diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 261f70f69b..8f4c89ac30 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -6,6 +6,7 @@ on:
       - "bitwindow/server/**"
       - "sidechain-orchestrator/**"
       - "dc-hub/server/**"
+      - "ecash-broadcaster/**"
       - "sqlitemigrate/**"
       - "coinnews/codec/**"
       - "coinnews/server/**"
@@ -40,6 +41,7 @@ jobs:
           - bitwindow/server
           - sidechain-orchestrator
           - dc-hub/server
+          - ecash-broadcaster
           - sqlitemigrate
           - coinnews/codec
           - coinnews/server
diff --git a/bitassets/pubspec.yaml b/bitassets/pubspec.yaml
index 904e07e60b..ef3241d609 100644
--- a/bitassets/pubspec.yaml
+++ b/bitassets/pubspec.yaml
@@ -2,7 +2,7 @@ name: bitassets
 description: UI for Drivechain (BIP300/301) based sidechains
 publish_to: "none" # Remove this line if you wish to publish to pub.dev
 
-version: 1.0.369
+version: 1.0.370
 
 environment:
   sdk: 3.13.5
diff --git a/bitnames/pubspec.yaml b/bitnames/pubspec.yaml
index 1da7ff63b7..3442c2d493 100644
--- a/bitnames/pubspec.yaml
+++ b/bitnames/pubspec.yaml
@@ -2,7 +2,7 @@ name: bitnames
 description: UI for Drivechain (BIP300/301) based sidechains
 publish_to: "none" # Remove this line if you wish to publish to pub.dev
 
-version: 1.0.370
+version: 1.0.371
 
 environment:
   sdk: 3.13.5
diff --git a/bitwindow/pubspec.yaml b/bitwindow/pubspec.yaml
index a5d454679d..a4e2c49e7b 100644
--- a/bitwindow/pubspec.yaml
+++ b/bitwindow/pubspec.yaml
@@ -3,7 +3,7 @@ description:
   "A frontend for interacting with a Drivechain-enabled layer 1 bitcoin network."
 publish_to: "none"
 
-version: 0.2.249
+version: 0.2.250
 
 environment:
   sdk: 3.13.5
diff --git a/bitwindow/server/api/bitdrive/bitdrive.go b/bitwindow/server/api/bitdrive/bitdrive.go
index 3747b8bc6e..1be3d89ff2 100644
--- a/bitwindow/server/api/bitdrive/bitdrive.go
+++ b/bitwindow/server/api/bitdrive/bitdrive.go
@@ -3,10 +3,9 @@ package bitdrive
 import (
 	"context"
 	"database/sql"
-	"errors"
 	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -36,36 +35,36 @@ type Server struct {
 }
 
 // StoreFile implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) StoreFile(ctx context.Context, req *connect.Request[bitdrivev1.StoreFileRequest]) (*connect.Response[bitdrivev1.StoreFileResponse], error) {
-	if len(req.Msg.Content) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("content is required"))
+func (s *Server) StoreFile(ctx context.Context, req *bitdrivev1.StoreFileRequest) (*bitdrivev1.StoreFileResponse, error) {
+	if len(req.Content) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "content is required")
 	}
 
-	txid, fileType, err := s.bitdriveEngine.StoreFile(ctx, req.Msg.Content, req.Msg.Encrypt, req.Msg.FeeSatPerVbyte)
+	txid, fileType, err := s.bitdriveEngine.StoreFile(ctx, req.Content, req.Encrypt, req.FeeSatPerVbyte)
 	if err != nil {
 		return nil, err
 	}
 
-	return connect.NewResponse(&bitdrivev1.StoreFileResponse{
+	return &bitdrivev1.StoreFileResponse{
 		Txid:      txid,
 		FileType:  fileType,
-		Encrypted: req.Msg.Encrypt,
-	}), nil
+		Encrypted: req.Encrypt,
+	}, nil
 }
 
 // RetrieveContent implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) RetrieveContent(ctx context.Context, req *connect.Request[bitdrivev1.RetrieveContentRequest]) (*connect.Response[bitdrivev1.RetrieveContentResponse], error) {
-	if req.Msg.Txid == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("txid is required"))
+func (s *Server) RetrieveContent(ctx context.Context, req *bitdrivev1.RetrieveContentRequest) (*bitdrivev1.RetrieveContentResponse, error) {
+	if req.Txid == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "txid is required")
 	}
 
-	opReturn, err := opreturns.GetByTxID(ctx, s.database, req.Msg.Txid)
+	opReturn, err := opreturns.GetByTxID(ctx, s.database, req.Txid)
 	if err != nil {
 		return nil, fmt.Errorf("get OP_RETURN: %w", err)
 	}
 
 	if opReturn == nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("OP_RETURN not found for txid %s", req.Msg.Txid))
+		return nil, connect.Errorf(connect.CodeNotFound, "OP_RETURN not found for txid %s", req.Txid)
 	}
 
 	// Decode content
@@ -75,22 +74,22 @@ func (s *Server) RetrieveContent(ctx context.Context, req *connect.Request[bitdr
 		return nil, fmt.Errorf("decode OP_RETURN data: %w", err)
 	}
 
-	return connect.NewResponse(&bitdrivev1.RetrieveContentResponse{
+	return &bitdrivev1.RetrieveContentResponse{
 		Content:   content,
 		FileType:  metadata.FileType,
 		Encrypted: metadata.Encrypted,
 		Timestamp: metadata.Timestamp,
-	}), nil
+	}, nil
 }
 
 // ScanForFiles implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) ScanForFiles(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[bitdrivev1.ScanForFilesResponse], error) {
+func (s *Server) ScanForFiles(ctx context.Context, req *emptypb.Empty) (*bitdrivev1.ScanForFilesResponse, error) {
 	pending, scanned, err := s.bitdriveEngine.ScanForFiles(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("scan for files: %w", err)
 	}
 
-	return connect.NewResponse(&bitdrivev1.ScanForFilesResponse{
+	return &bitdrivev1.ScanForFilesResponse{
 		PendingFiles: lo.Map(pending, func(p engines.PendingBitDriveFile, _ int) *bitdrivev1.PendingFile {
 			return &bitdrivev1.PendingFile{
 				Txid:      p.OPReturn.TxID,
@@ -101,34 +100,34 @@ func (s *Server) ScanForFiles(ctx context.Context, req *connect.Request[emptypb.
 			}
 		}),
 		TotalScanned: uint32(scanned),
-	}), nil
+	}, nil
 }
 
 // DownloadPendingFiles implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) DownloadPendingFiles(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[bitdrivev1.DownloadPendingFilesResponse], error) {
+func (s *Server) DownloadPendingFiles(ctx context.Context, req *emptypb.Empty) (*bitdrivev1.DownloadPendingFilesResponse, error) {
 	downloaded, failed, err := s.bitdriveEngine.DownloadPendingFiles(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("download pending files: %w", err)
 	}
 
-	return connect.NewResponse(&bitdrivev1.DownloadPendingFilesResponse{
+	return &bitdrivev1.DownloadPendingFilesResponse{
 		DownloadedCount: downloaded,
 		FailedCount:     failed,
-	}), nil
+	}, nil
 }
 
 // ListFiles implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) ListFiles(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[bitdrivev1.ListFilesResponse], error) {
+func (s *Server) ListFiles(ctx context.Context, req *emptypb.Empty) (*bitdrivev1.ListFilesResponse, error) {
 	files, err := s.bitdriveEngine.ListFiles(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("list files: %w", err)
 	}
 
-	return connect.NewResponse(&bitdrivev1.ListFilesResponse{
+	return &bitdrivev1.ListFilesResponse{
 		Files: lo.Map(files, func(f bitdrive.File, _ int) *bitdrivev1.BitDriveFile {
 			return fileToProto(f)
 		}),
-	}), nil
+	}, nil
 }
 
 func fileToProto(f bitdrive.File) *bitdrivev1.BitDriveFile {
@@ -145,24 +144,24 @@ func fileToProto(f bitdrive.File) *bitdrivev1.BitDriveFile {
 }
 
 // GetFile implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) GetFile(ctx context.Context, req *connect.Request[bitdrivev1.GetFileRequest]) (*connect.Response[bitdrivev1.GetFileResponse], error) {
+func (s *Server) GetFile(ctx context.Context, req *bitdrivev1.GetFileRequest) (*bitdrivev1.GetFileResponse, error) {
 	var file *bitdrive.File
 	var err error
 
 	switch {
-	case req.Msg.Id > 0:
-		file, err = bitdrive.GetByID(ctx, s.database, req.Msg.Id)
-	case req.Msg.Txid != "":
-		file, err = bitdrive.GetByTxID(ctx, s.database, req.Msg.Txid)
+	case req.Id > 0:
+		file, err = bitdrive.GetByID(ctx, s.database, req.Id)
+	case req.Txid != "":
+		file, err = bitdrive.GetByTxID(ctx, s.database, req.Txid)
 	default:
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("id or txid is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "id or txid is required")
 	}
 
 	if err != nil {
 		return nil, fmt.Errorf("get file: %w", err)
 	}
 	if file == nil {
-		return nil, connect.NewError(connect.CodeNotFound, errors.New("file not found"))
+		return nil, connect.NewError(connect.CodeNotFound, "file not found")
 	}
 
 	// Read file content
@@ -171,61 +170,61 @@ func (s *Server) GetFile(ctx context.Context, req *connect.Request[bitdrivev1.Ge
 		return nil, fmt.Errorf("read file content: %w", err)
 	}
 
-	return connect.NewResponse(&bitdrivev1.GetFileResponse{
+	return &bitdrivev1.GetFileResponse{
 		File:    fileToProto(*file),
 		Content: content,
-	}), nil
+	}, nil
 }
 
 // DeleteFile implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) DeleteFile(ctx context.Context, req *connect.Request[bitdrivev1.DeleteFileRequest]) (*connect.Response[emptypb.Empty], error) {
-	if req.Msg.Id <= 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("id is required"))
+func (s *Server) DeleteFile(ctx context.Context, req *bitdrivev1.DeleteFileRequest) (*emptypb.Empty, error) {
+	if req.Id <= 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "id is required")
 	}
 
-	if err := s.bitdriveEngine.DeleteFile(ctx, req.Msg.Id); err != nil {
+	if err := s.bitdriveEngine.DeleteFile(ctx, req.Id); err != nil {
 		return nil, fmt.Errorf("delete file: %w", err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // StoreMultisigData implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) StoreMultisigData(ctx context.Context, req *connect.Request[bitdrivev1.StoreMultisigDataRequest]) (*connect.Response[bitdrivev1.StoreMultisigDataResponse], error) {
-	if len(req.Msg.JsonData) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("json_data is required"))
+func (s *Server) StoreMultisigData(ctx context.Context, req *bitdrivev1.StoreMultisigDataRequest) (*bitdrivev1.StoreMultisigDataResponse, error) {
+	if len(req.JsonData) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "json_data is required")
 	}
 
-	txid, err := s.bitdriveEngine.StoreMultisigData(ctx, req.Msg.JsonData, req.Msg.Encrypt, req.Msg.FeeSatPerVbyte)
+	txid, err := s.bitdriveEngine.StoreMultisigData(ctx, req.JsonData, req.Encrypt, req.FeeSatPerVbyte)
 	if err != nil {
 		return nil, err
 	}
 
-	return connect.NewResponse(&bitdrivev1.StoreMultisigDataResponse{
+	return &bitdrivev1.StoreMultisigDataResponse{
 		Txid: txid,
-	}), nil
+	}, nil
 }
 
 // WipeData implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) WipeData(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
+func (s *Server) WipeData(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
 	if err := s.bitdriveEngine.WipeData(ctx); err != nil {
 		return nil, fmt.Errorf("wipe data: %w", err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // GetBitdriveDir implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) GetBitdriveDir(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[bitdrivev1.GetBitdriveDirResponse], error) {
-	return connect.NewResponse(&bitdrivev1.GetBitdriveDirResponse{
+func (s *Server) GetBitdriveDir(ctx context.Context, req *emptypb.Empty) (*bitdrivev1.GetBitdriveDirResponse, error) {
+	return &bitdrivev1.GetBitdriveDirResponse{
 		Path: s.bitdriveEngine.GetDir(),
-	}), nil
+	}, nil
 }
 
 // OpenBitdriveDir implements bitdrivev1connect.BitDriveServiceHandler.
-func (s *Server) OpenBitdriveDir(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
+func (s *Server) OpenBitdriveDir(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
 	if err := s.bitdriveEngine.OpenDir(ctx); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("open bitdrive dir: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("open bitdrive dir: %s", err)).WithCause(err)
 	}
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
diff --git a/bitwindow/server/api/bitwindowd/bitwindowd.go b/bitwindow/server/api/bitwindowd/bitwindowd.go
index 0ad966fb7c..dde0ec916b 100644
--- a/bitwindow/server/api/bitwindowd/bitwindowd.go
+++ b/bitwindow/server/api/bitwindowd/bitwindowd.go
@@ -15,7 +15,8 @@ import (
 	"sync/atomic"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/btcutil"
@@ -138,60 +139,60 @@ func (s *Server) observeTip(height uint32, hash string) (changed bool) {
 //     one, rebuilds engines + sub-handlers, atomic-swaps the listener mux.
 //     The HTTP server stays bound to the same port across the swap.
 //  3. Return success.
-func (s *Server) UpdateNetwork(ctx context.Context, req *connect.Request[pb.UpdateNetworkRequest]) (*connect.Response[pb.UpdateNetworkResponse], error) {
-	if req.Msg.Network == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("network required"))
+func (s *Server) UpdateNetwork(ctx context.Context, req *pb.UpdateNetworkRequest) (*pb.UpdateNetworkResponse, error) {
+	if req.Network == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "network required")
 	}
 
-	network := config.Network(req.Msg.Network)
+	network := config.Network(req.Network)
 	if !isKnownNetwork(network) {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("unknown network: %q", req.Msg.Network))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "unknown network: %q", req.Network)
 	}
 
 	confClient := dial.BitcoinConf(s.config.OrchestratorAddr, s.config.BitwindowDir())
 	// The orchestrator takes the catalog id; this server takes the network it
 	// belongs to, because its own runtime is per-network.
-	target := req.Msg.NetworkId
+	target := req.NetworkId
 	if target == "" {
-		target = req.Msg.Network
+		target = req.Network
 	}
 	// Planned before the switch runs: once it has, the plan reads as a no-op.
 	var resetFrom uint32
-	if network == config.NetworkECash && req.Msg.NetworkId != "" {
-		plan, err := confClient.PlanECashSwitch(ctx, connect.NewRequest(&orchpb.PlanECashSwitchRequest{
-			NetworkId: req.Msg.NetworkId,
-		}))
+	if network == config.NetworkECash && req.NetworkId != "" {
+		plan, err := confClient.PlanECashSwitch(ctx, &orchpb.PlanECashSwitchRequest{
+			NetworkId: req.NetworkId,
+		})
 		if err != nil {
-			return nil, connect.NewError(connect.CodeOf(err), fmt.Errorf("orchestrator.PlanECashSwitch: %w", err))
+			return nil, connect.NewError(connect.CodeOf(err), fmt.Sprintf("orchestrator.PlanECashSwitch: %s", err)).WithCause(err)
 		}
-		if plan.Msg.NeedsRollback {
-			resetFrom = plan.Msg.RewindHeight + 1
+		if plan.NeedsRollback {
+			resetFrom = plan.RewindHeight + 1
 		} else {
 			// A completed migration already moved Core, so the switch plan has no rollback.
 			client := dial.Orchestrator(s.config.OrchestratorAddr, s.config.BitwindowDir())
-			status, err := client.GetECashMigrationStatus(ctx, connect.NewRequest(&orchpb.GetECashMigrationStatusRequest{}))
+			status, err := client.GetECashMigrationStatus(ctx, &orchpb.GetECashMigrationStatusRequest{})
 			if err != nil {
-				return nil, connect.NewError(connect.CodeOf(err), fmt.Errorf("orchestrator.GetECashMigrationStatus: %w", err))
+				return nil, connect.NewError(connect.CodeOf(err), fmt.Sprintf("orchestrator.GetECashMigrationStatus: %s", err)).WithCause(err)
 			}
-			migration := status.Msg.GetStatus()
+			migration := status.GetStatus()
 			if migration.GetComplete() && migration.GetToId() == target && !migration.GetWalletOnly() {
 				resetFrom = uint32(migration.GetCommonHeight()) + 1
 			}
 		}
 	}
-	if _, err := confClient.SetBitcoinConfigNetwork(ctx, connect.NewRequest(&orchpb.SetBitcoinConfigNetworkRequest{
+	if _, err := confClient.SetBitcoinConfigNetwork(ctx, &orchpb.SetBitcoinConfigNetworkRequest{
 		Network: target,
-		DataDir: req.Msg.DataDir,
-	})); err != nil {
-		return nil, connect.NewError(connect.CodeOf(err), fmt.Errorf("orchestrator.SetBitcoinConfigNetwork: %w", err))
+		DataDir: req.DataDir,
+	}); err != nil {
+		return nil, connect.NewError(connect.CodeOf(err), fmt.Sprintf("orchestrator.SetBitcoinConfigNetwork: %s", err)).WithCause(err)
 	}
 
 	if err := s.recycle(ctx, network, target, resetFrom); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("recycle runtime to %s: %w", network, err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("recycle runtime to %s: %s", network, err)).WithCause(err)
 	}
 
-	zerolog.Ctx(ctx).Info().Str("network", req.Msg.Network).Msg("network swap complete (in-process)")
-	return connect.NewResponse(&pb.UpdateNetworkResponse{}), nil
+	zerolog.Ctx(ctx).Info().Str("network", req.Network).Msg("network swap complete (in-process)")
+	return &pb.UpdateNetworkResponse{}, nil
 }
 
 func isKnownNetwork(n config.Network) bool {
@@ -209,10 +210,10 @@ func isKnownNetwork(n config.Network) bool {
 // own teardown. Acks the frontend in milliseconds so the window can
 // windowManager.destroy() immediately. With skip_downstream=true the
 // drivechaind stack stays running (only bitwindowd dies).
-func (s *Server) Stop(ctx context.Context, req *connect.Request[pb.BitwindowdServiceStopRequest]) (*connect.Response[emptypb.Empty], error) {
+func (s *Server) Stop(ctx context.Context, req *pb.BitwindowdServiceStopRequest) (*emptypb.Empty, error) {
 	log := zerolog.Ctx(ctx)
 
-	if req.Msg.SkipDownstream {
+	if req.SkipDownstream {
 		log.Info().Msg("skip_downstream=true, bitwindowd-only exit (drivechaind stays running)")
 	} else {
 		client := dial.Orchestrator(s.config.OrchestratorAddr, s.config.BitwindowDir())
@@ -222,7 +223,7 @@ func (s *Server) Stop(ctx context.Context, req *connect.Request[pb.BitwindowdSer
 		rpcCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
 		defer cancel()
 		// only_if_last: a sidechain frontend may hold drivechaind directly.
-		if _, err := client.Shutdown(rpcCtx, connect.NewRequest(&orchpb.ShutdownRequest{OnlyIfLast: true})); err != nil {
+		if _, err := client.Shutdown(rpcCtx, &orchpb.ShutdownRequest{OnlyIfLast: true}); err != nil {
 			log.Warn().Err(err).Msg("relay Shutdown to drivechaind (continuing with bitwindowd teardown)")
 		} else {
 			log.Info().Msg("drivechaind Shutdown relayed; it will drain children in the background")
@@ -236,94 +237,94 @@ func (s *Server) Stop(ctx context.Context, req *connect.Request[pb.BitwindowdSer
 		s.onShutdown(context.WithoutCancel(ctx))
 	}()
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 func (s *Server) CreateDenial(
 	ctx context.Context,
-	req *connect.Request[pb.CreateDenialRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	if req.Msg.DelaySeconds <= 0 {
+	req *pb.CreateDenialRequest,
+) (*emptypb.Empty, error) {
+	if req.DelaySeconds <= 0 {
 		err := errors.New("delay_seconds must be positive")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	if req.Msg.NumHops <= 0 {
+	if req.NumHops <= 0 {
 		err := errors.New("num_hops must be positive")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// Get active wallet to determine routing
 	activeWallet, err := s.walletEngine.GetActiveWallet(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get active wallet: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get active wallet: %s", err)).WithCause(err)
 	}
 
 	// Deniability requires spending, which a watch-only wallet cannot do.
 	if activeWallet.IsWatchOnly() {
 		err := errors.New("deniability is not supported for watch-only wallets")
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	// List UTXOs based on wallet type
 	var utxoExists bool
 	switch activeWallet.WalletType {
 	case engines.WalletTypeBitcoinCore:
-		utxoExists, err = s.checkBitcoinCoreUTXO(ctx, activeWallet.ID, req.Msg.Txid, req.Msg.Vout)
+		utxoExists, err = s.checkBitcoinCoreUTXO(ctx, activeWallet.ID, req.Txid, req.Vout)
 	case engines.WalletTypeElectrum:
-		utxoExists, err = s.checkElectrumUTXO(ctx, activeWallet.ID, req.Msg.Txid, req.Msg.Vout)
+		utxoExists, err = s.checkElectrumUTXO(ctx, activeWallet.ID, req.Txid, req.Vout)
 	default:
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("unknown wallet type: %s", activeWallet.WalletType))
+		return nil, connect.Errorf(connect.CodeInternal, "unknown wallet type: %s", activeWallet.WalletType)
 	}
 	if err != nil {
 		return nil, err
 	}
 
 	if !utxoExists {
-		err := fmt.Errorf("utxo %s:%d not found in wallet", req.Msg.Txid, req.Msg.Vout)
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		err := fmt.Errorf("utxo %s:%d not found in wallet", req.Txid, req.Vout)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	denial, err := deniability.GetByTip(ctx, s.db, req.Msg.Txid, lo.ToPtr(int32(req.Msg.Vout)))
+	denial, err := deniability.GetByTip(ctx, s.db, req.Txid, lo.ToPtr(int32(req.Vout)))
 	if err != nil {
 		err = fmt.Errorf("get by tip: %w", err)
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	if denial != nil {
 		if denial.CancelledAt == nil && (denial.NextExecution != nil || denial.PausedAt != nil) {
-			return nil, connect.NewError(connect.CodeAlreadyExists,
-				fmt.Errorf("denial %d already runs for %s:%d", denial.ID, req.Msg.Txid, req.Msg.Vout))
+			return nil, connect.Errorf(connect.CodeAlreadyExists,
+				"denial %d already runs for %s:%d", denial.ID, req.Txid, req.Vout)
 		}
 
 		zerolog.Ctx(ctx).Info().
 			Int64("denial_id", denial.ID).
-			Str("txid", req.Msg.Txid).
-			Uint32("vout", req.Msg.Vout).
-			Int32("delay_seconds", req.Msg.DelaySeconds).
-			Int32("num_hops", req.Msg.NumHops).
+			Str("txid", req.Txid).
+			Uint32("vout", req.Vout).
+			Int32("delay_seconds", req.DelaySeconds).
+			Int32("num_hops", req.NumHops).
 			Msg("CreateDenial: continue a stopped denial")
 
-		targetSizes := make(deniability.TargetSizes, denial.NumHops, int(denial.NumHops)+len(req.Msg.TargetUtxoSizes))
+		targetSizes := make(deniability.TargetSizes, denial.NumHops, int(denial.NumHops)+len(req.TargetUtxoSizes))
 		copy(targetSizes, denial.TargetUTXOSizes)
-		targetSizes = append(targetSizes, req.Msg.TargetUtxoSizes...)
+		targetSizes = append(targetSizes, req.TargetUtxoSizes...)
 		if err := deniability.Update(
-			ctx, s.db, denial.ID, time.Duration(req.Msg.DelaySeconds)*time.Second, req.Msg.NumHops,
-			targetSizes, req.Msg.Txid, int32(req.Msg.Vout),
+			ctx, s.db, denial.ID, time.Duration(req.DelaySeconds)*time.Second, req.NumHops,
+			targetSizes, req.Txid, int32(req.Vout),
 		); err != nil {
-			return nil, connect.NewError(connect.CodeInternal, err)
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 
-		return connect.NewResponse(&emptypb.Empty{}), nil
+		return &emptypb.Empty{}, nil
 	}
 
 	zerolog.Ctx(ctx).Info().
-		Str("txid", req.Msg.Txid).
-		Uint32("vout", req.Msg.Vout).
-		Int32("delay_seconds", req.Msg.DelaySeconds).
-		Int32("num_hops", req.Msg.NumHops).
+		Str("txid", req.Txid).
+		Uint32("vout", req.Vout).
+		Int32("delay_seconds", req.DelaySeconds).
+		Int32("num_hops", req.NumHops).
 		Str("wallet_id", activeWallet.ID).
-		Ints64("target_utxo_sizes", req.Msg.TargetUtxoSizes).
+		Ints64("target_utxo_sizes", req.TargetUtxoSizes).
 		Msg("CreateDenial: creating new denial")
 
 	// UTXO exists, create the denial with the wallet ID
@@ -331,91 +332,91 @@ func (s *Server) CreateDenial(
 		ctx,
 		s.db,
 		activeWallet.ID,
-		req.Msg.Txid,
-		int32(req.Msg.Vout),
-		time.Duration(req.Msg.DelaySeconds)*time.Second,
-		req.Msg.NumHops,
-		req.Msg.TargetUtxoSizes,
+		req.Txid,
+		int32(req.Vout),
+		time.Duration(req.DelaySeconds)*time.Second,
+		req.NumHops,
+		req.TargetUtxoSizes,
 	)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 func (s *Server) CancelDenial(
 	ctx context.Context,
-	req *connect.Request[pb.CancelDenialRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	err := deniability.Cancel(ctx, s.db, req.Msg.Id, "cancelled by user")
+	req *pb.CancelDenialRequest,
+) (*emptypb.Empty, error) {
+	err := deniability.Cancel(ctx, s.db, req.Id, "cancelled by user")
 	switch {
 	case errors.Is(err, deniability.ErrNotFound):
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 func (s *Server) PauseDenial(
 	ctx context.Context,
-	req *connect.Request[pb.PauseDenialRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	err := deniability.Pause(ctx, s.db, req.Msg.Id)
+	req *pb.PauseDenialRequest,
+) (*emptypb.Empty, error) {
+	err := deniability.Pause(ctx, s.db, req.Id)
 	switch {
 	case errors.Is(err, deniability.ErrNotFound):
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("pause denial %d: %w", req.Msg.Id, err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("pause denial %d: %s", req.Id, err)).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 func (s *Server) ResumeDenial(
 	ctx context.Context,
-	req *connect.Request[pb.ResumeDenialRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	err := deniability.Resume(ctx, s.db, req.Msg.Id)
+	req *pb.ResumeDenialRequest,
+) (*emptypb.Empty, error) {
+	err := deniability.Resume(ctx, s.db, req.Id)
 	switch {
 	case errors.Is(err, deniability.ErrNotFound):
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("resume denial %d: %w", req.Msg.Id, err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("resume denial %d: %s", req.Id, err)).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
-func (s *Server) CreateAddressBookEntry(ctx context.Context, req *connect.Request[pb.CreateAddressBookEntryRequest]) (*connect.Response[pb.CreateAddressBookEntryResponse], error) {
-	direction, err := addressbook.DirectionFromProto(req.Msg.Direction)
+func (s *Server) CreateAddressBookEntry(ctx context.Context, req *pb.CreateAddressBookEntryRequest) (*pb.CreateAddressBookEntryResponse, error) {
+	direction, err := addressbook.DirectionFromProto(req.Direction)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	addr := strings.TrimSpace(req.Msg.Address)
+	addr := strings.TrimSpace(req.Address)
 	if err := validateAddressBookAddress(addr); err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// A label must map to a single address. Saving the same address again
 	// sets its label.
-	if err := s.checkLabelFree(ctx, strings.TrimSpace(req.Msg.Label), func(entry addressbook.Entry) bool {
+	if err := s.checkLabelFree(ctx, strings.TrimSpace(req.Label), func(entry addressbook.Entry) bool {
 		return entry.Address == addr
 	}); err != nil {
 		return nil, err
 	}
 
 	// User-added addresses don't belong to a specific wallet (nil walletID)
-	if err := addressbook.Upsert(ctx, s.db, nil, req.Msg.Label, addr, direction); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+	if err := addressbook.Upsert(ctx, s.db, nil, req.Label, addr, direction); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	entries, err := addressbook.List(ctx, s.db)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	entry, ok := lo.Find(entries, func(entry addressbook.Entry) bool {
@@ -423,12 +424,12 @@ func (s *Server) CreateAddressBookEntry(ctx context.Context, req *connect.Reques
 	})
 	if !ok {
 		err := fmt.Errorf("entry %s/%s missing after save", addr, direction)
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.CreateAddressBookEntryResponse{
+	return &pb.CreateAddressBookEntryResponse{
 		Entry: EntryToProto(&entry),
-	}), nil
+	}, nil
 }
 
 func validateAddressBookAddress(addr string) error {
@@ -450,12 +451,12 @@ func (s *Server) checkLabelFree(ctx context.Context, label string, self func(add
 	}
 	entries, err := addressbook.List(ctx, s.db)
 	if err != nil {
-		return connect.NewError(connect.CodeInternal, fmt.Errorf("list address book entries: %w", err))
+		return connect.NewError(connect.CodeInternal, fmt.Sprintf("list address book entries: %s", err)).WithCause(err)
 	}
 	if lo.ContainsBy(entries, func(entry addressbook.Entry) bool {
 		return !self(entry) && strings.EqualFold(strings.TrimSpace(entry.Label), label)
 	}) {
-		return connect.NewError(connect.CodeAlreadyExists, fmt.Errorf("an address book entry with label %q already exists", label))
+		return connect.Errorf(connect.CodeAlreadyExists, "an address book entry with label %q already exists", label)
 	}
 	return nil
 }
@@ -476,10 +477,10 @@ func EntryToProto(entry *addressbook.Entry) *pb.AddressBookEntry {
 	}
 }
 
-func (s *Server) ListAddressBook(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[pb.ListAddressBookResponse], error) {
+func (s *Server) ListAddressBook(ctx context.Context, req *emptypb.Empty) (*pb.ListAddressBookResponse, error) {
 	entries, err := addressbook.List(ctx, s.db)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	var pbEntries []*pb.AddressBookEntry
@@ -487,58 +488,58 @@ func (s *Server) ListAddressBook(ctx context.Context, req *connect.Request[empty
 		pbEntries = append(pbEntries, EntryToProto(&entries[i]))
 	}
 
-	return connect.NewResponse(&pb.ListAddressBookResponse{
+	return &pb.ListAddressBookResponse{
 		Entries: pbEntries,
-	}), nil
+	}, nil
 }
 
-func (s *Server) UpdateAddressBookEntry(ctx context.Context, req *connect.Request[pb.UpdateAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error) {
-	if err := s.checkLabelFree(ctx, strings.TrimSpace(req.Msg.Label), func(entry addressbook.Entry) bool {
-		return entry.ID == req.Msg.Id
+func (s *Server) UpdateAddressBookEntry(ctx context.Context, req *pb.UpdateAddressBookEntryRequest) (*emptypb.Empty, error) {
+	if err := s.checkLabelFree(ctx, strings.TrimSpace(req.Label), func(entry addressbook.Entry) bool {
+		return entry.ID == req.Id
 	}); err != nil {
 		return nil, err
 	}
 
-	err := addressbook.UpdateLabel(ctx, s.db, req.Msg.Id, req.Msg.Label)
+	err := addressbook.UpdateLabel(ctx, s.db, req.Id, req.Label)
 	switch {
 	case errors.Is(err, sql.ErrNoRows):
-		return nil, connect.NewError(connect.CodeNotFound, errors.New("address book entry not found"))
+		return nil, connect.NewError(connect.CodeNotFound, "address book entry not found")
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
-func (s *Server) DeleteAddressBookEntry(ctx context.Context, req *connect.Request[pb.DeleteAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error) {
-	err := addressbook.Delete(ctx, s.db, req.Msg.Id)
+func (s *Server) DeleteAddressBookEntry(ctx context.Context, req *pb.DeleteAddressBookEntryRequest) (*emptypb.Empty, error) {
+	err := addressbook.Delete(ctx, s.db, req.Id)
 	switch {
 	case errors.Is(err, sql.ErrNoRows):
-		return nil, connect.NewError(connect.CodeNotFound, errors.New("address book entry not found"))
+		return nil, connect.NewError(connect.CodeNotFound, "address book entry not found")
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // GetSyncInfo implements bitwindowdv1connect.BitwindowdServiceHandler.
-func (s *Server) GetSyncInfo(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[pb.GetSyncInfoResponse], error) {
+func (s *Server) GetSyncInfo(ctx context.Context, req *emptypb.Empty) (*pb.GetSyncInfoResponse, error) {
 	bitcoind, err := s.bitcoind.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	tip, err := bitcoind.GetBlockchainInfo(ctx, connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	tip, err := bitcoind.GetBlockchainInfo(ctx, connectv1.NewRequest(&corepb.GetBlockchainInfoRequest{}))
 	if err != nil {
 		// Bitcoin Core returns -28 from every RPC while it's still loading the
 		// block index, verifying blocks, or rescanning the wallet. Treat that
 		// as "still booting" and surface the message so the UI can render
 		// "Verifying blocks…" instead of a misleading "0 / 0 blocks" state.
 		if msg := engines.ExtractBitcoindStartupMessage(err.Error()); msg != "" {
-			return connect.NewResponse(&pb.GetSyncInfoResponse{
+			return &pb.GetSyncInfoResponse{
 				StartupMessage: msg,
-			}), nil
+			}, nil
 		}
 		return nil, err
 	}
@@ -546,13 +547,13 @@ func (s *Server) GetSyncInfo(ctx context.Context, req *connect.Request[emptypb.E
 	processedTip, err := blocks.GetProcessedTip(ctx, s.db)
 	if err != nil {
 		zerolog.Ctx(ctx).Error().Err(err).Msg("get processed tip")
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	waitsForCore := engines.WaitsForCore(tip.Msg.InitialBlockDownload, s.config.BitcoinCoreNetwork)
 
 	if processedTip == nil {
-		return connect.NewResponse(&pb.GetSyncInfoResponse{
+		return &pb.GetSyncInfoResponse{
 			TipBlockHeight:      0,
 			TipBlockTime:        0,
 			TipBlockHash:        "",
@@ -560,7 +561,7 @@ func (s *Server) GetSyncInfo(ctx context.Context, req *connect.Request[emptypb.E
 			HeaderHeight:        int64(tip.Msg.Headers),
 			SyncProgress:        0,
 			WaitsForCore:        waitsForCore,
-		}), nil
+		}, nil
 	}
 
 	var syncProgress float64
@@ -568,7 +569,7 @@ func (s *Server) GetSyncInfo(ctx context.Context, req *connect.Request[emptypb.E
 		syncProgress = float64(processedTip.Height) / float64(tip.Msg.Blocks)
 	}
 
-	return connect.NewResponse(&pb.GetSyncInfoResponse{
+	return &pb.GetSyncInfoResponse{
 		TipBlockHeight:      int64(processedTip.Height),
 		TipBlockTime:        processedTip.ProcessedAt.Unix(),
 		TipBlockHash:        processedTip.Hash.String(),
@@ -576,53 +577,53 @@ func (s *Server) GetSyncInfo(ctx context.Context, req *connect.Request[emptypb.E
 		SyncProgress:        syncProgress,
 		HeaderHeight:        int64(tip.Msg.Headers),
 		WaitsForCore:        waitsForCore,
-	}), nil
+	}, nil
 }
 
 // SetTransactionNote implements bitwindowdv1connect.BitwindowdServiceHandler.
-func (s *Server) SetTransactionNote(ctx context.Context, req *connect.Request[pb.SetTransactionNoteRequest]) (*connect.Response[emptypb.Empty], error) {
-	walletID := req.Msg.WalletId
+func (s *Server) SetTransactionNote(ctx context.Context, req *pb.SetTransactionNoteRequest) (*emptypb.Empty, error) {
+	walletID := req.WalletId
 	if walletID == "" {
 		activeWallet, err := s.walletEngine.GetActiveWallet(ctx)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("get active wallet: %w", err))
+			return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Sprintf("get active wallet: %s", err)).WithCause(err)
 		}
 		walletID = activeWallet.ID
 	}
 
-	err := transactions.SetNote(ctx, s.db, walletID, req.Msg.Txid, req.Msg.Note)
+	err := transactions.SetNote(ctx, s.db, walletID, req.Txid, req.Note)
 	switch {
 	case errors.Is(err, transactions.ErrEmptyTxID):
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // ExportLabels implements bitwindowdv1connect.BitwindowdServiceHandler.
-func (s *Server) ExportLabels(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[pb.ExportLabelsResponse], error) {
+func (s *Server) ExportLabels(ctx context.Context, req *emptypb.Empty) (*pb.ExportLabelsResponse, error) {
 	addrs, err := addressbook.List(ctx, s.db)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	// BIP329 has no wallet field: a label file describes one wallet. Export the
 	// active wallet's notes, which is what importing one back in expects.
 	activeWallet, err := s.walletEngine.GetActiveWallet(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("get active wallet: %w", err))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Sprintf("get active wallet: %s", err)).WithCause(err)
 	}
 
 	notes, err := transactions.ListByWallet(ctx, s.db, activeWallet.ID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	utxos, err := utxometadata.Get(ctx, s.db, nil)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	var labels []bip329.Label
@@ -647,23 +648,23 @@ func (s *Server) ExportLabels(ctx context.Context, req *connect.Request[emptypb.
 
 	jsonl, err := bip329.Encode(labels)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.ExportLabelsResponse{Jsonl: jsonl}), nil
+	return &pb.ExportLabelsResponse{Jsonl: jsonl}, nil
 }
 
 // ImportLabels implements bitwindowdv1connect.BitwindowdServiceHandler.
-func (s *Server) ImportLabels(ctx context.Context, req *connect.Request[pb.ImportLabelsRequest]) (*connect.Response[pb.ImportLabelsResponse], error) {
-	labels, skipped, err := bip329.Decode(req.Msg.Jsonl)
+func (s *Server) ImportLabels(ctx context.Context, req *pb.ImportLabelsRequest) (*pb.ImportLabelsResponse, error) {
+	labels, skipped, err := bip329.Decode(req.Jsonl)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// A BIP329 file describes one wallet, so its notes belong to the active one.
 	activeWallet, err := s.walletEngine.GetActiveWallet(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("get active wallet: %w", err))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Sprintf("get active wallet: %s", err)).WithCause(err)
 	}
 
 	resp := &pb.ImportLabelsResponse{Skipped: int64(skipped)}
@@ -727,62 +728,62 @@ func (s *Server) ImportLabels(ctx context.Context, req *connect.Request[pb.Impor
 		}
 	}
 
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 // GetFireplaceStats implements bitwindowdv1connect.BitwindowdServiceHandler.
-func (s *Server) GetFireplaceStats(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[pb.GetFireplaceStatsResponse], error) {
+func (s *Server) GetFireplaceStats(ctx context.Context, req *emptypb.Empty) (*pb.GetFireplaceStatsResponse, error) {
 	// Calculate block count in last 24 hours
 	blockCount24h, err := blocks.CountSince(ctx, s.db, time.Now().Add(-24*time.Hour))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get block count: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get block count: %s", err)).WithCause(err)
 	}
 
 	// Calculate transaction count in last 24 hours
 	txCount24h, err := blocks.TxCountSince(ctx, s.db, time.Now().Add(-24*time.Hour))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get transaction count: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get transaction count: %s", err)).WithCause(err)
 	}
 
 	// Calculate coinnews count in last 7 days
 	coinnewsCount7d, err := cnstore.CountStoriesSince(ctx, s.db, time.Now().Add(-7*24*time.Hour))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get coinnews count: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get coinnews count: %s", err)).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.GetFireplaceStatsResponse{
+	return &pb.GetFireplaceStatsResponse{
 		TransactionCount_24H: txCount24h,
 		CoinnewsCount_7D:     coinnewsCount7d,
 		BlockCount_24H:       blockCount24h,
-	}), nil
+	}, nil
 }
 
-func (s *Server) ListBlocks(ctx context.Context, c *connect.Request[pb.ListBlocksRequest]) (*connect.Response[pb.ListBlocksResponse], error) {
+func (s *Server) ListBlocks(ctx context.Context, c *pb.ListBlocksRequest) (*pb.ListBlocksResponse, error) {
 	bitcoind, err := s.bitcoind.Get(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("bitcoind: %w", err)
 	}
 
-	info, err := bitcoind.GetBlockchainInfo(ctx, connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	info, err := bitcoind.GetBlockchainInfo(ctx, connectv1.NewRequest(&corepb.GetBlockchainInfoRequest{}))
 	if err != nil {
 		return nil, fmt.Errorf("bitcoind: get blockchain info: %w", err)
 	}
 	if info.Msg.InitialBlockDownload && config.IsFullChainNetwork(s.config.BitcoinCoreNetwork) {
-		return connect.NewResponse(&pb.ListBlocksResponse{}), nil
+		return &pb.ListBlocksResponse{}, nil
 	}
 	currentTip := info.Msg.Blocks
 	currentHash := info.Msg.BestBlockHash
 
 	// Default to most recent blocks if no pagination
 	startHeight := currentTip
-	if c.Msg.StartHeight > 0 {
-		startHeight = c.Msg.StartHeight
+	if c.StartHeight > 0 {
+		startHeight = c.StartHeight
 	}
 
 	// Default page size
 	pageSize := uint32(50)
-	if c.Msg.PageSize > 0 {
-		pageSize = c.Msg.PageSize
+	if c.PageSize > 0 {
+		pageSize = c.PageSize
 	}
 
 	currentValidity := blocksTip{height: currentTip, hash: currentHash}
@@ -800,10 +801,10 @@ func (s *Server) ListBlocks(ctx context.Context, c *connect.Request[pb.ListBlock
 			// are shared and must be treated read-only by the caller.
 			out := make([]*pb.Block, len(entry.blocks))
 			copy(out, entry.blocks)
-			return connect.NewResponse(&pb.ListBlocksResponse{
+			return &pb.ListBlocksResponse{
 				RecentBlocks: out,
 				HasMore:      entry.hasMore,
-			}), nil
+			}, nil
 		}
 	}
 
@@ -819,7 +820,7 @@ func (s *Server) ListBlocks(ctx context.Context, c *connect.Request[pb.ListBlock
 			if height < 0 {
 				return nil, nil
 			}
-			hash, err := bitcoind.GetBlockHash(ctx, connect.NewRequest(&corepb.GetBlockHashRequest{
+			hash, err := bitcoind.GetBlockHash(ctx, connectv1.NewRequest(&corepb.GetBlockHashRequest{
 				Height: uint32(height),
 			}))
 			switch {
@@ -832,7 +833,7 @@ func (s *Server) ListBlocks(ctx context.Context, c *connect.Request[pb.ListBlock
 				return nil, fmt.Errorf("bitcoind: get block hash %d: %w", height, err)
 			}
 
-			block, err := bitcoind.GetBlock(ctx, connect.NewRequest(&corepb.GetBlockRequest{
+			block, err := bitcoind.GetBlock(ctx, connectv1.NewRequest(&corepb.GetBlockRequest{
 				Verbosity: corepb.GetBlockRequest_VERBOSITY_BLOCK_INFO,
 				Hash:      hash.Msg.Hash,
 			}))
@@ -887,20 +888,20 @@ func (s *Server) ListBlocks(ctx context.Context, c *connect.Request[pb.ListBlock
 
 	out := make([]*pb.Block, len(blocks))
 	copy(out, blocks)
-	return connect.NewResponse(&pb.ListBlocksResponse{
+	return &pb.ListBlocksResponse{
 		RecentBlocks: out,
 		HasMore:      hasMore,
-	}), nil
+	}, nil
 }
 
-func (s *Server) ListRecentTransactions(ctx context.Context, c *connect.Request[pb.ListRecentTransactionsRequest]) (*connect.Response[pb.ListRecentTransactionsResponse], error) {
+func (s *Server) ListRecentTransactions(ctx context.Context, c *pb.ListRecentTransactionsRequest) (*pb.ListRecentTransactionsResponse, error) {
 	bitcoind, err := s.bitcoind.Get(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("bitcoind: %w", err)
 	}
 
 	// First get mempool transactions
-	mempoolRes, err := bitcoind.GetRawMempool(ctx, connect.NewRequest(&corepb.GetRawMempoolRequest{
+	mempoolRes, err := bitcoind.GetRawMempool(ctx, connectv1.NewRequest(&corepb.GetRawMempoolRequest{
 		Verbose: true,
 	}))
 	if err != nil {
@@ -924,7 +925,7 @@ func (s *Server) ListRecentTransactions(ctx context.Context, c *connect.Request[
 			ConfirmedInBlock: nil,
 		})
 	}
-	info, err := bitcoind.GetBlockchainInfo(ctx, connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	info, err := bitcoind.GetBlockchainInfo(ctx, connectv1.NewRequest(&corepb.GetBlockchainInfoRequest{}))
 	if err != nil {
 		return nil, fmt.Errorf("bitcoind: get blockchain info: %w", err)
 	}
@@ -937,20 +938,20 @@ func (s *Server) ListRecentTransactions(ctx context.Context, c *connect.Request[
 	// its client timeout. The user has nothing useful to look at in that
 	// window anyway — return mempool only and bail.
 	if info.Msg.InitialBlockDownload && config.IsFullChainNetwork(s.config.BitcoinCoreNetwork) {
-		return connect.NewResponse(&pb.ListRecentTransactionsResponse{
+		return &pb.ListRecentTransactionsResponse{
 			Transactions: transactions,
-		}), nil
+		}, nil
 	}
 
 	// Resolve the requested count up front so the block walk can stop as
 	// soon as we have enough.
 	count := int64(100)
-	if c.Msg.Count > 0 {
-		count = c.Msg.Count
+	if c.Count > 0 {
+		count = c.Count
 	}
 
 	// Get block at latest height
-	blockHashRes, err := bitcoind.GetBlock(ctx, connect.NewRequest(&corepb.GetBlockRequest{
+	blockHashRes, err := bitcoind.GetBlock(ctx, connectv1.NewRequest(&corepb.GetBlockRequest{
 		Hash:      info.Msg.BestBlockHash,
 		Verbosity: corepb.GetBlockRequest_VERBOSITY_BLOCK_INFO,
 	}))
@@ -965,7 +966,7 @@ func (s *Server) ListRecentTransactions(ctx context.Context, c *connect.Request[
 	currentHash := blockHashRes.Msg.Hash
 walkBlocks:
 	for i := 0; i < maxBlocks && currentHash != ""; i++ {
-		blockRes, err := bitcoind.GetBlock(ctx, connect.NewRequest(&corepb.GetBlockRequest{
+		blockRes, err := bitcoind.GetBlock(ctx, connectv1.NewRequest(&corepb.GetBlockRequest{
 			Hash:      currentHash,
 			Verbosity: corepb.GetBlockRequest_VERBOSITY_BLOCK_TX_INFO,
 		}))
@@ -978,7 +979,7 @@ walkBlocks:
 				continue
 			}
 
-			txRes, err := bitcoind.GetRawTransaction(ctx, connect.NewRequest(&corepb.GetRawTransactionRequest{
+			txRes, err := bitcoind.GetRawTransaction(ctx, connectv1.NewRequest(&corepb.GetRawTransactionRequest{
 				Txid:      txid,
 				Verbosity: corepb.GetRawTransactionRequest_VERBOSITY_TX_PREVOUT_INFO,
 			}))
@@ -1018,17 +1019,17 @@ walkBlocks:
 	}
 	transactions = transactions[:count]
 
-	return connect.NewResponse(&pb.ListRecentTransactionsResponse{
+	return &pb.ListRecentTransactionsResponse{
 		Transactions: transactions,
-	}), nil
+	}, nil
 }
 
-func (s *Server) GetNetworkStats(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[pb.GetNetworkStatsResponse], error) {
+func (s *Server) GetNetworkStats(ctx context.Context, req *emptypb.Empty) (*pb.GetNetworkStatsResponse, error) {
 	// Light mode runs no local Bitcoin Core. Answer before the dial, so the
 	// caller gets one clear reason instead of a connection error each tick.
 	if !s.walletEngine.NodeMode().RunsLocalNode(ctx) {
 		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			errors.New("network stats need full mode, which runs a local Bitcoin node"))
+			"network stats need full mode, which runs a local Bitcoin node")
 	}
 
 	bitcoind, err := s.bitcoind.Get(ctx)
@@ -1037,7 +1038,7 @@ func (s *Server) GetNetworkStats(ctx context.Context, req *connect.Request[empty
 	}
 
 	// Fetch blockchain info
-	blockchainInfo, err := bitcoind.GetBlockchainInfo(ctx, connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	blockchainInfo, err := bitcoind.GetBlockchainInfo(ctx, connectv1.NewRequest(&corepb.GetBlockchainInfoRequest{}))
 	if err != nil {
 		return nil, fmt.Errorf("get blockchain info: %w", err)
 	}
@@ -1051,13 +1052,13 @@ func (s *Server) GetNetworkStats(ctx context.Context, req *connect.Request[empty
 	// Get difficulty from latest block
 	difficulty := 0.0
 	if blockchainInfo.Msg.Blocks > 0 {
-		hash, err := bitcoind.GetBlockHash(ctx, connect.NewRequest(&corepb.GetBlockHashRequest{
+		hash, err := bitcoind.GetBlockHash(ctx, connectv1.NewRequest(&corepb.GetBlockHashRequest{
 			Height: blockchainInfo.Msg.Blocks,
 		}))
 		if err != nil {
 			return nil, fmt.Errorf("get latest block hash: %w", err)
 		}
-		block, err := bitcoind.GetBlock(ctx, connect.NewRequest(&corepb.GetBlockRequest{
+		block, err := bitcoind.GetBlock(ctx, connectv1.NewRequest(&corepb.GetBlockRequest{
 			Hash:      hash.Msg.Hash,
 			Verbosity: 1,
 		}))
@@ -1067,18 +1068,18 @@ func (s *Server) GetNetworkStats(ctx context.Context, req *connect.Request[empty
 		difficulty = block.Msg.Difficulty
 	}
 
-	networkInfo, err := bitcoind.GetNetworkInfo(ctx, connect.NewRequest(&corepb.GetNetworkInfoRequest{}))
+	networkInfo, err := bitcoind.GetNetworkInfo(ctx, connectv1.NewRequest(&corepb.GetNetworkInfoRequest{}))
 	if err != nil {
 		return nil, fmt.Errorf("get network info: %w", err)
 	}
 
-	netTotals, err := bitcoind.GetNetTotals(ctx, connect.NewRequest(&corepb.GetNetTotalsRequest{}))
+	netTotals, err := bitcoind.GetNetTotals(ctx, connectv1.NewRequest(&corepb.GetNetTotalsRequest{}))
 	if err != nil {
 		return nil, fmt.Errorf("get net totals: %w", err)
 	}
 
 	// Get peer info
-	peerInfo, err := bitcoind.GetPeerInfo(ctx, connect.NewRequest(&corepb.GetPeerInfoRequest{}))
+	peerInfo, err := bitcoind.GetPeerInfo(ctx, connectv1.NewRequest(&corepb.GetPeerInfoRequest{}))
 	if err != nil {
 		return nil, fmt.Errorf("get peer info: %w", err)
 	}
@@ -1096,14 +1097,14 @@ func (s *Server) GetNetworkStats(ctx context.Context, req *connect.Request[empty
 
 	bitcoindBandwidth, err := s.processBandwidth(ctx, "bitcoind")
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	enforcerBandwidth, err := s.processBandwidth(ctx, "bip300301-enforcer")
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.GetNetworkStatsResponse{
+	return &pb.GetNetworkStatsResponse{
 		NetworkHashrate:    0, // Requires getmininginfo (mining-specific)
 		Difficulty:         difficulty,
 		PeerCount:          int32(len(peerInfo.Msg.Peers)),
@@ -1117,7 +1118,7 @@ func (s *Server) GetNetworkStats(ctx context.Context, req *connect.Request[empty
 		ConnectionsOut:     connectionsOut,
 		BitcoindBandwidth:  bitcoindBandwidth,
 		EnforcerBandwidth:  enforcerBandwidth,
-	}), nil
+	}, nil
 }
 
 // processBandwidth gives nil when no process has the name.
@@ -1192,14 +1193,14 @@ func (s *Server) getBlockAtHeight(ctx context.Context, height int64) (int64, err
 		return 0, fmt.Errorf("bitcoind: %w", err)
 	}
 
-	hash, err := bitcoind.GetBlockHash(ctx, connect.NewRequest(&corepb.GetBlockHashRequest{
+	hash, err := bitcoind.GetBlockHash(ctx, connectv1.NewRequest(&corepb.GetBlockHashRequest{
 		Height: uint32(height),
 	}))
 	if err != nil {
 		return 0, fmt.Errorf("get block hash: %w", err)
 	}
 
-	block, err := bitcoind.GetBlock(ctx, connect.NewRequest(&corepb.GetBlockRequest{
+	block, err := bitcoind.GetBlock(ctx, connectv1.NewRequest(&corepb.GetBlockRequest{
 		Hash:      hash.Msg.Hash,
 		Verbosity: corepb.GetBlockRequest_VERBOSITY_BLOCK_INFO,
 	}))
@@ -1237,7 +1238,7 @@ func (s *Server) checkBitcoinCoreUTXO(ctx context.Context, walletID string, txid
 		return false, fmt.Errorf("bitcoind: %w", err)
 	}
 
-	utxos, err := bitcoind.ListUnspent(ctx, connect.NewRequest(&corepb.ListUnspentRequest{
+	utxos, err := bitcoind.ListUnspent(ctx, connectv1.NewRequest(&corepb.ListUnspentRequest{
 		Wallet: walletName,
 	}))
 	if err != nil {
@@ -1248,45 +1249,45 @@ func (s *Server) checkBitcoinCoreUTXO(ctx context.Context, walletID string, txid
 		return utxo.Txid == txid && utxo.Vout == vout
 	}), nil
 }
-func (s *Server) SetMempoolWatch(ctx context.Context, req *connect.Request[pb.SetMempoolWatchRequest]) (*connect.Response[emptypb.Empty], error) {
-	if req.Msg.Enabled {
+func (s *Server) SetMempoolWatch(ctx context.Context, req *pb.SetMempoolWatchRequest) (*emptypb.Empty, error) {
+	if req.Enabled {
 		if err := s.walletEngine.NodeMode().RequireFullNode(ctx, "mempool watch"); err != nil {
 			return nil, err
 		}
 	}
-	if err := s.mempoolWatcher.SetEnabled(ctx, req.Msg.Enabled); err != nil {
+	if err := s.mempoolWatcher.SetEnabled(ctx, req.Enabled); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
-func (s *Server) ResetMempoolWatch(ctx context.Context, _ *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
+func (s *Server) ResetMempoolWatch(ctx context.Context, _ *emptypb.Empty) (*emptypb.Empty, error) {
 	if err := s.mempoolWatcher.Reset(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
-func (s *Server) GetMempoolWatchStatus(ctx context.Context, _ *connect.Request[emptypb.Empty]) (*connect.Response[pb.GetMempoolWatchStatusResponse], error) {
+func (s *Server) GetMempoolWatchStatus(ctx context.Context, _ *emptypb.Empty) (*pb.GetMempoolWatchStatusResponse, error) {
 	status := s.mempoolWatcher.Status()
 	count, err := mempooltx.Count(ctx, s.db)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetMempoolWatchStatusResponse{
+	return &pb.GetMempoolWatchStatusResponse{
 		Enabled:      status.Enabled,
 		Running:      status.Running,
 		Error:        status.Error,
 		TipHeight:    status.Tip,
 		PendingCount: count,
-	}), nil
+	}, nil
 }
 
-func (s *Server) ListMempoolTransactions(ctx context.Context, req *connect.Request[pb.ListMempoolTransactionsRequest]) (*connect.Response[pb.ListMempoolTransactionsResponse], error) {
+func (s *Server) ListMempoolTransactions(ctx context.Context, req *pb.ListMempoolTransactionsRequest) (*pb.ListMempoolTransactionsResponse, error) {
 	filter := mempooltx.Filter{
-		TxidPrefix: strings.ToLower(strings.TrimSpace(req.Msg.Txid)),
-		Limit:      int(req.Msg.Limit),
-		Offset:     int(req.Msg.Offset),
+		TxidPrefix: strings.ToLower(strings.TrimSpace(req.Txid)),
+		Limit:      int(req.Limit),
+		Offset:     int(req.Offset),
 	}
 	if filter.Limit == 0 {
 		filter.Limit = 200
@@ -1307,11 +1308,11 @@ func (s *Server) ListMempoolTransactions(ctx context.Context, req *connect.Reque
 			FirstSeenHeight: tx.FirstSeenHeight,
 		}
 	}
-	return connect.NewResponse(&pb.ListMempoolTransactionsResponse{Transactions: out, Total: total}), nil
+	return &pb.ListMempoolTransactionsResponse{Transactions: out, Total: total}, nil
 }
 
-func (s *Server) ListBlockStats(ctx context.Context, req *connect.Request[pb.ListBlockStatsRequest]) (*connect.Response[pb.ListBlockStatsResponse], error) {
-	blocks, err := mempooltx.ListBlockStats(ctx, s.db, req.Msg.FromHeight, req.Msg.ToHeight)
+func (s *Server) ListBlockStats(ctx context.Context, req *pb.ListBlockStatsRequest) (*pb.ListBlockStatsResponse, error) {
+	blocks, err := mempooltx.ListBlockStats(ctx, s.db, req.FromHeight, req.ToHeight)
 	if err != nil {
 		return nil, err
 	}
@@ -1319,7 +1320,7 @@ func (s *Server) ListBlockStats(ctx context.Context, req *connect.Request[pb.Lis
 	for i, b := range blocks {
 		out[i] = &pb.BlockStats{Height: b.Height, MinFeeRate: b.MinFeeRate, TotalFeeSats: b.TotalFeeSats}
 	}
-	return connect.NewResponse(&pb.ListBlockStatsResponse{Blocks: out}), nil
+	return &pb.ListBlockStatsResponse{Blocks: out}, nil
 }
 
 var miningPoolWindows = map[pb.MiningPoolWindow]time.Duration{
@@ -1328,8 +1329,8 @@ var miningPoolWindows = map[pb.MiningPoolWindow]time.Duration{
 	pb.MiningPoolWindow_MINING_POOL_WINDOW_1W:  7 * 24 * time.Hour,
 }
 
-func (s *Server) ListMiningPools(ctx context.Context, req *connect.Request[pb.ListMiningPoolsRequest]) (*connect.Response[pb.ListMiningPoolsResponse], error) {
-	window, ok := miningPoolWindows[req.Msg.Window]
+func (s *Server) ListMiningPools(ctx context.Context, req *pb.ListMiningPoolsRequest) (*pb.ListMiningPoolsResponse, error) {
+	window, ok := miningPoolWindows[req.Window]
 	if !ok {
 		window = miningPoolWindows[pb.MiningPoolWindow_MINING_POOL_WINDOW_24H]
 	}
@@ -1349,7 +1350,7 @@ func (s *Server) ListMiningPools(ctx context.Context, req *connect.Request[pb.Li
 			EstimatedHashrate: share.Hashrate,
 		}
 	}
-	return connect.NewResponse(&pb.ListMiningPoolsResponse{
+	return &pb.ListMiningPoolsResponse{
 		Pools:             shares,
 		BlockCount:        summary.Blocks,
 		FromHeight:        summary.FromHeight,
@@ -1357,7 +1358,7 @@ func (s *Server) ListMiningPools(ctx context.Context, req *connect.Request[pb.Li
 		NetworkHashrate:   summary.NetworkHashrate,
 		RegistryAvailable: registry.Available,
 		RegistrySource:    registry.Source,
-	}), nil
+	}, nil
 }
 
 // attributeBlocks fills the pool of every block whose coinbase was recorded.
diff --git a/bitwindow/server/api/bitwindowd/bitwindowd_test.go b/bitwindow/server/api/bitwindowd/bitwindowd_test.go
index 5b1ced9001..b38d4c2fd3 100644
--- a/bitwindow/server/api/bitwindowd/bitwindowd_test.go
+++ b/bitwindow/server/api/bitwindowd/bitwindowd_test.go
@@ -9,7 +9,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -43,9 +44,9 @@ type shutdownRecorder struct {
 	onlyIfLast chan bool
 }
 
-func (r *shutdownRecorder) Shutdown(_ context.Context, req *connect.Request[orchpb.ShutdownRequest]) (*connect.Response[orchpb.ShutdownResponse], error) {
-	r.onlyIfLast <- req.Msg.OnlyIfLast
-	return connect.NewResponse(&orchpb.ShutdownResponse{}), nil
+func (r *shutdownRecorder) Shutdown(_ context.Context, req *orchpb.ShutdownRequest) (*orchpb.ShutdownResponse, error) {
+	r.onlyIfLast <- req.OnlyIfLast
+	return &orchpb.ShutdownResponse{}, nil
 }
 
 func TestService_Stop(t *testing.T) {
@@ -64,14 +65,14 @@ func TestService_Stop(t *testing.T) {
 
 			var shutDown atomic.Bool
 			orchestrator := &shutdownRecorder{onlyIfLast: make(chan bool, 1)}
-			cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database.Test(t),
+			cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database.Test(t),
 				apitests.WithOnShutdown(func(context.Context) { shutDown.Store(true) }),
 				apitests.WithOrchestratorControl(orchestrator),
 			))
 
-			_, err := cli.Stop(t.Context(), connect.NewRequest(&v1.BitwindowdServiceStopRequest{
+			_, err := cli.Stop(t.Context(), &v1.BitwindowdServiceStopRequest{
 				SkipDownstream: test.skipDownstream,
-			}))
+			})
 			require.NoError(t, err)
 
 			assert.True(t, shutDown.Load())
@@ -99,7 +100,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -108,19 +109,19 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 0,
 			NumHops:      1,
-		}))
+		})
 		require.ErrorContains(t, err, "delay_seconds must be positive")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -133,17 +134,17 @@ func TestService_CreateDenial(t *testing.T) {
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, errors.New("bitcoind is down")))
+			Return(nil, connectv1.NewError(connectv1.CodeUnavailable, errors.New("bitcoind is down")))
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+			apitests.RPC(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 10,
 			NumHops:      1,
-		}))
+		})
 		require.ErrorContains(t, err, "bitcoind is down")
 		assert.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	})
@@ -159,7 +160,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -168,19 +169,19 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: -10,
 			NumHops:      1,
-		}))
+		})
 		require.ErrorContains(t, err, "delay_seconds must be positive")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -196,7 +197,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -205,19 +206,19 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 60,
 			NumHops:      0,
-		}))
+		})
 		require.ErrorContains(t, err, "num_hops must be positive")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -233,7 +234,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -242,19 +243,19 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 60,
 			NumHops:      -5,
-		}))
+		})
 		require.ErrorContains(t, err, "num_hops must be positive")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -270,24 +271,24 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{},
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "",
 			Vout:         0,
 			DelaySeconds: 60,
 			NumHops:      1,
-		}))
+		})
 		require.ErrorContains(t, err, "utxo :0 not found in wallet")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -303,7 +304,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -312,19 +313,19 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "nonexistent",
 			Vout:         0,
 			DelaySeconds: 60,
 			NumHops:      1,
-		}))
+		})
 		require.ErrorContains(t, err, "utxo nonexistent:0 not found in wallet")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -340,7 +341,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -349,19 +350,19 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 60,
 			NumHops:      1,
-		}))
+		})
 		require.NoError(t, err)
 
 		denials, err := deniability.List(t.Context(), database)
@@ -374,13 +375,13 @@ func TestService_CreateDenial(t *testing.T) {
 		assert.EqualValues(t, int32(60), denials[0].DelayDuration.Seconds())
 		assert.Equal(t, int32(1), denials[0].NumHops)
 
-		_, err = cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err = cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:            "abc123",
 			Vout:            0,
 			DelaySeconds:    120,
 			NumHops:         1,
 			TargetUtxoSizes: []int64{1000},
-		}))
+		})
 		require.ErrorContains(t, err, "already runs for abc123:0")
 		assert.Equal(t, connect.CodeAlreadyExists, connect.CodeOf(err))
 
@@ -390,17 +391,17 @@ func TestService_CreateDenial(t *testing.T) {
 		assert.EqualValues(t, int32(60), denials[0].DelayDuration.Seconds())
 		assert.Empty(t, denials[0].TargetUTXOSizes)
 
-		_, err = cli.PauseDenial(t.Context(), connect.NewRequest(&v1.PauseDenialRequest{Id: denialID}))
+		_, err = cli.PauseDenial(t.Context(), &v1.PauseDenialRequest{Id: denialID})
 		require.NoError(t, err)
-		_, err = cli.CancelDenial(t.Context(), connect.NewRequest(&v1.CancelDenialRequest{Id: denialID}))
+		_, err = cli.CancelDenial(t.Context(), &v1.CancelDenialRequest{Id: denialID})
 		require.NoError(t, err)
-		_, err = cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err = cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:            "abc123",
 			Vout:            0,
 			DelaySeconds:    120,
 			NumHops:         2,
 			TargetUtxoSizes: []int64{1000, 2000},
-		}))
+		})
 		require.NoError(t, err)
 
 		denials, err = deniability.List(t.Context(), database)
@@ -427,7 +428,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -437,7 +438,7 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
@@ -445,21 +446,21 @@ func TestService_CreateDenial(t *testing.T) {
 			))
 
 		// Create first denial
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 60,
 			NumHops:      1,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Create second denial
-		_, err = cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err = cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "def456",
 			Vout:         1,
 			DelaySeconds: 120,
 			NumHops:      2,
-		}))
+		})
 		require.NoError(t, err)
 
 		denials, err := deniability.List(t.Context(), database)
@@ -478,7 +479,7 @@ func TestService_CreateDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -487,19 +488,19 @@ func TestService_CreateDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
 				apitests.WithBitcoind(mockBitcoind),
 			))
 
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 86400, // 24 hours
 			NumHops:      10,
-		}))
+		})
 		require.NoError(t, err)
 
 		denials, err := deniability.List(t.Context(), database)
@@ -517,11 +518,11 @@ func TestService_CancelDenial(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database, apitests.WithCoreWallet()))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database, apitests.WithCoreWallet()))
 
-		_, err := cli.CancelDenial(t.Context(), connect.NewRequest(&v1.CancelDenialRequest{
+		_, err := cli.CancelDenial(t.Context(), &v1.CancelDenialRequest{
 			Id: 999,
-		}))
+		})
 		assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
 
@@ -529,11 +530,11 @@ func TestService_CancelDenial(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database, apitests.WithCoreWallet()))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database, apitests.WithCoreWallet()))
 
-		_, err := cli.CancelDenial(t.Context(), connect.NewRequest(&v1.CancelDenialRequest{
+		_, err := cli.CancelDenial(t.Context(), &v1.CancelDenialRequest{
 			Id: 0,
-		}))
+		})
 		assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
 
@@ -548,7 +549,7 @@ func TestService_CancelDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -557,7 +558,7 @@ func TestService_CancelDenial(t *testing.T) {
 			}, nil)
 
 		cli := v1connect.NewBitwindowdServiceClient(
-			apitests.API(
+			apitests.RPC(
 				t,
 				database,
 				apitests.WithCoreWallet(),
@@ -565,12 +566,12 @@ func TestService_CancelDenial(t *testing.T) {
 			))
 
 		// First create a denial
-		_, err := cli.CreateDenial(t.Context(), connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(t.Context(), &v1.CreateDenialRequest{
 			Txid:         "abc123",
 			Vout:         0,
 			DelaySeconds: 60,
 			NumHops:      1,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Get the denial ID from the database
@@ -579,9 +580,9 @@ func TestService_CancelDenial(t *testing.T) {
 		require.Len(t, denials, 1)
 
 		// Then cancel it
-		_, err = cli.CancelDenial(t.Context(), connect.NewRequest(&v1.CancelDenialRequest{
+		_, err = cli.CancelDenial(t.Context(), &v1.CancelDenialRequest{
 			Id: denials[0].ID,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Verify it's cancelled
@@ -599,13 +600,13 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Test Address",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 	})
 
@@ -613,13 +614,13 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 	})
 
@@ -627,13 +628,13 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Invalid Address",
 			Address:   "invalid-bitcoin-address",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.ErrorContains(t, err, "invalid address \"invalid-bitcoin-address\"")
 	})
 
@@ -641,13 +642,13 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Send Address",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_SEND,
-		}))
+		})
 		require.NoError(t, err)
 	})
 
@@ -655,41 +656,41 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Create first entry
-		_, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "First Label",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Try to create duplicate
-		_, err = cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err = cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Second Label",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 		// If it succeeds, verify we have 2 entries
-		resp, err := cli.ListAddressBook(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListAddressBook(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.Len(t, resp.Msg.Entries, 1)
+		assert.Len(t, resp.Entries, 1)
 		// Label should be updated
-		assert.Equal(t, "Second Label", resp.Msg.Entries[0].Label)
+		assert.Equal(t, "Second Label", resp.Entries[0].Label)
 	})
 
 	t.Run("a label maps to one address", func(t *testing.T) {
 		t.Parallel()
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database.Test(t)))
-		create := func(label, address string) (*connect.Response[v1.CreateAddressBookEntryResponse], error) {
-			return cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database.Test(t)))
+		create := func(label, address string) (*v1.CreateAddressBookEntryResponse, error) {
+			return cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 				Label:     label,
 				Address:   address,
 				Direction: v1.Direction_DIRECTION_SEND,
-			}))
+			})
 		}
 
 		first, err := create("rent", "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh")
@@ -703,14 +704,14 @@ func TestService_AddressBook(t *testing.T) {
 		_, err = create("rent", "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh")
 		require.NoError(t, err)
 
-		_, err = cli.UpdateAddressBookEntry(t.Context(), connect.NewRequest(&v1.UpdateAddressBookEntryRequest{
-			Id: second.Msg.Entry.Id, Label: "rent",
-		}))
+		_, err = cli.UpdateAddressBookEntry(t.Context(), &v1.UpdateAddressBookEntryRequest{
+			Id: second.Entry.Id, Label: "rent",
+		})
 		require.Equal(t, connect.CodeAlreadyExists, connect.CodeOf(err))
 
-		_, err = cli.UpdateAddressBookEntry(t.Context(), connect.NewRequest(&v1.UpdateAddressBookEntryRequest{
-			Id: first.Msg.Entry.Id, Label: "rent",
-		}))
+		_, err = cli.UpdateAddressBookEntry(t.Context(), &v1.UpdateAddressBookEntryRequest{
+			Id: first.Entry.Id, Label: "rent",
+		})
 		require.NoError(t, err)
 	})
 
@@ -718,40 +719,40 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Create an entry first
-		_, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Test Address",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 
-		resp, err := cli.ListAddressBook(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListAddressBook(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Entries)
+		assert.NotEmpty(t, resp.Entries)
 	})
 
 	t.Run("update entry", func(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Create an entry first
-		createResp, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		createResp, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Original Label",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Update the entry
-		_, err = cli.UpdateAddressBookEntry(t.Context(), connect.NewRequest(&v1.UpdateAddressBookEntryRequest{
-			Id:    createResp.Msg.Entry.Id,
+		_, err = cli.UpdateAddressBookEntry(t.Context(), &v1.UpdateAddressBookEntryRequest{
+			Id:    createResp.Entry.Id,
 			Label: "Updated Label",
-		}))
+		})
 		require.NoError(t, err)
 	})
 
@@ -759,21 +760,21 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Create an entry first
-		createResp, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		createResp, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Original Label",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Try to update with empty label
-		_, err = cli.UpdateAddressBookEntry(t.Context(), connect.NewRequest(&v1.UpdateAddressBookEntryRequest{
-			Id:    createResp.Msg.Entry.Id,
+		_, err = cli.UpdateAddressBookEntry(t.Context(), &v1.UpdateAddressBookEntryRequest{
+			Id:    createResp.Entry.Id,
 			Label: "",
-		}))
+		})
 		require.NoError(t, err)
 	})
 
@@ -781,13 +782,13 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Try to update non-existent entry
-		_, err := cli.UpdateAddressBookEntry(t.Context(), connect.NewRequest(&v1.UpdateAddressBookEntryRequest{
+		_, err := cli.UpdateAddressBookEntry(t.Context(), &v1.UpdateAddressBookEntryRequest{
 			Id:    99999,
 			Label: "New Label",
-		}))
+		})
 		require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 		require.ErrorContains(t, err, "address book entry not found")
 	})
@@ -796,20 +797,20 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Create an entry first
-		createResp, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		createResp, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Test Address",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Delete the entry
-		_, err = cli.DeleteAddressBookEntry(t.Context(), connect.NewRequest(&v1.DeleteAddressBookEntryRequest{
-			Id: createResp.Msg.Entry.Id,
-		}))
+		_, err = cli.DeleteAddressBookEntry(t.Context(), &v1.DeleteAddressBookEntryRequest{
+			Id: createResp.Entry.Id,
+		})
 		require.NoError(t, err)
 	})
 
@@ -817,12 +818,12 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Try to delete non-existent entry
-		_, err := cli.DeleteAddressBookEntry(t.Context(), connect.NewRequest(&v1.DeleteAddressBookEntryRequest{
+		_, err := cli.DeleteAddressBookEntry(t.Context(), &v1.DeleteAddressBookEntryRequest{
 			Id: 99999,
-		}))
+		})
 		require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 		require.ErrorContains(t, err, "address book entry not found")
 	})
@@ -831,26 +832,26 @@ func TestService_AddressBook(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Create an entry first
-		createResp, err := cli.CreateAddressBookEntry(t.Context(), connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		createResp, err := cli.CreateAddressBookEntry(t.Context(), &v1.CreateAddressBookEntryRequest{
 			Label:     "Test Address",
 			Address:   "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Delete the entry
-		_, err = cli.DeleteAddressBookEntry(t.Context(), connect.NewRequest(&v1.DeleteAddressBookEntryRequest{
-			Id: createResp.Msg.Entry.Id,
-		}))
+		_, err = cli.DeleteAddressBookEntry(t.Context(), &v1.DeleteAddressBookEntryRequest{
+			Id: createResp.Entry.Id,
+		})
 		require.NoError(t, err)
 
 		// Try to delete again
-		_, err = cli.DeleteAddressBookEntry(t.Context(), connect.NewRequest(&v1.DeleteAddressBookEntryRequest{
-			Id: createResp.Msg.Entry.Id,
-		}))
+		_, err = cli.DeleteAddressBookEntry(t.Context(), &v1.DeleteAddressBookEntryRequest{
+			Id: createResp.Entry.Id,
+		})
 		require.ErrorContains(t, err, "address book entry not found")
 	})
 }
@@ -870,7 +871,7 @@ func TestService_GetSyncInfo(t *testing.T) {
 		// Background operations expectations
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{
 					Wallets: []string{},
 				},
@@ -878,7 +879,7 @@ func TestService_GetSyncInfo(t *testing.T) {
 			AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{
 					Name: "test_wallet",
 				},
@@ -887,21 +888,21 @@ func TestService_GetSyncInfo(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Chain: "main",
 				},
 			}, nil)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.GetSyncInfo(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.GetSyncInfo(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.NotNil(t, resp.Msg)
-		assert.GreaterOrEqual(t, resp.Msg.TipBlockHeight, int64(0))
-		assert.GreaterOrEqual(t, resp.Msg.HeaderHeight, int64(0))
-		assert.GreaterOrEqual(t, resp.Msg.SyncProgress, float64(0))
-		assert.LessOrEqual(t, resp.Msg.SyncProgress, float64(1))
+		assert.NotNil(t, resp)
+		assert.GreaterOrEqual(t, resp.TipBlockHeight, int64(0))
+		assert.GreaterOrEqual(t, resp.HeaderHeight, int64(0))
+		assert.GreaterOrEqual(t, resp.SyncProgress, float64(0))
+		assert.LessOrEqual(t, resp.SyncProgress, float64(1))
 	})
 
 	t.Run("get sync info with error", func(t *testing.T) {
@@ -916,7 +917,7 @@ func TestService_GetSyncInfo(t *testing.T) {
 		// Background operations expectations
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{
 					Wallets: []string{},
 				},
@@ -924,7 +925,7 @@ func TestService_GetSyncInfo(t *testing.T) {
 			AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{
 					Name: "test_wallet",
 				},
@@ -933,11 +934,11 @@ func TestService_GetSyncInfo(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeInternal, nil))
+			Return(nil, connectv1.NewError(connectv1.CodeInternal, nil))
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.GetSyncInfo(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := cli.GetSyncInfo(t.Context(), &emptypb.Empty{})
 		require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 	})
 
@@ -953,7 +954,7 @@ func TestService_GetSyncInfo(t *testing.T) {
 		// Background operations expectations
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{
 					Wallets: []string{},
 				},
@@ -961,7 +962,7 @@ func TestService_GetSyncInfo(t *testing.T) {
 			AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{
 					Name: "test_wallet",
 				},
@@ -970,17 +971,17 @@ func TestService_GetSyncInfo(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Chain: "test",
 				},
 			}, nil)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.GetSyncInfo(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.GetSyncInfo(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.NotNil(t, resp.Msg)
+		assert.NotNil(t, resp)
 	})
 }
 
@@ -991,12 +992,12 @@ func TestService_SetTransactionNote(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.SetTransactionNote(t.Context(), connect.NewRequest(&v1.SetTransactionNoteRequest{
+		_, err := cli.SetTransactionNote(t.Context(), &v1.SetTransactionNoteRequest{
 			Txid: "abc123",
 			Note: "Test note",
-		}))
+		})
 		require.NoError(t, err)
 	})
 
@@ -1004,12 +1005,12 @@ func TestService_SetTransactionNote(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.SetTransactionNote(t.Context(), connect.NewRequest(&v1.SetTransactionNoteRequest{
+		_, err := cli.SetTransactionNote(t.Context(), &v1.SetTransactionNoteRequest{
 			Txid: "abc123",
 			Note: "",
-		}))
+		})
 		require.NoError(t, err)
 	})
 
@@ -1017,12 +1018,12 @@ func TestService_SetTransactionNote(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.SetTransactionNote(t.Context(), connect.NewRequest(&v1.SetTransactionNoteRequest{
+		_, err := cli.SetTransactionNote(t.Context(), &v1.SetTransactionNoteRequest{
 			Txid: "",
 			Note: "Test note",
-		}))
+		})
 		require.ErrorContains(t, err, "txid cannot be empty")
 	})
 
@@ -1030,17 +1031,17 @@ func TestService_SetTransactionNote(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		longNote := ""
 		for i := 0; i < 1000; i++ {
 			longNote += "This is a very long note. "
 		}
 
-		_, err := cli.SetTransactionNote(t.Context(), connect.NewRequest(&v1.SetTransactionNoteRequest{
+		_, err := cli.SetTransactionNote(t.Context(), &v1.SetTransactionNoteRequest{
 			Txid: "abc123",
 			Note: longNote,
-		}))
+		})
 		// This might succeed or fail depending on implementation limits
 		// Just verify it doesn't panic
 		_ = err
@@ -1050,20 +1051,20 @@ func TestService_SetTransactionNote(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
 		// Set initial note
-		_, err := cli.SetTransactionNote(t.Context(), connect.NewRequest(&v1.SetTransactionNoteRequest{
+		_, err := cli.SetTransactionNote(t.Context(), &v1.SetTransactionNoteRequest{
 			Txid: "abc123",
 			Note: "Initial note",
-		}))
+		})
 		require.NoError(t, err)
 
 		// Update the note
-		_, err = cli.SetTransactionNote(t.Context(), connect.NewRequest(&v1.SetTransactionNoteRequest{
+		_, err = cli.SetTransactionNote(t.Context(), &v1.SetTransactionNoteRequest{
 			Txid: "abc123",
 			Note: "Updated note",
-		}))
+		})
 		require.NoError(t, err)
 	})
 }
@@ -1073,14 +1074,14 @@ func TestService_GetFireplaceStats(t *testing.T) {
 
 	ctx := t.Context()
 	database := database.Test(t)
-	cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database))
+	cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database))
 
-	resp, err := cli.GetFireplaceStats(ctx, connect.NewRequest(&emptypb.Empty{}))
+	resp, err := cli.GetFireplaceStats(ctx, &emptypb.Empty{})
 	require.NoError(t, err)
 
-	assert.Empty(t, resp.Msg.TransactionCount_24H)
-	assert.Empty(t, resp.Msg.CoinnewsCount_7D)
-	assert.Empty(t, resp.Msg.BlockCount_24H)
+	assert.Empty(t, resp.TransactionCount_24H)
+	assert.Empty(t, resp.CoinnewsCount_7D)
+	assert.Empty(t, resp.BlockCount_24H)
 
 	newHash := func(t *testing.T) chainhash.Hash {
 		buf := make([]byte, chainhash.HashSize)
@@ -1160,12 +1161,12 @@ func TestService_GetFireplaceStats(t *testing.T) {
 	seedStory(9, 902, "Fresh CoinNews", time.Now())
 	seedStory(10, 903, "Old CoinNews", time.Now().AddDate(-1, 0, 0))
 
-	resp, err = cli.GetFireplaceStats(ctx, connect.NewRequest(&emptypb.Empty{}))
+	resp, err = cli.GetFireplaceStats(ctx, &emptypb.Empty{})
 	require.NoError(t, err)
 
-	assert.EqualValues(t, 1, resp.Msg.TransactionCount_24H)
-	assert.EqualValues(t, 1, resp.Msg.CoinnewsCount_7D)
-	assert.EqualValues(t, 1, resp.Msg.BlockCount_24H)
+	assert.EqualValues(t, 1, resp.TransactionCount_24H)
+	assert.EqualValues(t, 1, resp.CoinnewsCount_7D)
+	assert.EqualValues(t, 1, resp.BlockCount_24H)
 
 }
 
@@ -1184,7 +1185,7 @@ func TestService_PauseDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -1192,12 +1193,12 @@ func TestService_PauseDenial(t *testing.T) {
 				},
 			}, nil)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
 		// First create a denial
-		_, err := cli.CreateDenial(ctx, connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(ctx, &v1.CreateDenialRequest{
 			Txid: "abc123", Vout: 0, DelaySeconds: 60, NumHops: 1,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Get the denial ID from the database
@@ -1207,7 +1208,7 @@ func TestService_PauseDenial(t *testing.T) {
 		denialID := denials[0].ID
 
 		// Pause it
-		_, err = cli.PauseDenial(ctx, connect.NewRequest(&v1.PauseDenialRequest{Id: denialID}))
+		_, err = cli.PauseDenial(ctx, &v1.PauseDenialRequest{Id: denialID})
 		require.NoError(t, err)
 
 		// Verify it's paused by checking the database
@@ -1221,9 +1222,9 @@ func TestService_PauseDenial(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithCoreWallet()))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet()))
 
-		_, err := cli.PauseDenial(t.Context(), connect.NewRequest(&v1.PauseDenialRequest{Id: 99999}))
+		_, err := cli.PauseDenial(t.Context(), &v1.PauseDenialRequest{Id: 99999})
 		require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
 }
@@ -1243,7 +1244,7 @@ func TestService_ResumeDenial(t *testing.T) {
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[corepb.ListUnspentResponse]{
+			Return(&connectv1.Response[corepb.ListUnspentResponse]{
 				Msg: &corepb.ListUnspentResponse{
 					Unspent: []*corepb.UnspentOutput{
 						{Txid: "abc123", Vout: 0, Amount: 0.01, Confirmations: 6},
@@ -1251,12 +1252,12 @@ func TestService_ResumeDenial(t *testing.T) {
 				},
 			}, nil)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
 		// Create a denial
-		_, err := cli.CreateDenial(ctx, connect.NewRequest(&v1.CreateDenialRequest{
+		_, err := cli.CreateDenial(ctx, &v1.CreateDenialRequest{
 			Txid: "abc123", Vout: 0, DelaySeconds: 60, NumHops: 1,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Get the denial ID from the database
@@ -1266,11 +1267,11 @@ func TestService_ResumeDenial(t *testing.T) {
 		denialID := denials[0].ID
 
 		// Pause it
-		_, err = cli.PauseDenial(ctx, connect.NewRequest(&v1.PauseDenialRequest{Id: denialID}))
+		_, err = cli.PauseDenial(ctx, &v1.PauseDenialRequest{Id: denialID})
 		require.NoError(t, err)
 
 		// Resume it
-		_, err = cli.ResumeDenial(ctx, connect.NewRequest(&v1.ResumeDenialRequest{Id: denialID}))
+		_, err = cli.ResumeDenial(ctx, &v1.ResumeDenialRequest{Id: denialID})
 		require.NoError(t, err)
 
 		// Verify it's resumed by checking the database
@@ -1284,9 +1285,9 @@ func TestService_ResumeDenial(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithCoreWallet()))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet()))
 
-		_, err := cli.ResumeDenial(t.Context(), connect.NewRequest(&v1.ResumeDenialRequest{Id: 99999}))
+		_, err := cli.ResumeDenial(t.Context(), &v1.ResumeDenialRequest{Id: 99999})
 		require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
 }
@@ -1311,7 +1312,7 @@ func TestService_ListBlocksInitialSync(t *testing.T) {
 
 			mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 			mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(connect.NewResponse(&corepb.GetBlockchainInfoResponse{
+				Return(connectv1.NewResponse(&corepb.GetBlockchainInfoResponse{
 					Blocks:               100,
 					BestBlockHash:        "hash100",
 					InitialBlockDownload: test.initial,
@@ -1319,14 +1320,14 @@ func TestService_ListBlocksInitialSync(t *testing.T) {
 
 			var hashReads, blockReads atomic.Uint32
 			mockBitcoind.EXPECT().GetBlockHash(gomock.Any(), gomock.Any()).
-				DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockHashRequest]) (*connect.Response[corepb.GetBlockHashResponse], error) {
+				DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockHashRequest]) (*connectv1.Response[corepb.GetBlockHashResponse], error) {
 					hashReads.Add(1)
-					return connect.NewResponse(&corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", req.Msg.Height)}), nil
+					return connectv1.NewResponse(&corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", req.Msg.Height)}), nil
 				}).AnyTimes()
 			mockBitcoind.EXPECT().GetBlock(gomock.Any(), gomock.Any()).
-				DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockRequest]) (*connect.Response[corepb.GetBlockResponse], error) {
+				DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockRequest]) (*connectv1.Response[corepb.GetBlockResponse], error) {
 					blockReads.Add(1)
-					return connect.NewResponse(&corepb.GetBlockResponse{Height: 100, Hash: req.Msg.Hash}), nil
+					return connectv1.NewResponse(&corepb.GetBlockResponse{Height: 100, Hash: req.Msg.Hash}), nil
 				}).AnyTimes()
 
 			core := service.New("bitcoind", func(context.Context) (corerpc.BitcoinServiceClient, error) {
@@ -1334,10 +1335,10 @@ func TestService_ListBlocksInitialSync(t *testing.T) {
 			})
 			server := api_bitwindowd.New(nil, database.Test(t), core, nil, nil, miningpools.New(t.Context(), test.network, "", "", offlineRegistry), config.Config{BitcoinCoreNetwork: test.network}, nil)
 
-			response, err := server.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 1}))
+			response, err := server.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 1})
 			require.NoError(t, err)
-			assert.Len(t, response.Msg.RecentBlocks, int(test.blockCount))
-			assert.Equal(t, test.blockCount > 0, response.Msg.HasMore)
+			assert.Len(t, response.RecentBlocks, int(test.blockCount))
+			assert.Equal(t, test.blockCount > 0, response.HasMore)
 			assert.Equal(t, test.blockCount, hashReads.Load())
 			assert.Equal(t, test.blockCount, blockReads.Load())
 		})
@@ -1359,19 +1360,19 @@ func TestService_ListBlocks(t *testing.T) {
 		// Mock ListWallets and CreateWallet for background ensureWatchWallet
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
 		// Mock GetBlockchainInfo
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Blocks: 100},
 			}, nil)
 
@@ -1380,12 +1381,12 @@ func TestService_ListBlocks(t *testing.T) {
 			height := uint32(100 - i)
 			mockBitcoind.EXPECT().
 				GetBlockHash(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockHashResponse]{
+				Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 					Msg: &corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", height)},
 				}, nil)
 			mockBitcoind.EXPECT().
 				GetBlock(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockResponse]{
+				Return(&connectv1.Response[corepb.GetBlockResponse]{
 					Msg: &corepb.GetBlockResponse{
 						Height:        height,
 						Hash:          fmt.Sprintf("hash%d", height),
@@ -1395,16 +1396,16 @@ func TestService_ListBlocks(t *testing.T) {
 				}, nil)
 		}
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{}))
+		resp, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{})
 		require.NoError(t, err)
-		assert.Len(t, resp.Msg.RecentBlocks, 50)
-		assert.True(t, resp.Msg.HasMore)
+		assert.Len(t, resp.RecentBlocks, 50)
+		assert.True(t, resp.HasMore)
 
 		// Verify blocks are sorted by height descending
-		for i := 1; i < len(resp.Msg.RecentBlocks); i++ {
-			assert.Greater(t, resp.Msg.RecentBlocks[i-1].Height, resp.Msg.RecentBlocks[i].Height)
+		for i := 1; i < len(resp.RecentBlocks); i++ {
+			assert.Greater(t, resp.RecentBlocks[i-1].Height, resp.RecentBlocks[i].Height)
 		}
 	})
 
@@ -1419,18 +1420,18 @@ func TestService_ListBlocks(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10},
 			}, nil)
 
@@ -1439,12 +1440,12 @@ func TestService_ListBlocks(t *testing.T) {
 			height := uint32(10 - i)
 			mockBitcoind.EXPECT().
 				GetBlockHash(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockHashResponse]{
+				Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 					Msg: &corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", height)},
 				}, nil)
 			mockBitcoind.EXPECT().
 				GetBlock(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockResponse]{
+				Return(&connectv1.Response[corepb.GetBlockResponse]{
 					Msg: &corepb.GetBlockResponse{
 						Height: height,
 						Hash:   fmt.Sprintf("hash%d", height),
@@ -1453,13 +1454,13 @@ func TestService_ListBlocks(t *testing.T) {
 				}, nil)
 		}
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{
+		resp, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{
 			PageSize: 5,
-		}))
+		})
 		require.NoError(t, err)
-		assert.Len(t, resp.Msg.RecentBlocks, 5)
+		assert.Len(t, resp.RecentBlocks, 5)
 	})
 
 	t.Run("a reorg below the tip drops the missing heights", func(t *testing.T) {
@@ -1473,7 +1474,7 @@ func TestService_ListBlocks(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10},
 			}, nil)
 
@@ -1482,23 +1483,23 @@ func TestService_ListBlocks(t *testing.T) {
 		const tipAfterReorg = 8
 		mockBitcoind.EXPECT().
 			GetBlockHash(gomock.Any(), gomock.Any()).
-			DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockHashRequest]) (*connect.Response[corepb.GetBlockHashResponse], error) {
+			DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockHashRequest]) (*connectv1.Response[corepb.GetBlockHashResponse], error) {
 				if req.Msg.Height > tipAfterReorg {
 					return nil, errors.New("unknown: -8: Block height out of range")
 				}
-				return &connect.Response[corepb.GetBlockHashResponse]{
+				return &connectv1.Response[corepb.GetBlockHashResponse]{
 					Msg: &corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", req.Msg.Height)},
 				}, nil
 			}).Times(5)
 
 		mockBitcoind.EXPECT().
 			GetBlock(gomock.Any(), gomock.Any()).
-			DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockRequest]) (*connect.Response[corepb.GetBlockResponse], error) {
+			DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockRequest]) (*connectv1.Response[corepb.GetBlockResponse], error) {
 				var height uint32
 				if _, err := fmt.Sscanf(req.Msg.Hash, "hash%d", &height); err != nil {
 					return nil, err
 				}
-				return &connect.Response[corepb.GetBlockResponse]{
+				return &connectv1.Response[corepb.GetBlockResponse]{
 					Msg: &corepb.GetBlockResponse{
 						Height: height,
 						Hash:   req.Msg.Hash,
@@ -1507,15 +1508,15 @@ func TestService_ListBlocks(t *testing.T) {
 				}, nil
 			}).Times(3)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{
+		resp, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{
 			PageSize: 5,
-		}))
+		})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.RecentBlocks, 3)
-		assert.Equal(t, uint32(8), resp.Msg.RecentBlocks[0].Height)
-		assert.Equal(t, uint32(6), resp.Msg.RecentBlocks[2].Height)
+		require.Len(t, resp.RecentBlocks, 3)
+		assert.Equal(t, uint32(8), resp.RecentBlocks[0].Height)
+		assert.Equal(t, uint32(6), resp.RecentBlocks[2].Height)
 	})
 
 	t.Run("hasMore is true while the genesis block is not on a page", func(t *testing.T) {
@@ -1526,24 +1527,24 @@ func TestService_ListBlocks(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10},
 			}, nil).Times(2)
 		mockBitcoind.EXPECT().
 			GetBlockHash(gomock.Any(), gomock.Any()).
-			DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockHashRequest]) (*connect.Response[corepb.GetBlockHashResponse], error) {
-				return &connect.Response[corepb.GetBlockHashResponse]{
+			DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockHashRequest]) (*connectv1.Response[corepb.GetBlockHashResponse], error) {
+				return &connectv1.Response[corepb.GetBlockHashResponse]{
 					Msg: &corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", req.Msg.Height)},
 				}, nil
 			}).Times(10)
 		mockBitcoind.EXPECT().
 			GetBlock(gomock.Any(), gomock.Any()).
-			DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockRequest]) (*connect.Response[corepb.GetBlockResponse], error) {
+			DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockRequest]) (*connectv1.Response[corepb.GetBlockResponse], error) {
 				var height uint32
 				if _, err := fmt.Sscanf(req.Msg.Hash, "hash%d", &height); err != nil {
 					return nil, err
 				}
-				return &connect.Response[corepb.GetBlockResponse]{
+				return &connectv1.Response[corepb.GetBlockResponse]{
 					Msg: &corepb.GetBlockResponse{Height: height, Hash: req.Msg.Hash, Time: timestamppb.Now()},
 				}, nil
 			}).Times(10)
@@ -1551,19 +1552,19 @@ func TestService_ListBlocks(t *testing.T) {
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 		expectWatchWalletNoop(mockBitcoind)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		page, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{StartHeight: 5, PageSize: 5}))
+		page, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{StartHeight: 5, PageSize: 5})
 		require.NoError(t, err)
-		require.Len(t, page.Msg.RecentBlocks, 5)
-		assert.Equal(t, uint32(1), page.Msg.RecentBlocks[4].Height)
-		assert.True(t, page.Msg.HasMore)
+		require.Len(t, page.RecentBlocks, 5)
+		assert.Equal(t, uint32(1), page.RecentBlocks[4].Height)
+		assert.True(t, page.HasMore)
 
-		last, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{StartHeight: 4, PageSize: 5}))
+		last, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{StartHeight: 4, PageSize: 5})
 		require.NoError(t, err)
-		require.Len(t, last.Msg.RecentBlocks, 5)
-		assert.Equal(t, uint32(0), last.Msg.RecentBlocks[4].Height)
-		assert.False(t, last.Msg.HasMore)
+		require.Len(t, last.RecentBlocks, 5)
+		assert.Equal(t, uint32(0), last.RecentBlocks[4].Height)
+		assert.False(t, last.HasMore)
 	})
 
 	t.Run("hasMore is false when the genesis block is on a shorter page", func(t *testing.T) {
@@ -1574,41 +1575,41 @@ func TestService_ListBlocks(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10},
 			}, nil)
 		mockBitcoind.EXPECT().
 			GetBlockHash(gomock.Any(), gomock.Any()).
-			DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockHashRequest]) (*connect.Response[corepb.GetBlockHashResponse], error) {
+			DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockHashRequest]) (*connectv1.Response[corepb.GetBlockHashResponse], error) {
 				// The chain lost block 4 after the tip read.
 				if req.Msg.Height == 4 {
 					return nil, errors.New("Block height out of range")
 				}
-				return &connect.Response[corepb.GetBlockHashResponse]{
+				return &connectv1.Response[corepb.GetBlockHashResponse]{
 					Msg: &corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", req.Msg.Height)},
 				}, nil
 			}).Times(5)
 		mockBitcoind.EXPECT().
 			GetBlock(gomock.Any(), gomock.Any()).
-			DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockRequest]) (*connect.Response[corepb.GetBlockResponse], error) {
+			DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockRequest]) (*connectv1.Response[corepb.GetBlockResponse], error) {
 				var height uint32
 				if _, err := fmt.Sscanf(req.Msg.Hash, "hash%d", &height); err != nil {
 					return nil, err
 				}
-				return &connect.Response[corepb.GetBlockResponse]{
+				return &connectv1.Response[corepb.GetBlockResponse]{
 					Msg: &corepb.GetBlockResponse{Height: height, Hash: req.Msg.Hash, Time: timestamppb.Now()},
 				}, nil
 			}).Times(4)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 		expectWatchWalletNoop(mockBitcoind)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		page, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{StartHeight: 4, PageSize: 5}))
+		page, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{StartHeight: 4, PageSize: 5})
 		require.NoError(t, err)
-		require.Len(t, page.Msg.RecentBlocks, 4)
-		assert.Equal(t, uint32(0), page.Msg.RecentBlocks[3].Height)
-		assert.False(t, page.Msg.HasMore)
+		require.Len(t, page.RecentBlocks, 4)
+		assert.Equal(t, uint32(0), page.RecentBlocks[3].Height)
+		assert.False(t, page.HasMore)
 	})
 
 	t.Run("repeat call at the same tip is served from cache", func(t *testing.T) {
@@ -1623,28 +1624,28 @@ func TestService_ListBlocks(t *testing.T) {
 		// GetBlockHash + GetBlock fire 5× (= pageSize) total across both
 		// calls — the second call must come from cache.
 		mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10},
 			}, nil).Times(2)
 		mockBitcoind.EXPECT().GetBlockHash(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockHashResponse]{
+			Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 				Msg: &corepb.GetBlockHashResponse{Hash: "h"},
 			}, nil).Times(5)
 		mockBitcoind.EXPECT().GetBlock(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockResponse]{
+			Return(&connectv1.Response[corepb.GetBlockResponse]{
 				Msg: &corepb.GetBlockResponse{Height: 10, Hash: "h", Time: timestamppb.Now()},
 			}, nil).Times(5)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		req := connect.NewRequest(&v1.ListBlocksRequest{PageSize: 5})
+		req := &v1.ListBlocksRequest{PageSize: 5}
 		first, err := cli.ListBlocks(t.Context(), req)
 		require.NoError(t, err)
-		require.Len(t, first.Msg.RecentBlocks, 5)
+		require.Len(t, first.RecentBlocks, 5)
 
-		second, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 5}))
+		second, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 5})
 		require.NoError(t, err)
-		require.Len(t, second.Msg.RecentBlocks, 5)
+		require.Len(t, second.RecentBlocks, 5)
 	})
 
 	t.Run("cache is dropped on same-height reorg (different best-block-hash)", func(t *testing.T) {
@@ -1660,28 +1661,28 @@ func TestService_ListBlocks(t *testing.T) {
 		// must do its own fan-out (10 fetches each = 20 total).
 		gomock.InOrder(
 			mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+				Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 					Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10, BestBlockHash: "hash-A"},
 				}, nil),
 			mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+				Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 					Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10, BestBlockHash: "hash-B"},
 				}, nil),
 		)
 		mockBitcoind.EXPECT().GetBlockHash(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockHashResponse]{
+			Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 				Msg: &corepb.GetBlockHashResponse{Hash: "h"},
 			}, nil).Times(10)
 		mockBitcoind.EXPECT().GetBlock(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockResponse]{
+			Return(&connectv1.Response[corepb.GetBlockResponse]{
 				Msg: &corepb.GetBlockResponse{Height: 10, Hash: "h", Time: timestamppb.Now()},
 			}, nil).Times(10)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 5}))
+		_, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 5})
 		require.NoError(t, err)
-		_, err = cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 5}))
+		_, err = cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 5})
 		require.NoError(t, err)
 	})
 
@@ -1695,33 +1696,33 @@ func TestService_ListBlocks(t *testing.T) {
 		expectWatchWalletNoop(mockBitcoind)
 
 		mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10, BestBlockHash: "h"},
 			}, nil).Times(2)
 		mockBitcoind.EXPECT().GetBlockHash(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockHashResponse]{
+			Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 				Msg: &corepb.GetBlockHashResponse{Hash: "h"},
 			}, nil).Times(3)
 		mockBitcoind.EXPECT().GetBlock(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockResponse]{
+			Return(&connectv1.Response[corepb.GetBlockResponse]{
 				Msg: &corepb.GetBlockResponse{Height: 10, Hash: "h", Time: timestamppb.Now()},
 			}, nil).Times(3)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		first, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 3}))
+		first, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 3})
 		require.NoError(t, err)
-		require.Len(t, first.Msg.RecentBlocks, 3)
+		require.Len(t, first.RecentBlocks, 3)
 
 		// Mutate the response: if the cache shared its backing array
 		// we'd corrupt the next caller.
-		first.Msg.RecentBlocks[0] = nil
-		first.Msg.RecentBlocks = append(first.Msg.RecentBlocks, nil, nil, nil, nil)
+		first.RecentBlocks[0] = nil
+		first.RecentBlocks = append(first.RecentBlocks, nil, nil, nil, nil)
 
-		second, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 3}))
+		second, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 3})
 		require.NoError(t, err)
-		require.Len(t, second.Msg.RecentBlocks, 3, "cache must hand out a fresh slice")
-		require.NotNil(t, second.Msg.RecentBlocks[0])
+		require.Len(t, second.RecentBlocks, 3, "cache must hand out a fresh slice")
+		require.NotNil(t, second.RecentBlocks[0])
 	})
 
 	t.Run("cache is dropped when tip moves", func(t *testing.T) {
@@ -1733,11 +1734,11 @@ func TestService_ListBlocks(t *testing.T) {
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 
 		mockBitcoind.EXPECT().ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
@@ -1746,28 +1747,28 @@ func TestService_ListBlocks(t *testing.T) {
 		// 5 times PER call = 10 total.
 		gomock.InOrder(
 			mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+				Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 					Msg: &corepb.GetBlockchainInfoResponse{Blocks: 10},
 				}, nil),
 			mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+				Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 					Msg: &corepb.GetBlockchainInfoResponse{Blocks: 11},
 				}, nil),
 		)
 		mockBitcoind.EXPECT().GetBlockHash(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockHashResponse]{
+			Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 				Msg: &corepb.GetBlockHashResponse{Hash: "h"},
 			}, nil).Times(10)
 		mockBitcoind.EXPECT().GetBlock(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockResponse]{
+			Return(&connectv1.Response[corepb.GetBlockResponse]{
 				Msg: &corepb.GetBlockResponse{Height: 10, Hash: "h", Time: timestamppb.Now()},
 			}, nil).Times(10)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 5}))
+		_, err := cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 5})
 		require.NoError(t, err)
-		_, err = cli.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 5}))
+		_, err = cli.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 5})
 		require.NoError(t, err)
 	})
 }
@@ -1786,19 +1787,19 @@ func TestService_ListRecentTransactions(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
 		// Mock GetRawMempool with one tx
 		mockBitcoind.EXPECT().
 			GetRawMempool(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetRawMempoolResponse]{
+			Return(&connectv1.Response[corepb.GetRawMempoolResponse]{
 				Msg: &corepb.GetRawMempoolResponse{
 					Transactions: map[string]*corepb.MempoolEntry{
 						"mempool_tx1": {
@@ -1815,7 +1816,7 @@ func TestService_ListRecentTransactions(t *testing.T) {
 		// Mock GetBlockchainInfo - return BestBlockHash
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Blocks:        1,
 					BestBlockHash: "blockhash1",
@@ -1825,7 +1826,7 @@ func TestService_ListRecentTransactions(t *testing.T) {
 		// Mock GetBlock - returns empty txids to avoid needing GetRawTransaction mocks
 		mockBitcoind.EXPECT().
 			GetBlock(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockResponse]{
+			Return(&connectv1.Response[corepb.GetBlockResponse]{
 				Msg: &corepb.GetBlockResponse{
 					Height:            1,
 					Hash:              "blockhash1",
@@ -1835,15 +1836,15 @@ func TestService_ListRecentTransactions(t *testing.T) {
 				},
 			}, nil).Times(2) // First for GetBlock with BestBlockHash, second for the loop
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListRecentTransactions(t.Context(), connect.NewRequest(&v1.ListRecentTransactionsRequest{
+		resp, err := cli.ListRecentTransactions(t.Context(), &v1.ListRecentTransactionsRequest{
 			Count: 10,
-		}))
+		})
 		require.NoError(t, err)
 		// Should have 1 mempool tx
-		assert.Len(t, resp.Msg.Transactions, 1)
-		assert.Equal(t, "mempool_tx1", resp.Msg.Transactions[0].Txid)
+		assert.Len(t, resp.Transactions, 1)
+		assert.Equal(t, "mempool_tx1", resp.Transactions[0].Txid)
 	})
 
 	t.Run("empty mempool and genesis block", func(t *testing.T) {
@@ -1857,19 +1858,19 @@ func TestService_ListRecentTransactions(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
 		// Empty mempool
 		mockBitcoind.EXPECT().
 			GetRawMempool(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetRawMempoolResponse]{
+			Return(&connectv1.Response[corepb.GetRawMempoolResponse]{
 				Msg: &corepb.GetRawMempoolResponse{
 					Transactions: map[string]*corepb.MempoolEntry{},
 				},
@@ -1877,7 +1878,7 @@ func TestService_ListRecentTransactions(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Blocks:        0,
 					BestBlockHash: "genesis",
@@ -1887,7 +1888,7 @@ func TestService_ListRecentTransactions(t *testing.T) {
 		// Genesis block - empty txids
 		mockBitcoind.EXPECT().
 			GetBlock(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockResponse]{
+			Return(&connectv1.Response[corepb.GetBlockResponse]{
 				Msg: &corepb.GetBlockResponse{
 					Height:            0,
 					Hash:              "genesis",
@@ -1897,13 +1898,13 @@ func TestService_ListRecentTransactions(t *testing.T) {
 				},
 			}, nil).Times(2)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListRecentTransactions(t.Context(), connect.NewRequest(&v1.ListRecentTransactionsRequest{
+		resp, err := cli.ListRecentTransactions(t.Context(), &v1.ListRecentTransactionsRequest{
 			Count: 10,
-		}))
+		})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Transactions)
+		assert.Empty(t, resp.Transactions)
 	})
 }
 
@@ -1921,19 +1922,19 @@ func TestService_GetNetworkStats(t *testing.T) {
 
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
 		// Mock GetBlockchainInfo
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Blocks: 1000,
 					Chain:  "signet",
@@ -1943,14 +1944,14 @@ func TestService_GetNetworkStats(t *testing.T) {
 		// Mock GetBlockHash for calculating avg block time and difficulty
 		mockBitcoind.EXPECT().
 			GetBlockHash(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockHashResponse]{
+			Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 				Msg: &corepb.GetBlockHashResponse{Hash: "latesthash"},
 			}, nil).AnyTimes()
 
 		// Mock GetBlock for difficulty and avg block time calculation
 		mockBitcoind.EXPECT().
 			GetBlock(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockResponse]{
+			Return(&connectv1.Response[corepb.GetBlockResponse]{
 				Msg: &corepb.GetBlockResponse{
 					Height:     1000,
 					Hash:       "latesthash",
@@ -1962,7 +1963,7 @@ func TestService_GetNetworkStats(t *testing.T) {
 		// Mock GetNetworkInfo
 		mockBitcoind.EXPECT().
 			GetNetworkInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetNetworkInfoResponse]{
+			Return(&connectv1.Response[corepb.GetNetworkInfoResponse]{
 				Msg: &corepb.GetNetworkInfoResponse{
 					Version:    250000,
 					Subversion: "/Satoshi:25.0.0/",
@@ -1972,7 +1973,7 @@ func TestService_GetNetworkStats(t *testing.T) {
 		// Mock GetNetTotals
 		mockBitcoind.EXPECT().
 			GetNetTotals(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetNetTotalsResponse]{
+			Return(&connectv1.Response[corepb.GetNetTotalsResponse]{
 				Msg: &corepb.GetNetTotalsResponse{
 					TotalBytesRecv: 1000000,
 					TotalBytesSent: 500000,
@@ -1982,7 +1983,7 @@ func TestService_GetNetworkStats(t *testing.T) {
 		// Mock GetPeerInfo
 		mockBitcoind.EXPECT().
 			GetPeerInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetPeerInfoResponse]{
+			Return(&connectv1.Response[corepb.GetPeerInfoResponse]{
 				Msg: &corepb.GetPeerInfoResponse{
 					Peers: []*corepb.Peer{
 						{Inbound: true},
@@ -1992,20 +1993,20 @@ func TestService_GetNetworkStats(t *testing.T) {
 				},
 			}, nil)
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.GetNetworkStats(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.GetNetworkStats(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 
-		assert.Equal(t, int64(1000), resp.Msg.BlockHeight)
-		assert.Equal(t, int32(3), resp.Msg.PeerCount)
-		assert.Equal(t, int32(1), resp.Msg.ConnectionsIn)
-		assert.Equal(t, int32(2), resp.Msg.ConnectionsOut)
-		assert.Equal(t, uint64(1000000), resp.Msg.TotalBytesReceived)
-		assert.Equal(t, uint64(500000), resp.Msg.TotalBytesSent)
-		assert.Equal(t, int32(250000), resp.Msg.NetworkVersion)
-		assert.Equal(t, "/Satoshi:25.0.0/", resp.Msg.Subversion)
-		assert.Equal(t, 12345.67, resp.Msg.Difficulty)
+		assert.Equal(t, int64(1000), resp.BlockHeight)
+		assert.Equal(t, int32(3), resp.PeerCount)
+		assert.Equal(t, int32(1), resp.ConnectionsIn)
+		assert.Equal(t, int32(2), resp.ConnectionsOut)
+		assert.Equal(t, uint64(1000000), resp.TotalBytesReceived)
+		assert.Equal(t, uint64(500000), resp.TotalBytesSent)
+		assert.Equal(t, int32(250000), resp.NetworkVersion)
+		assert.Equal(t, "/Satoshi:25.0.0/", resp.Subversion)
+		assert.Equal(t, 12345.67, resp.Difficulty)
 	})
 
 	for _, tc := range []struct {
@@ -2014,7 +2015,7 @@ func TestService_GetNetworkStats(t *testing.T) {
 		code connect.Code
 	}{
 		{"a plain network info failure returns Unknown", errors.New("rpc broke"), connect.CodeUnknown},
-		{"a Core warmup keeps its code", connect.NewError(connect.CodeFailedPrecondition, errors.New("Loading block index")), connect.CodeFailedPrecondition},
+		{"a Core warmup keeps its code", connect.NewError(connect.CodeFailedPrecondition, "Loading block index"), connect.CodeFailedPrecondition},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
@@ -2024,28 +2025,32 @@ func TestService_GetNetworkStats(t *testing.T) {
 			apitests.ExpectCoreWalletSetup(mockBitcoind)
 			mockBitcoind.EXPECT().
 				GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+				Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 					Msg: &corepb.GetBlockchainInfoResponse{Blocks: 2, Chain: "signet"},
 				}, nil)
 			mockBitcoind.EXPECT().
 				GetBlockHash(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockHashResponse]{
+				Return(&connectv1.Response[corepb.GetBlockHashResponse]{
 					Msg: &corepb.GetBlockHashResponse{Hash: "latesthash"},
 				}, nil).AnyTimes()
 			mockBitcoind.EXPECT().
 				GetBlock(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockResponse]{
+				Return(&connectv1.Response[corepb.GetBlockResponse]{
 					Msg: &corepb.GetBlockResponse{Hash: "latesthash", Time: timestamppb.Now(), Difficulty: 1},
 				}, nil).AnyTimes()
 			mockBitcoind.EXPECT().
 				GetNetworkInfo(gomock.Any(), gomock.Any()).
 				Return(nil, tc.err)
 
-			cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
+			cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
 
-			_, err := cli.GetNetworkStats(t.Context(), connect.NewRequest(&emptypb.Empty{}))
-			require.ErrorContains(t, err, tc.err.Error())
+			_, err := cli.GetNetworkStats(t.Context(), &emptypb.Empty{})
 			require.Equal(t, tc.code, connect.CodeOf(err))
+			if tc.code == connect.CodeUnknown {
+				require.NotContains(t, err.Error(), tc.err.Error())
+			} else {
+				require.ErrorContains(t, err, tc.err.Error())
+			}
 		})
 	}
 }
@@ -2061,49 +2066,49 @@ func TestService_Labels(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db))
 		ctx := t.Context()
 
-		_, err := cli.CreateAddressBookEntry(ctx, connect.NewRequest(&v1.CreateAddressBookEntryRequest{
+		_, err := cli.CreateAddressBookEntry(ctx, &v1.CreateAddressBookEntryRequest{
 			Label:     "donations",
 			Address:   addr,
 			Direction: v1.Direction_DIRECTION_RECEIVE,
-		}))
+		})
 		require.NoError(t, err)
 
-		_, err = cli.SetTransactionNote(ctx, connect.NewRequest(&v1.SetTransactionNoteRequest{
+		_, err = cli.SetTransactionNote(ctx, &v1.SetTransactionNoteRequest{
 			Txid: txid,
 			Note: "coffee",
-		}))
+		})
 		require.NoError(t, err)
 
-		exported, err := cli.ExportLabels(ctx, connect.NewRequest(&emptypb.Empty{}))
+		exported, err := cli.ExportLabels(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.Contains(t, exported.Msg.Jsonl, "donations")
-		assert.Contains(t, exported.Msg.Jsonl, "coffee")
+		assert.Contains(t, exported.Jsonl, "donations")
+		assert.Contains(t, exported.Jsonl, "coffee")
 
 		// Re-import into a fresh DB; the same labels must land.
 		db2 := database.Test(t)
-		cli2 := v1connect.NewBitwindowdServiceClient(apitests.API(t, db2))
+		cli2 := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db2))
 
-		imp, err := cli2.ImportLabels(ctx, connect.NewRequest(&v1.ImportLabelsRequest{
-			Jsonl: exported.Msg.Jsonl,
-		}))
+		imp, err := cli2.ImportLabels(ctx, &v1.ImportLabelsRequest{
+			Jsonl: exported.Jsonl,
+		})
 		require.NoError(t, err)
-		assert.Equal(t, int64(1), imp.Msg.ImportedAddresses)
-		assert.Equal(t, int64(1), imp.Msg.ImportedTransactions)
-		assert.Equal(t, int64(0), imp.Msg.Skipped)
+		assert.Equal(t, int64(1), imp.ImportedAddresses)
+		assert.Equal(t, int64(1), imp.ImportedTransactions)
+		assert.Equal(t, int64(0), imp.Skipped)
 
-		reexported, err := cli2.ExportLabels(ctx, connect.NewRequest(&emptypb.Empty{}))
+		reexported, err := cli2.ExportLabels(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.Equal(t, exported.Msg.Jsonl, reexported.Msg.Jsonl)
+		assert.Equal(t, exported.Jsonl, reexported.Jsonl)
 	})
 
 	t.Run("imports sparrow sample and skips malformed", func(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db))
 		ctx := t.Context()
 
 		sample := `{"type":"tx","ref":"` + txid + `","label":"Restaurant"}
@@ -2115,54 +2120,54 @@ this line is not valid json
 
 `
 
-		imp, err := cli.ImportLabels(ctx, connect.NewRequest(&v1.ImportLabelsRequest{Jsonl: sample}))
+		imp, err := cli.ImportLabels(ctx, &v1.ImportLabelsRequest{Jsonl: sample})
 		require.NoError(t, err)
-		assert.Equal(t, int64(1), imp.Msg.ImportedAddresses)
-		assert.Equal(t, int64(1), imp.Msg.ImportedTransactions)
-		assert.Equal(t, int64(1), imp.Msg.ImportedOutputs)
+		assert.Equal(t, int64(1), imp.ImportedAddresses)
+		assert.Equal(t, int64(1), imp.ImportedTransactions)
+		assert.Equal(t, int64(1), imp.ImportedOutputs)
 		// xpub + input (unsupported) + malformed json = 3 skipped.
-		assert.Equal(t, int64(3), imp.Msg.Skipped)
+		assert.Equal(t, int64(3), imp.Skipped)
 
-		exported, err := cli.ExportLabels(ctx, connect.NewRequest(&emptypb.Empty{}))
+		exported, err := cli.ExportLabels(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.Contains(t, exported.Msg.Jsonl, "Restaurant")
-		assert.Contains(t, exported.Msg.Jsonl, "Savings")
-		assert.Contains(t, exported.Msg.Jsonl, "Coinjoin change")
+		assert.Contains(t, exported.Jsonl, "Restaurant")
+		assert.Contains(t, exported.Jsonl, "Savings")
+		assert.Contains(t, exported.Jsonl, "Coinjoin change")
 	})
 
 	t.Run("skips an address that does not classify", func(t *testing.T) {
 		t.Parallel()
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database.Test(t)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database.Test(t)))
 
-		imp, err := cli.ImportLabels(t.Context(), connect.NewRequest(&v1.ImportLabelsRequest{
+		imp, err := cli.ImportLabels(t.Context(), &v1.ImportLabelsRequest{
 			Jsonl: `{"type":"addr","ref":"not-an-address","label":"Savings"}`,
-		}))
+		})
 		require.NoError(t, err)
-		assert.Equal(t, int64(0), imp.Msg.ImportedAddresses)
-		assert.Equal(t, int64(1), imp.Msg.Skipped)
+		assert.Equal(t, int64(0), imp.ImportedAddresses)
+		assert.Equal(t, int64(1), imp.Skipped)
 	})
 
 	t.Run("a label maps to one address", func(t *testing.T) {
 		t.Parallel()
 
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, database.Test(t)))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, database.Test(t)))
 		ctx := t.Context()
 
-		imp, err := cli.ImportLabels(ctx, connect.NewRequest(&v1.ImportLabelsRequest{
+		imp, err := cli.ImportLabels(ctx, &v1.ImportLabelsRequest{
 			Jsonl: `{"type":"addr","ref":"bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh","label":" rent "}
 {"type":"addr","ref":"bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq","label":"Rent"}
 {"type":"addr","ref":"bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh","label":"rent"}`,
-		}))
+		})
 		require.NoError(t, err)
-		assert.Equal(t, int64(2), imp.Msg.ImportedAddresses)
-		assert.Equal(t, int64(1), imp.Msg.Skipped)
+		assert.Equal(t, int64(2), imp.ImportedAddresses)
+		assert.Equal(t, int64(1), imp.Skipped)
 
-		list, err := cli.ListAddressBook(ctx, connect.NewRequest(&emptypb.Empty{}))
+		list, err := cli.ListAddressBook(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
-		require.Len(t, list.Msg.Entries, 1)
-		assert.Equal(t, "rent", list.Msg.Entries[0].Label)
-		assert.Equal(t, "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh", list.Msg.Entries[0].Address)
+		require.Len(t, list.Entries, 1)
+		assert.Equal(t, "rent", list.Entries[0].Label)
+		assert.Equal(t, "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh", list.Entries[0].Address)
 	})
 
 	t.Run("a send address keeps its direction", func(t *testing.T) {
@@ -2172,32 +2177,33 @@ this line is not valid json
 		ctx := t.Context()
 		const address = "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh"
 		require.NoError(t, addressbook.Create(ctx, db, nil, "old", address, addressbook.DirectionSend))
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db))
 
-		imp, err := cli.ImportLabels(ctx, connect.NewRequest(&v1.ImportLabelsRequest{
+		imp, err := cli.ImportLabels(ctx, &v1.ImportLabelsRequest{
 			Jsonl: `{"type":"addr","ref":"` + address + `","label":"Landlord"}`,
-		}))
+		})
 		require.NoError(t, err)
-		assert.Equal(t, int64(1), imp.Msg.ImportedAddresses)
+		assert.Equal(t, int64(1), imp.ImportedAddresses)
 
-		list, err := cli.ListAddressBook(ctx, connect.NewRequest(&emptypb.Empty{}))
+		list, err := cli.ListAddressBook(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
-		require.Len(t, list.Msg.Entries, 1)
-		assert.Equal(t, "Landlord", list.Msg.Entries[0].Label)
-		assert.Equal(t, v1.Direction_DIRECTION_SEND, list.Msg.Entries[0].Direction)
+		require.Len(t, list.Entries, 1)
+		assert.Equal(t, "Landlord", list.Entries[0].Label)
+		assert.Equal(t, v1.Direction_DIRECTION_SEND, list.Entries[0].Direction)
 	})
 
 	t.Run("returns a database fault", func(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db))
+		cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db))
 		require.NoError(t, db.Close())
 
-		_, err := cli.ImportLabels(t.Context(), connect.NewRequest(&v1.ImportLabelsRequest{
+		_, err := cli.ImportLabels(t.Context(), &v1.ImportLabelsRequest{
 			Jsonl: `{"type":"tx","ref":"` + txid + `","label":"Restaurant"}`,
-		}))
-		require.ErrorContains(t, err, "sql: database is closed")
+		})
+		require.Equal(t, connect.CodeUnknown, connect.CodeOf(err))
+		require.NotContains(t, err.Error(), "sql: database is closed")
 	})
 }
 
@@ -2205,11 +2211,11 @@ this line is not valid json
 // for tests that don't care about it.
 func expectWatchWalletNoop(m *mocks.MockBitcoinServiceClient) {
 	m.EXPECT().ListWallets(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.ListWalletsResponse]{
+		Return(&connectv1.Response[corepb.ListWalletsResponse]{
 			Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 		}, nil).AnyTimes()
 	m.EXPECT().CreateWallet(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.CreateWalletResponse]{
+		Return(&connectv1.Response[corepb.CreateWalletResponse]{
 			Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 		}, nil).AnyTimes()
 }
diff --git a/bitwindow/server/api/bitwindowd/mining_pools_test.go b/bitwindow/server/api/bitwindowd/mining_pools_test.go
index 4024c3402a..520b20f838 100644
--- a/bitwindow/server/api/bitwindowd/mining_pools_test.go
+++ b/bitwindow/server/api/bitwindowd/mining_pools_test.go
@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/stretchr/testify/assert"
@@ -82,10 +82,10 @@ func TestService_ListMiningPools(t *testing.T) {
 		}))
 		server := api_bitwindowd.New(nil, db, nil, nil, nil, regtestRegistry(t), config.Config{}, nil)
 
-		response, err := server.ListMiningPools(t.Context(), connect.NewRequest(&v1.ListMiningPoolsRequest{}))
+		response, err := server.ListMiningPools(t.Context(), &v1.ListMiningPoolsRequest{})
 		require.NoError(t, err)
 
-		msg := response.Msg
+		msg := response
 		assert.EqualValues(t, 3, msg.BlockCount)
 		assert.EqualValues(t, 11, msg.FromHeight)
 		assert.EqualValues(t, 13, msg.ToHeight)
@@ -120,12 +120,12 @@ func TestService_ListMiningPools(t *testing.T) {
 		}))
 		server := api_bitwindowd.New(nil, db, nil, nil, nil, regtestRegistry(t), config.Config{}, nil)
 
-		response, err := server.ListMiningPools(t.Context(), connect.NewRequest(&v1.ListMiningPoolsRequest{
+		response, err := server.ListMiningPools(t.Context(), &v1.ListMiningPoolsRequest{
 			Window: v1.MiningPoolWindow_MINING_POOL_WINDOW_1W,
-		}))
+		})
 		require.NoError(t, err)
-		assert.EqualValues(t, 2, response.Msg.BlockCount)
-		assert.EqualValues(t, 10, response.Msg.FromHeight)
+		assert.EqualValues(t, 2, response.BlockCount)
+		assert.EqualValues(t, 10, response.FromHeight)
 	})
 
 	t.Run("a network with no registry lists only Unknown", func(t *testing.T) {
@@ -137,11 +137,11 @@ func TestService_ListMiningPools(t *testing.T) {
 		registry := miningpools.New(t.Context(), config.NetworkSignet, "", "", offlineRegistry)
 		server := api_bitwindowd.New(nil, db, nil, nil, nil, registry, config.Config{}, nil)
 
-		response, err := server.ListMiningPools(t.Context(), connect.NewRequest(&v1.ListMiningPoolsRequest{}))
+		response, err := server.ListMiningPools(t.Context(), &v1.ListMiningPoolsRequest{})
 		require.NoError(t, err)
-		assert.False(t, response.Msg.RegistryAvailable)
-		require.Len(t, response.Msg.Pools, 1)
-		assert.Equal(t, miningpools.Unknown.Name, response.Msg.Pools[0].Pool.Name)
+		assert.False(t, response.RegistryAvailable)
+		require.Len(t, response.Pools, 1)
+		assert.Equal(t, miningpools.Unknown.Name, response.Pools[0].Pool.Name)
 	})
 }
 
@@ -165,14 +165,14 @@ func TestService_ListBlocksNamesThePool(t *testing.T) {
 
 			mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 			mockBitcoind.EXPECT().GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(connect.NewResponse(&corepb.GetBlockchainInfoResponse{Blocks: 100, BestBlockHash: "hash100"}), nil)
+				Return(connectv1.NewResponse(&corepb.GetBlockchainInfoResponse{Blocks: 100, BestBlockHash: "hash100"}), nil)
 			mockBitcoind.EXPECT().GetBlockHash(gomock.Any(), gomock.Any()).
-				DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockHashRequest]) (*connect.Response[corepb.GetBlockHashResponse], error) {
-					return connect.NewResponse(&corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", req.Msg.Height)}), nil
+				DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockHashRequest]) (*connectv1.Response[corepb.GetBlockHashResponse], error) {
+					return connectv1.NewResponse(&corepb.GetBlockHashResponse{Hash: fmt.Sprintf("hash%d", req.Msg.Height)}), nil
 				}).AnyTimes()
 			mockBitcoind.EXPECT().GetBlock(gomock.Any(), gomock.Any()).
-				DoAndReturn(func(_ context.Context, req *connect.Request[corepb.GetBlockRequest]) (*connect.Response[corepb.GetBlockResponse], error) {
-					return connect.NewResponse(&corepb.GetBlockResponse{Height: 100, Hash: req.Msg.Hash}), nil
+				DoAndReturn(func(_ context.Context, req *connectv1.Request[corepb.GetBlockRequest]) (*connectv1.Response[corepb.GetBlockResponse], error) {
+					return connectv1.NewResponse(&corepb.GetBlockResponse{Height: 100, Hash: req.Msg.Hash}), nil
 				}).AnyTimes()
 			core := service.New("bitcoind", func(context.Context) (corerpc.BitcoinServiceClient, error) {
 				return mockBitcoind, nil
@@ -180,10 +180,10 @@ func TestService_ListBlocksNamesThePool(t *testing.T) {
 			conf := config.Config{BitcoinCoreNetwork: config.NetworkRegtest}
 			server := api_bitwindowd.New(nil, db, core, nil, nil, regtestRegistry(t), conf, nil)
 
-			response, err := server.ListBlocks(t.Context(), connect.NewRequest(&v1.ListBlocksRequest{PageSize: 1}))
+			response, err := server.ListBlocks(t.Context(), &v1.ListBlocksRequest{PageSize: 1})
 			require.NoError(t, err)
-			require.Len(t, response.Msg.RecentBlocks, 1)
-			assert.Equal(t, test.wantPool, response.Msg.RecentBlocks[0].GetPool().GetName())
+			require.Len(t, response.RecentBlocks, 1)
+			assert.Equal(t, test.wantPool, response.RecentBlocks[0].GetPool().GetName())
 		})
 	}
 }
diff --git a/bitwindow/server/api/bitwindowd/sync_info_test.go b/bitwindow/server/api/bitwindowd/sync_info_test.go
index 399fca4fa4..0fafb97a57 100644
--- a/bitwindow/server/api/bitwindowd/sync_info_test.go
+++ b/bitwindow/server/api/bitwindowd/sync_info_test.go
@@ -3,7 +3,7 @@ package bitwindowd_test
 import (
 	"testing"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -44,7 +44,7 @@ func TestGetSyncInfoWaitsForCore(t *testing.T) {
 			apitests.ExpectCoreWalletSetup(bitcoind)
 			bitcoind.EXPECT().
 				GetBlockchainInfo(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+				Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 					Msg: &corepb.GetBlockchainInfoResponse{
 						Blocks:               900_000,
 						Headers:              967_362,
@@ -54,7 +54,7 @@ func TestGetSyncInfoWaitsForCore(t *testing.T) {
 				AnyTimes()
 			bitcoind.EXPECT().
 				GetRawMempool(gomock.Any(), gomock.Any()).
-				Return(&connect.Response[corepb.GetRawMempoolResponse]{
+				Return(&connectv1.Response[corepb.GetRawMempoolResponse]{
 					Msg: &corepb.GetRawMempoolResponse{},
 				}, nil).
 				AnyTimes()
@@ -63,15 +63,15 @@ func TestGetSyncInfoWaitsForCore(t *testing.T) {
 				Return(nil, assert.AnError).
 				AnyTimes()
 
-			cli := v1connect.NewBitwindowdServiceClient(apitests.API(t, db,
+			cli := v1connect.NewBitwindowdServiceClient(apitests.RPC(t, db,
 				apitests.WithBitcoind(bitcoind),
 				apitests.WithNetwork(tc.network),
 			))
 
-			res, err := cli.GetSyncInfo(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+			res, err := cli.GetSyncInfo(t.Context(), &emptypb.Empty{})
 			require.NoError(t, err)
-			assert.Equal(t, tc.want, res.Msg.WaitsForCore)
-			assert.Equal(t, int64(967_362), res.Msg.HeaderHeight)
+			assert.Equal(t, tc.want, res.WaitsForCore)
+			assert.Equal(t, int64(967_362), res.HeaderHeight)
 		})
 	}
 }
diff --git a/bitwindow/server/api/bitwindowd/update_network_test.go b/bitwindow/server/api/bitwindowd/update_network_test.go
index 8e4d0157e1..5047076ee9 100644
--- a/bitwindow/server/api/bitwindowd/update_network_test.go
+++ b/bitwindow/server/api/bitwindowd/update_network_test.go
@@ -2,13 +2,13 @@ package bitwindowd_test
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/stretchr/testify/require"
 
 	api_bitwindowd "github.com/LayerTwo-Labs/sidesail/bitwindow/server/api/bitwindowd"
@@ -29,30 +29,33 @@ type migrationNetworkServer struct {
 	calls       chan string
 }
 
-func (s *migrationNetworkServer) PlanECashSwitch(_ context.Context, req *connect.Request[orchpb.PlanECashSwitchRequest]) (*connect.Response[orchpb.PlanECashSwitchResponse], error) {
-	s.calls <- "plan:" + req.Msg.NetworkId
-	return connect.NewResponse(s.plan), nil
+func (s *migrationNetworkServer) PlanECashSwitch(_ context.Context, req *orchpb.PlanECashSwitchRequest) (*orchpb.PlanECashSwitchResponse, error) {
+	s.calls <- "plan:" + req.NetworkId
+	return s.plan, nil
 }
 
-func (s *migrationNetworkServer) GetECashMigrationStatus(context.Context, *connect.Request[orchpb.GetECashMigrationStatusRequest]) (*connect.Response[orchpb.GetECashMigrationStatusResponse], error) {
+func (s *migrationNetworkServer) GetECashMigrationStatus(context.Context, *orchpb.GetECashMigrationStatusRequest) (*orchpb.GetECashMigrationStatusResponse, error) {
 	s.calls <- "status"
 	if s.statusError != nil {
 		return nil, s.statusError
 	}
-	return connect.NewResponse(&orchpb.GetECashMigrationStatusResponse{Status: s.status}), nil
+	return &orchpb.GetECashMigrationStatusResponse{Status: s.status}, nil
 }
 
-func (s *migrationNetworkServer) SetBitcoinConfigNetwork(_ context.Context, req *connect.Request[orchpb.SetBitcoinConfigNetworkRequest]) (*connect.Response[orchpb.SetBitcoinConfigNetworkResponse], error) {
-	s.calls <- "select:" + req.Msg.Network
-	return connect.NewResponse(&orchpb.SetBitcoinConfigNetworkResponse{}), nil
+func (s *migrationNetworkServer) SetBitcoinConfigNetwork(_ context.Context, req *orchpb.SetBitcoinConfigNetworkRequest) (*orchpb.SetBitcoinConfigNetworkResponse, error) {
+	s.calls <- "select:" + req.Network
+	return &orchpb.SetBitcoinConfigNetworkResponse{}, nil
 }
 
 func newMigrationNetworkServer(t *testing.T, handler *migrationNetworkServer) string {
 	t.Helper()
 	handler.calls = make(chan string, 10)
 	mux := http.NewServeMux()
-	mux.Handle(orchrpc.NewBitcoinConfServiceHandler(handler))
-	mux.Handle(orchrpc.NewOrchestratorServiceHandler(handler))
+	srv := connect.NewServer()
+	orchrpc.RegisterBitcoinConfServiceHandler(srv, handler)
+	orchrpc.RegisterOrchestratorServiceHandler(srv, handler)
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
+
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
 	return server.URL
@@ -125,7 +128,7 @@ func TestUpdateNetworkKeepsCompletedMigrationRows(t *testing.T) {
 				return engines.ResetChainData(ctx, db, height)
 			})
 
-			_, err = server.UpdateNetwork(t.Context(), connect.NewRequest(&pb.UpdateNetworkRequest{Network: "ecash", NetworkId: "betanet"}))
+			_, err = server.UpdateNetwork(t.Context(), &pb.UpdateNetworkRequest{Network: "ecash", NetworkId: "betanet"})
 			require.NoError(t, err)
 			for _, table := range []string{"processed_blocks", "op_returns"} {
 				var heights string
@@ -149,7 +152,7 @@ func TestUpdateNetworkKeepsCompletedMigrationRows(t *testing.T) {
 func TestUpdateNetworkReturnsMigrationStatusError(t *testing.T) {
 	handler := &migrationNetworkServer{
 		plan:        &orchpb.PlanECashSwitchResponse{FromId: "betanet", ToId: "betanet"},
-		statusError: connect.NewError(connect.CodeUnavailable, errors.New("The migration status is unavailable.")),
+		statusError: connect.NewError(connect.CodeUnavailable, "The migration status is unavailable."),
 	}
 	conf := config.Config{Datadir: t.TempDir(), OrchestratorAddr: newMigrationNetworkServer(t, handler)}
 	server := api_bitwindowd.New(nil, nil, nil, nil, nil, nil, conf, func(context.Context, config.Network, string, uint32) error {
@@ -157,7 +160,7 @@ func TestUpdateNetworkReturnsMigrationStatusError(t *testing.T) {
 		return nil
 	})
 
-	_, err := server.UpdateNetwork(t.Context(), connect.NewRequest(&pb.UpdateNetworkRequest{Network: "ecash", NetworkId: "betanet"}))
+	_, err := server.UpdateNetwork(t.Context(), &pb.UpdateNetworkRequest{Network: "ecash", NetworkId: "betanet"})
 	require.ErrorContains(t, err, "The migration status is unavailable.")
 	require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	var calls []string
diff --git a/bitwindow/server/api/connect_test.go b/bitwindow/server/api/connect_test.go
new file mode 100644
index 0000000000..8264906bcc
--- /dev/null
+++ b/bitwindow/server/api/connect_test.go
@@ -0,0 +1,210 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
+	"connectrpc.com/connect/v2/connectproto"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	notificationv1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/notification/v1"
+	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/notification/v1/notificationv1connect"
+	utilsv1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/utils/v1"
+	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/utils/v1/utilsv1connect"
+)
+
+type wireUtils struct {
+	utilsv1connect.UnimplementedUtilsServiceHandler
+	parse func(context.Context, *utilsv1.ParseBitcoinURIRequest) (*utilsv1.ParseBitcoinURIResponse, error)
+}
+
+func (s wireUtils) ParseBitcoinURI(ctx context.Context, req *utilsv1.ParseBitcoinURIRequest) (*utilsv1.ParseBitcoinURIResponse, error) {
+	return s.parse(ctx, req)
+}
+
+type wireNotification struct {
+	err error
+}
+
+func (s wireNotification) Watch(ctx context.Context, _ *emptypb.Empty, stream notificationv1connect.NotificationServiceWatchServerStream) error {
+	if err := setWireMetadata(ctx); err != nil {
+		return err
+	}
+	for _, txid := range []string{"first", "second"} {
+		if err := stream.Send(&notificationv1.WatchResponse{
+			Event: &notificationv1.WatchResponse_Transaction{
+				Transaction: &notificationv1.TransactionEvent{Txid: txid, AmountSats: 42},
+			},
+		}); err != nil {
+			return err
+		}
+	}
+	return s.err
+}
+
+func setWireMetadata(ctx context.Context) error {
+	info, ok := connect.CallInfoForServerContext(ctx)
+	if !ok {
+		return errors.New("the call info is absent")
+	}
+	info.ResponseHeader().Set("X-Test-Header", info.RequestHeader().Get("X-Test-Request"))
+	info.ResponseTrailer().Set("X-Test-Trailer", "complete")
+	return nil
+}
+
+func wireServer(t *testing.T, utils wireUtils, notification wireNotification) *httptest.Server {
+	t.Helper()
+	server := connect.NewServer(logInterceptor(), recoverInterceptor(), errorInterceptor())
+	utilsv1connect.RegisterUtilsServiceHandler(server, utils)
+	notificationv1connect.RegisterNotificationServiceHandler(server, notification)
+	mux := http.NewServeMux()
+	connecthttp.Mount(mux, server, connecthttp.WithReadMaxBytes(0))
+	httpServer := httptest.NewUnstartedServer(mux)
+	httpServer.EnableHTTP2 = true
+	httpServer.StartTLS()
+	t.Cleanup(httpServer.Close)
+	return httpServer
+}
+
+func TestV1ClientsUseV2API(t *testing.T) {
+	oldDetail, err := connectv1.NewErrorDetail(wrapperspb.String("v1 detail"))
+	require.NoError(t, err)
+	oldError := connectv1.NewError(connectv1.CodeFailedPrecondition, errors.New("the wallet is locked"))
+	oldError.AddDetail(oldDetail)
+	oldError.Meta()["X-Test-Error"] = []string{"first", "second"}
+
+	remoteDetail, err := connectproto.NewErrorDetail(wrapperspb.String("remote detail"))
+	require.NoError(t, err)
+	upstream := wireServer(t, wireUtils{
+		parse: func(context.Context, *utilsv1.ParseBitcoinURIRequest) (*utilsv1.ParseBitcoinURIResponse, error) {
+			return nil, connect.NewError(connect.CodeUnavailable, "the node is offline").WithDetail(remoteDetail)
+		},
+	}, wireNotification{})
+	remoteClient := utilsv1connect.NewUtilsServiceClient(connect.NewClient(
+		connecthttp.NewTransport(upstream.Client(), upstream.URL, connecthttp.WithReadMaxBytes(0)),
+	))
+	_, remoteErr := remoteClient.ParseBitcoinURI(t.Context(), &utilsv1.ParseBitcoinURIRequest{})
+	var remoteError *connect.Error
+	require.ErrorAs(t, remoteErr, &remoteError)
+	require.True(t, remoteError.IsRemote())
+
+	server := wireServer(t, wireUtils{
+		parse: func(ctx context.Context, req *utilsv1.ParseBitcoinURIRequest) (*utilsv1.ParseBitcoinURIResponse, error) {
+			if err := setWireMetadata(ctx); err != nil {
+				return nil, err
+			}
+			switch req.Uri {
+			case "v1":
+				return nil, fmt.Errorf("wallet call: %w", oldError)
+			case "local":
+				return nil, connect.NewError(connect.CodeInternal, "the wallet call failed").WithCause(oldError)
+			case "remote":
+				return nil, fmt.Errorf("node call: %w", remoteError)
+			case "bare":
+				return nil, errors.New("private wallet path")
+			case "panic":
+				panic("private panic value")
+			default:
+				return &utilsv1.ParseBitcoinURIResponse{Address: req.Uri, Amount: 1.25}, nil
+			}
+		},
+	}, wireNotification{err: oldError})
+
+	for _, protocol := range []struct {
+		name    string
+		options []connectv1.ClientOption
+	}{
+		{name: "Connect protobuf"},
+		{name: "Connect JSON", options: []connectv1.ClientOption{connectv1.WithProtoJSON()}},
+		{name: "gRPC", options: []connectv1.ClientOption{connectv1.WithGRPC()}},
+		{name: "gRPC-Web", options: []connectv1.ClientOption{connectv1.WithGRPCWeb()}},
+	} {
+		t.Run(protocol.name, func(t *testing.T) {
+			client := connectv1.NewClient[utilsv1.ParseBitcoinURIRequest, utilsv1.ParseBitcoinURIResponse](
+				server.Client(), server.URL+utilsv1connect.UtilsServiceParseBitcoinURIProcedure, protocol.options...,
+			)
+			t.Run("unary data and metadata", func(t *testing.T) {
+				req := connectv1.NewRequest(&utilsv1.ParseBitcoinURIRequest{Uri: "address"})
+				req.Header().Set("X-Test-Request", "unary request")
+				resp, err := client.CallUnary(t.Context(), req)
+				require.NoError(t, err)
+				require.Equal(t, "address", resp.Msg.Address)
+				require.Equal(t, 1.25, resp.Msg.Amount)
+				require.Equal(t, "unary request", resp.Header().Get("X-Test-Header"))
+				require.Equal(t, "complete", resp.Trailer().Get("X-Test-Trailer"))
+			})
+
+			for _, tt := range []struct {
+				name    string
+				code    connectv1.Code
+				message string
+				detail  string
+			}{
+				{name: "v1", code: connectv1.CodeFailedPrecondition, message: "the wallet is locked", detail: "v1 detail"},
+				{name: "local", code: connectv1.CodeInternal, message: "the wallet call failed"},
+				{name: "remote", code: connectv1.CodeUnavailable, message: "the node is offline", detail: "remote detail"},
+				{name: "bare", code: connectv1.CodeUnknown},
+				{name: "panic", code: connectv1.CodeInternal, message: "panic in " + utilsv1connect.UtilsServiceParseBitcoinURIProcedure},
+			} {
+				t.Run(tt.name, func(t *testing.T) {
+					req := connectv1.NewRequest(&utilsv1.ParseBitcoinURIRequest{Uri: tt.name})
+					_, err := client.CallUnary(t.Context(), req)
+					var rpcError *connectv1.Error
+					require.ErrorAs(t, err, &rpcError)
+					require.Equal(t, tt.code, rpcError.Code())
+					require.Equal(t, tt.message, rpcError.Message())
+					require.NotContains(t, err.Error(), "private")
+					if tt.detail == "" {
+						require.Empty(t, rpcError.Details())
+					} else {
+						require.Len(t, rpcError.Details(), 1)
+						detail, err := rpcError.Details()[0].Value()
+						require.NoError(t, err)
+						require.True(t, proto.Equal(wrapperspb.String(tt.detail), detail))
+					}
+					if tt.name == "v1" {
+						require.Equal(t, []string{"first", "second"}, rpcError.Meta().Values("X-Test-Error"))
+					}
+				})
+			}
+
+			t.Run("stream data then error", func(t *testing.T) {
+				client := connectv1.NewClient[emptypb.Empty, notificationv1.WatchResponse](
+					server.Client(), server.URL+notificationv1connect.NotificationServiceWatchProcedure, protocol.options...,
+				)
+				req := connectv1.NewRequest(&emptypb.Empty{})
+				req.Header().Set("X-Test-Request", "stream request")
+				stream, err := client.CallServerStream(t.Context(), req)
+				require.NoError(t, err)
+				t.Cleanup(func() { require.NoError(t, stream.Close()) })
+				var txids []string
+				for stream.Receive() {
+					txids = append(txids, stream.Msg().GetTransaction().GetTxid())
+					require.Equal(t, uint64(42), stream.Msg().GetTransaction().GetAmountSats())
+				}
+				require.Equal(t, []string{"first", "second"}, txids)
+				var rpcError *connectv1.Error
+				require.ErrorAs(t, stream.Err(), &rpcError)
+				require.Equal(t, oldError.Code(), rpcError.Code())
+				require.Equal(t, oldError.Message(), rpcError.Message())
+				require.Len(t, rpcError.Details(), 1)
+				detail, err := rpcError.Details()[0].Value()
+				require.NoError(t, err)
+				require.True(t, proto.Equal(wrapperspb.String("v1 detail"), detail))
+				require.Equal(t, "stream request", stream.ResponseHeader().Get("X-Test-Header"))
+				require.Equal(t, "complete", stream.ResponseTrailer().Get("X-Test-Trailer"))
+				require.Equal(t, []string{"first", "second"}, stream.ResponseTrailer().Values("X-Test-Error"))
+			})
+		})
+	}
+}
diff --git a/bitwindow/server/api/drivechain/drivechain.go b/bitwindow/server/api/drivechain/drivechain.go
index df0afc7cf6..e337faee9a 100644
--- a/bitwindow/server/api/drivechain/drivechain.go
+++ b/bitwindow/server/api/drivechain/drivechain.go
@@ -4,12 +4,11 @@ import (
 	"cmp"
 	"context"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"slices"
 	"sync"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/rs/zerolog"
 	"github.com/samber/lo"
@@ -90,21 +89,21 @@ func (s *Server) chainTip(ctx context.Context) (validatorrpc.ValidatorServiceCli
 		return nil, nil, fmt.Errorf("enforcer: %w", err)
 	}
 
-	chainTipResp, err := enforcer.GetChainTip(ctx, connect.NewRequest(&validatorpb.GetChainTipRequest{}))
+	chainTipResp, err := enforcer.GetChainTip(ctx, &validatorpb.GetChainTipRequest{})
 	if err != nil {
 		return nil, nil, fmt.Errorf("get chain tip: %w", err)
 	}
 
-	tip := chainTipResp.Msg.BlockHeaderInfo
+	tip := chainTipResp.BlockHeaderInfo
 	if tip.GetBlockHash().GetHex() == nil {
-		return nil, nil, connect.NewError(connect.CodeInternal, errors.New("chain tip missing block hash"))
+		return nil, nil, connect.NewError(connect.CodeInternal, "chain tip missing block hash")
 	}
 	return enforcer, tip, nil
 }
 
 // ListSidechainProposals implements drivechainv1connect.DrivechainServiceHandler.
 // Uses caching to avoid repeated enforcer calls.
-func (s *Server) ListSidechainProposals(ctx context.Context, c *connect.Request[pb.ListSidechainProposalsRequest]) (*connect.Response[pb.ListSidechainProposalsResponse], error) {
+func (s *Server) ListSidechainProposals(ctx context.Context, c *pb.ListSidechainProposalsRequest) (*pb.ListSidechainProposalsResponse, error) {
 	log := zerolog.Ctx(ctx)
 
 	enforcer, tip, err := s.chainTip(ctx)
@@ -120,20 +119,20 @@ func (s *Server) ListSidechainProposals(ctx context.Context, c *connect.Request[
 
 	if cache != nil && cache.lastBlockHash == currentBlockHash {
 		log.Debug().Msg("ListSidechainProposals: returning cached data")
-		return connect.NewResponse(&pb.ListSidechainProposalsResponse{
+		return &pb.ListSidechainProposalsResponse{
 			Proposals: cache.proposals,
-		}), nil
+		}, nil
 	}
 
 	// Cache miss - fetch fresh data
-	sidechainProposals, err := enforcer.GetSidechainProposals(ctx, connect.NewRequest(&validatorpb.GetSidechainProposalsRequest{}))
+	sidechainProposals, err := enforcer.GetSidechainProposals(ctx, &validatorpb.GetSidechainProposalsRequest{})
 	if err != nil {
 		err = fmt.Errorf("enforcer/validator: get sidechain proposals: %w", err)
 		return nil, err
 	}
 
-	proposals := make([]*pb.SidechainProposal, 0, len(sidechainProposals.Msg.SidechainProposals))
-	for _, proposal := range sidechainProposals.Msg.SidechainProposals {
+	proposals := make([]*pb.SidechainProposal, 0, len(sidechainProposals.SidechainProposals))
+	for _, proposal := range sidechainProposals.SidechainProposals {
 		data, err := hex.DecodeString(proposal.Description.Hex.Value)
 		if err != nil {
 			return nil, fmt.Errorf("decode description of sidechain proposal %d: %w", proposal.SidechainNumber.Value, err)
@@ -160,14 +159,14 @@ func (s *Server) ListSidechainProposals(ctx context.Context, c *connect.Request[
 		Int("count", len(proposals)).
 		Msg("ListSidechainProposals: fetched and cached")
 
-	return connect.NewResponse(&pb.ListSidechainProposalsResponse{
+	return &pb.ListSidechainProposalsResponse{
 		Proposals: proposals,
-	}), nil
+	}, nil
 }
 
 // ListSidechains implements drivechainv1connect.DrivechainServiceHandler.
 // Uses caching to avoid repeated enforcer calls for GetCtip on every sidechain.
-func (s *Server) ListSidechains(ctx context.Context, _ *connect.Request[pb.ListSidechainsRequest]) (*connect.Response[pb.ListSidechainsResponse], error) {
+func (s *Server) ListSidechains(ctx context.Context, _ *pb.ListSidechainsRequest) (*pb.ListSidechainsResponse, error) {
 	enforcer, tip, err := s.chainTip(ctx)
 	if err != nil {
 		return nil, err
@@ -180,20 +179,20 @@ func (s *Server) ListSidechains(ctx context.Context, _ *connect.Request[pb.ListS
 	s.sidechainsCacheMu.RUnlock()
 
 	if cache != nil && cache.lastBlockHash == currentBlockHash {
-		return connect.NewResponse(&pb.ListSidechainsResponse{
+		return &pb.ListSidechainsResponse{
 			Sidechains: cache.sidechains,
-		}), nil
+		}, nil
 	}
 
-	sidechains, err := enforcer.GetSidechains(ctx, connect.NewRequest(&validatorpb.GetSidechainsRequest{}))
+	sidechains, err := enforcer.GetSidechains(ctx, &validatorpb.GetSidechainsRequest{})
 	if err != nil {
 		err = fmt.Errorf("enforcer/validator: get sidechains: %w", err)
 		return nil, err
 	}
 
 	// Loop over all sidechains and get their chaintip if available
-	sidechainList := make([]*pb.ListSidechainsResponse_Sidechain, 0, len(sidechains.Msg.Sidechains))
-	for _, sidechain := range sidechains.Msg.Sidechains {
+	sidechainList := make([]*pb.ListSidechainsResponse_Sidechain, 0, len(sidechains.Sidechains))
+	for _, sidechain := range sidechains.Sidechains {
 		// The enforcer reports a nil declaration for descriptions that aren't a v0
 		// declaration, which is legal. Use nil-safe getters throughout.
 		declaration := sidechain.GetDeclaration().GetV0()
@@ -212,14 +211,14 @@ func (s *Server) ListSidechains(ctx context.Context, _ *connect.Request[pb.ListS
 
 		// A sidechain with no deposits has no ctip.
 		ctipResponse, err := enforcer.GetCtip(ctx,
-			connect.NewRequest(&validatorpb.GetCtipRequest{SidechainNumber: wrapperspb.UInt32(sc.Slot)}),
+			&validatorpb.GetCtipRequest{SidechainNumber: wrapperspb.UInt32(sc.Slot)},
 		)
 		switch {
 		case err != nil && connect.CodeOf(err) == connect.CodeNotFound:
 		case err != nil:
 			return nil, fmt.Errorf("get ctip of sidechain %d: %w", sc.Slot, err)
-		case ctipResponse.Msg.Ctip != nil:
-			ctip := ctipResponse.Msg.Ctip
+		case ctipResponse.Ctip != nil:
+			ctip := ctipResponse.Ctip
 			txidHash, err := chainhash.NewHashFromStr(ctip.GetTxid().GetHex().GetValue())
 			if err != nil {
 				return nil, fmt.Errorf("parse ctip txid of sidechain %d: %w", sc.Slot, err)
@@ -241,32 +240,32 @@ func (s *Server) ListSidechains(ctx context.Context, _ *connect.Request[pb.ListS
 	}
 	s.sidechainsCacheMu.Unlock()
 
-	return connect.NewResponse(&pb.ListSidechainsResponse{
+	return &pb.ListSidechainsResponse{
 		Sidechains: sidechainList,
-	}), nil
+	}, nil
 }
 
 // ProposeSidechain implements drivechainv1connect.DrivechainServiceHandler.
 func (s *Server) ProposeSidechain(
 	ctx context.Context,
-	c *connect.Request[pb.ProposeSidechainRequest],
-) (*connect.Response[pb.ProposeSidechainResponse], error) {
+	c *pb.ProposeSidechainRequest,
+) (*pb.ProposeSidechainResponse, error) {
 	// Validation
-	if c.Msg.Slot > 255 {
+	if c.Slot > 255 {
 		return nil, connect.NewError(connect.CodeInvalidArgument,
-			errors.New("slot must be 0-255"))
+			"slot must be 0-255")
 	}
-	if c.Msg.Title == "" {
+	if c.Title == "" {
 		return nil, connect.NewError(connect.CodeInvalidArgument,
-			errors.New("title required"))
+			"title required")
 	}
-	if c.Msg.Hashid1 != "" && len(c.Msg.Hashid1) != 64 {
+	if c.Hashid1 != "" && len(c.Hashid1) != 64 {
 		return nil, connect.NewError(connect.CodeInvalidArgument,
-			errors.New("hashid1 must be 64 hex chars (256 bits)"))
+			"hashid1 must be 64 hex chars (256 bits)")
 	}
-	if c.Msg.Hashid2 != "" && len(c.Msg.Hashid2) != 40 {
+	if c.Hashid2 != "" && len(c.Hashid2) != 40 {
 		return nil, connect.NewError(connect.CodeInvalidArgument,
-			errors.New("hashid2 must be 40 hex chars (160 bits)"))
+			"hashid2 must be 40 hex chars (160 bits)")
 	}
 
 	if err := s.walletEngine.RequireFullNode(ctx, "proposing a sidechain"); err != nil {
@@ -276,24 +275,24 @@ func (s *Server) ProposeSidechain(
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, connect.NewError(connect.CodeUnavailable,
-			fmt.Errorf("block producer unavailable: %w", err))
+			fmt.Sprintf("block producer unavailable: %s", err)).WithCause(err)
 	}
 
 	// Build SidechainDeclaration V0
 	declarationV0 := &validatorpb.SidechainDeclaration_V0{
-		Title:       wrapperspb.String(c.Msg.Title),
-		Description: wrapperspb.String(c.Msg.Description),
+		Title:       wrapperspb.String(c.Title),
+		Description: wrapperspb.String(c.Description),
 	}
 
 	// Add hash IDs if provided
-	if c.Msg.Hashid1 != "" {
+	if c.Hashid1 != "" {
 		declarationV0.HashId_1 = &commonpb.ConsensusHex{
-			Hex: wrapperspb.String(c.Msg.Hashid1),
+			Hex: wrapperspb.String(c.Hashid1),
 		}
 	}
-	if c.Msg.Hashid2 != "" {
+	if c.Hashid2 != "" {
 		declarationV0.HashId_2 = &commonpb.Hex{
-			Hex: wrapperspb.String(c.Msg.Hashid2),
+			Hex: wrapperspb.String(c.Hashid2),
 		}
 	}
 
@@ -303,29 +302,29 @@ func (s *Server) ProposeSidechain(
 		},
 	}
 
-	_, err = producer.SubmitSidechainProposal(ctx, connect.NewRequest(&validatorpb.SubmitSidechainProposalRequest{
-		SidechainId: wrapperspb.UInt32(c.Msg.Slot),
+	_, err = producer.SubmitSidechainProposal(ctx, &validatorpb.SubmitSidechainProposalRequest{
+		SidechainId: wrapperspb.UInt32(c.Slot),
 		Declaration: declaration,
-	}))
+	})
 	if err != nil {
 		return nil, fmt.Errorf("propose sidechain: %w", err)
 	}
 
-	return connect.NewResponse(&pb.ProposeSidechainResponse{
+	return &pb.ProposeSidechainResponse{
 		Success: true,
-		Message: fmt.Sprintf("Sidechain %d proposal saved. It goes into the chain only when this node mines a block.", c.Msg.Slot),
-	}), nil
+		Message: fmt.Sprintf("Sidechain %d proposal saved. It goes into the chain only when this node mines a block.", c.Slot),
+	}, nil
 }
 
 // ListWithdrawals implements drivechainv1connect.DrivechainServiceHandler.
 // Uses caching to avoid re-scanning the entire blockchain on every call.
 func (s *Server) ListWithdrawals(
 	ctx context.Context,
-	c *connect.Request[pb.ListWithdrawalsRequest],
-) (*connect.Response[pb.ListWithdrawalsResponse], error) {
+	c *pb.ListWithdrawalsRequest,
+) (*pb.ListWithdrawalsResponse, error) {
 	log := zerolog.Ctx(ctx)
 
-	sidechainID := c.Msg.SidechainId
+	sidechainID := c.SidechainId
 
 	enforcer, tip, err := s.chainTip(ctx)
 	if err != nil {
@@ -345,32 +344,32 @@ func (s *Server) ListWithdrawals(
 			Uint32("sidechain", sidechainID).
 			Uint32("height", currentHeight).
 			Msg("ListWithdrawals: returning cached data")
-		return connect.NewResponse(&pb.ListWithdrawalsResponse{
+		return &pb.ListWithdrawalsResponse{
 			Bundles: s.updateBundleAges(cache.bundles, currentHeight),
-		}), nil
+		}, nil
 	}
 
 	// Get sidechains to find activation height
-	sidechainsResp, err := enforcer.GetSidechains(ctx, connect.NewRequest(&validatorpb.GetSidechainsRequest{}))
+	sidechainsResp, err := enforcer.GetSidechains(ctx, &validatorpb.GetSidechainsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("get sidechains: %w", err)
 	}
 
 	// Find the sidechain we're looking for
-	sidechain, found := lo.Find(sidechainsResp.Msg.Sidechains, func(sc *validatorpb.GetSidechainsResponse_SidechainInfo) bool {
+	sidechain, found := lo.Find(sidechainsResp.Sidechains, func(sc *validatorpb.GetSidechainsResponse_SidechainInfo) bool {
 		return sc.SidechainNumber != nil && sc.SidechainNumber.Value == sidechainID
 	})
 
 	if !found || sidechain.ActivationHeight == nil {
-		return nil, connect.NewError(connect.CodeNotFound,
-			fmt.Errorf("sidechain %d not found", sidechainID))
+		return nil, connect.Errorf(connect.CodeNotFound,
+			"sidechain %d not found", sidechainID)
 	}
 
 	activationHeight := sidechain.ActivationHeight.Value
 
 	if currentHeight < activationHeight {
-		return nil, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("activation height %d is greater than current height %d", activationHeight, currentHeight))
+		return nil, connect.Errorf(connect.CodeInternal,
+			"activation height %d is greater than current height %d", activationHeight, currentHeight)
 	}
 
 	// Determine start block for fetching
@@ -381,14 +380,14 @@ func (s *Server) ListWithdrawals(
 	if cache != nil && cache.activationHeight == activationHeight &&
 		cache.lastBlockHeight > 0 && cache.lastBlockHeight <= currentHeight {
 		ancestors := currentHeight - cache.lastBlockHeight
-		headersResp, err := enforcer.GetBlockHeaderInfo(ctx, connect.NewRequest(&validatorpb.GetBlockHeaderInfoRequest{
+		headersResp, err := enforcer.GetBlockHeaderInfo(ctx, &validatorpb.GetBlockHeaderInfoRequest{
 			BlockHash:    tip.BlockHash,
 			MaxAncestors: &ancestors,
-		}))
+		})
 		if err != nil {
 			return nil, fmt.Errorf("get cached block header: %w", err)
 		}
-		reuseCache = cacheOnChain(cache, headersResp.Msg.HeaderInfos)
+		reuseCache = cacheOnChain(cache, headersResp.HeaderInfos)
 		if !reuseCache {
 			log.Info().
 				Uint32("sidechain", sidechainID).
@@ -413,21 +412,21 @@ func (s *Server) ListWithdrawals(
 		// No cache or activation height changed - need full fetch from activation
 		// Get the activation block hash
 		ancestorsNeeded := currentHeight - activationHeight
-		activationBlockResp, err := enforcer.GetBlockHeaderInfo(ctx, connect.NewRequest(&validatorpb.GetBlockHeaderInfoRequest{
+		activationBlockResp, err := enforcer.GetBlockHeaderInfo(ctx, &validatorpb.GetBlockHeaderInfoRequest{
 			BlockHash:    tip.BlockHash,
 			MaxAncestors: &ancestorsNeeded,
-		}))
+		})
 		if err != nil {
 			return nil, fmt.Errorf("get activation block header: %w", err)
 		}
 
-		activationBlock, found := lo.Find(activationBlockResp.Msg.HeaderInfos, func(headerInfo *validatorpb.BlockHeaderInfo) bool {
+		activationBlock, found := lo.Find(activationBlockResp.HeaderInfos, func(headerInfo *validatorpb.BlockHeaderInfo) bool {
 			return headerInfo.Height == activationHeight
 		})
 
 		if !found || activationBlock.BlockHash == nil || activationBlock.BlockHash.Hex == nil {
-			return nil, connect.NewError(connect.CodeInternal,
-				fmt.Errorf("no block at activation height %d", activationHeight))
+			return nil, connect.Errorf(connect.CodeInternal,
+				"no block at activation height %d", activationHeight)
 		}
 
 		startBlockHash = activationBlock.BlockHash.Hex.Value
@@ -440,17 +439,17 @@ func (s *Server) ListWithdrawals(
 	}
 
 	// Fetch peg data from start to current tip
-	pegData, err := enforcer.GetTwoWayPegData(ctx, connect.NewRequest(&validatorpb.GetTwoWayPegDataRequest{
+	pegData, err := enforcer.GetTwoWayPegData(ctx, &validatorpb.GetTwoWayPegDataRequest{
 		SidechainId:    wrapperspb.UInt32(sidechainID),
 		StartBlockHash: &commonpb.ReverseHex{Hex: wrapperspb.String(startBlockHash)},
 		EndBlockHash:   &commonpb.ReverseHex{Hex: wrapperspb.String(currentBlockHash)},
-	}))
+	})
 	if err != nil {
 		return nil, fmt.Errorf("get two-way peg data: %w", err)
 	}
 
 	// Process new blocks and extract withdrawal bundle events
-	newBundles := s.processPegDataBlocks(pegData.Msg.Blocks, sidechainID)
+	newBundles := s.processPegDataBlocks(pegData.Blocks, sidechainID)
 
 	// Merge existing and new bundles
 	allBundles := s.mergeBundles(existingBundles, newBundles)
@@ -465,9 +464,9 @@ func (s *Server) ListWithdrawals(
 	}
 	s.withdrawalCacheMu.Unlock()
 
-	return connect.NewResponse(&pb.ListWithdrawalsResponse{
+	return &pb.ListWithdrawalsResponse{
 		Bundles: s.updateBundleAges(allBundles, currentHeight),
-	}), nil
+	}, nil
 }
 
 // cacheOnChain reports whether the cached block is in headers, the ancestors
@@ -597,7 +596,7 @@ func (s *Server) updateBundleAges(bundles []*pb.WithdrawalBundle, currentHeight
 // ListRecentActions implements drivechainv1connect.DrivechainServiceHandler.
 func (s *Server) ListRecentActions(
 	ctx context.Context,
-	_ *connect.Request[pb.ListRecentActionsRequest],
-) (*connect.Response[pb.ListRecentActionsResponse], error) {
-	return connect.NewResponse(&pb.ListRecentActionsResponse{}), nil
+	_ *pb.ListRecentActionsRequest,
+) (*pb.ListRecentActionsResponse, error) {
+	return &pb.ListRecentActionsResponse{}, nil
 }
diff --git a/bitwindow/server/api/drivechain/drivechain_test.go b/bitwindow/server/api/drivechain/drivechain_test.go
index a84d3e8c93..f1351248cc 100644
--- a/bitwindow/server/api/drivechain/drivechain_test.go
+++ b/bitwindow/server/api/drivechain/drivechain_test.go
@@ -2,10 +2,9 @@ package drivechain_test
 
 import (
 	"context"
-	"errors"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
@@ -35,13 +34,11 @@ func TestService_ListSidechains(t *testing.T) {
 		// Mock GetChainTip
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
@@ -49,32 +46,30 @@ func TestService_ListSidechains(t *testing.T) {
 		// Mock GetSidechains
 		mockValidator.EXPECT().
 			GetSidechains(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainsResponse]{
-				Msg: &mainchainv1.GetSidechainsResponse{
-					Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
-						{
-							SidechainNumber: wrapperspb.UInt32(0),
-							Declaration: &mainchainv1.SidechainDeclaration{
-								SidechainDeclaration: &mainchainv1.SidechainDeclaration_V0_{
-									V0: &mainchainv1.SidechainDeclaration_V0{
-										Title:       wrapperspb.String("Test Sidechain"),
-										Description: wrapperspb.String("A test sidechain"),
-										HashId_1: &commonv1.ConsensusHex{
-											Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000000"),
-										},
-										HashId_2: &commonv1.Hex{
-											Hex: wrapperspb.String("0000000000000000000000000000000000000000"),
-										},
+			Return(&mainchainv1.GetSidechainsResponse{
+				Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
+					{
+						SidechainNumber: wrapperspb.UInt32(0),
+						Declaration: &mainchainv1.SidechainDeclaration{
+							SidechainDeclaration: &mainchainv1.SidechainDeclaration_V0_{
+								V0: &mainchainv1.SidechainDeclaration_V0{
+									Title:       wrapperspb.String("Test Sidechain"),
+									Description: wrapperspb.String("A test sidechain"),
+									HashId_1: &commonv1.ConsensusHex{
+										Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000000"),
+									},
+									HashId_2: &commonv1.Hex{
+										Hex: wrapperspb.String("0000000000000000000000000000000000000000"),
 									},
 								},
 							},
-							Description: &commonv1.ConsensusHex{
-								Hex: wrapperspb.String("deadbeef"),
-							},
-							VoteCount:        wrapperspb.UInt32(100),
-							ProposalHeight:   wrapperspb.UInt32(50),
-							ActivationHeight: wrapperspb.UInt32(60),
 						},
+						Description: &commonv1.ConsensusHex{
+							Hex: wrapperspb.String("deadbeef"),
+						},
+						VoteCount:        wrapperspb.UInt32(100),
+						ProposalHeight:   wrapperspb.UInt32(50),
+						ActivationHeight: wrapperspb.UInt32(60),
 					},
 				},
 			}, nil)
@@ -82,26 +77,24 @@ func TestService_ListSidechains(t *testing.T) {
 		// Mock GetCtip for sidechain 0
 		mockValidator.EXPECT().
 			GetCtip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetCtipResponse]{
-				Msg: &mainchainv1.GetCtipResponse{
-					Ctip: &mainchainv1.GetCtipResponse_Ctip{
-						Txid: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
-						},
-						Vout:           0,
-						Value:          1000000,
-						SequenceNumber: 1,
+			Return(&mainchainv1.GetCtipResponse{
+				Ctip: &mainchainv1.GetCtipResponse_Ctip{
+					Txid: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
 					},
+					Vout:           0,
+					Value:          1000000,
+					SequenceNumber: 1,
 				},
 			}, nil)
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		resp, err := cli.ListSidechains(t.Context(), connect.NewRequest(&pb.ListSidechainsRequest{}))
+		resp, err := cli.ListSidechains(t.Context(), &pb.ListSidechainsRequest{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Sidechains, 1)
-		assert.Equal(t, "Test Sidechain", resp.Msg.Sidechains[0].Title)
-		assert.Equal(t, uint32(0), resp.Msg.Sidechains[0].Slot)
+		require.Len(t, resp.Sidechains, 1)
+		assert.Equal(t, "Test Sidechain", resp.Sidechains[0].Title)
+		assert.Equal(t, uint32(0), resp.Sidechains[0].Slot)
 	})
 
 	t.Run("handles nil declaration", func(t *testing.T) {
@@ -114,13 +107,11 @@ func TestService_ListSidechains(t *testing.T) {
 
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
@@ -129,35 +120,33 @@ func TestService_ListSidechains(t *testing.T) {
 		// decode as a v0 declaration, which the spec allows.
 		mockValidator.EXPECT().
 			GetSidechains(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainsResponse]{
-				Msg: &mainchainv1.GetSidechainsResponse{
-					Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
-						{
-							SidechainNumber: wrapperspb.UInt32(7),
-							Declaration:     nil,
-							Description: &commonv1.ConsensusHex{
-								Hex: wrapperspb.String("deadbeef"),
-							},
-							VoteCount:        wrapperspb.UInt32(100),
-							ProposalHeight:   wrapperspb.UInt32(50),
-							ActivationHeight: wrapperspb.UInt32(60),
+			Return(&mainchainv1.GetSidechainsResponse{
+				Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
+					{
+						SidechainNumber: wrapperspb.UInt32(7),
+						Declaration:     nil,
+						Description: &commonv1.ConsensusHex{
+							Hex: wrapperspb.String("deadbeef"),
 						},
+						VoteCount:        wrapperspb.UInt32(100),
+						ProposalHeight:   wrapperspb.UInt32(50),
+						ActivationHeight: wrapperspb.UInt32(60),
 					},
 				},
 			}, nil)
 
 		mockValidator.EXPECT().
 			GetCtip(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeNotFound, nil))
+			Return(nil, connect.NewError(connect.CodeNotFound, ""))
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		resp, err := cli.ListSidechains(t.Context(), connect.NewRequest(&pb.ListSidechainsRequest{}))
+		resp, err := cli.ListSidechains(t.Context(), &pb.ListSidechainsRequest{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Sidechains, 1)
-		assert.Empty(t, resp.Msg.Sidechains[0].Title)
-		assert.Equal(t, uint32(7), resp.Msg.Sidechains[0].Slot)
-		assert.Equal(t, "deadbeef", resp.Msg.Sidechains[0].DescriptionHex)
+		require.Len(t, resp.Sidechains, 1)
+		assert.Empty(t, resp.Sidechains[0].Title)
+		assert.Equal(t, uint32(7), resp.Sidechains[0].Slot)
+		assert.Equal(t, "deadbeef", resp.Sidechains[0].DescriptionHex)
 	})
 
 	t.Run("handles empty sidechains", func(t *testing.T) {
@@ -170,30 +159,26 @@ func TestService_ListSidechains(t *testing.T) {
 
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
 
 		mockValidator.EXPECT().
 			GetSidechains(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainsResponse]{
-				Msg: &mainchainv1.GetSidechainsResponse{
-					Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{},
-				},
+			Return(&mainchainv1.GetSidechainsResponse{
+				Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{},
 			}, nil)
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		resp, err := cli.ListSidechains(t.Context(), connect.NewRequest(&pb.ListSidechainsRequest{}))
+		resp, err := cli.ListSidechains(t.Context(), &pb.ListSidechainsRequest{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Sidechains)
+		assert.Empty(t, resp.Sidechains)
 	})
 
 	t.Run("a failed ctip read returns the error", func(t *testing.T) {
@@ -202,32 +187,28 @@ func TestService_ListSidechains(t *testing.T) {
 		mockValidator := mocks.NewMockValidatorServiceClient(gomock.NewController(t))
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
 		mockValidator.EXPECT().
 			GetSidechains(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainsResponse]{
-				Msg: &mainchainv1.GetSidechainsResponse{
-					Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
-						{SidechainNumber: wrapperspb.UInt32(2)},
-					},
+			Return(&mainchainv1.GetSidechainsResponse{
+				Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
+					{SidechainNumber: wrapperspb.UInt32(2)},
 				},
 			}, nil)
 		mockValidator.EXPECT().
 			GetCtip(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, errors.New("enforcer went away")))
+			Return(nil, connect.NewError(connect.CodeUnavailable, "enforcer went away"))
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, database.Test(t), apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, database.Test(t), apitests.WithValidator(mockValidator)))
 
-		_, err := cli.ListSidechains(t.Context(), connect.NewRequest(&pb.ListSidechainsRequest{}))
+		_, err := cli.ListSidechains(t.Context(), &pb.ListSidechainsRequest{})
 		require.ErrorContains(t, err, "enforcer went away")
 		require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	})
@@ -242,11 +223,11 @@ func TestService_ListSidechains(t *testing.T) {
 
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, nil))
+			Return(nil, connect.NewError(connect.CodeUnavailable, ""))
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		_, err := cli.ListSidechains(t.Context(), connect.NewRequest(&pb.ListSidechainsRequest{}))
+		_, err := cli.ListSidechains(t.Context(), &pb.ListSidechainsRequest{})
 		require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	})
 }
@@ -264,46 +245,42 @@ func TestService_ListSidechainProposals(t *testing.T) {
 
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
 
 		mockValidator.EXPECT().
 			GetSidechainProposals(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainProposalsResponse]{
-				Msg: &mainchainv1.GetSidechainProposalsResponse{
-					SidechainProposals: []*mainchainv1.GetSidechainProposalsResponse_SidechainProposal{
-						{
-							SidechainNumber: wrapperspb.UInt32(5),
-							Description: &commonv1.ConsensusHex{
-								Hex: wrapperspb.String("deadbeef"),
-							},
-							DescriptionSha256DHash: &commonv1.ReverseHex{
-								Hex: wrapperspb.String("abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234"),
-							},
-							VoteCount:      wrapperspb.UInt32(50),
-							ProposalHeight: wrapperspb.UInt32(80),
-							ProposalAge:    wrapperspb.UInt32(20),
+			Return(&mainchainv1.GetSidechainProposalsResponse{
+				SidechainProposals: []*mainchainv1.GetSidechainProposalsResponse_SidechainProposal{
+					{
+						SidechainNumber: wrapperspb.UInt32(5),
+						Description: &commonv1.ConsensusHex{
+							Hex: wrapperspb.String("deadbeef"),
+						},
+						DescriptionSha256DHash: &commonv1.ReverseHex{
+							Hex: wrapperspb.String("abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234"),
 						},
+						VoteCount:      wrapperspb.UInt32(50),
+						ProposalHeight: wrapperspb.UInt32(80),
+						ProposalAge:    wrapperspb.UInt32(20),
 					},
 				},
 			}, nil)
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		resp, err := cli.ListSidechainProposals(t.Context(), connect.NewRequest(&pb.ListSidechainProposalsRequest{}))
+		resp, err := cli.ListSidechainProposals(t.Context(), &pb.ListSidechainProposalsRequest{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Proposals, 1)
-		assert.Equal(t, uint32(5), resp.Msg.Proposals[0].Slot)
-		assert.Equal(t, uint32(50), resp.Msg.Proposals[0].VoteCount)
-		assert.Equal(t, []byte{0xde, 0xad, 0xbe, 0xef}, resp.Msg.Proposals[0].Data)
+		require.Len(t, resp.Proposals, 1)
+		assert.Equal(t, uint32(5), resp.Proposals[0].Slot)
+		assert.Equal(t, uint32(50), resp.Proposals[0].VoteCount)
+		assert.Equal(t, []byte{0xde, 0xad, 0xbe, 0xef}, resp.Proposals[0].Data)
 	})
 
 	t.Run("handles empty proposals", func(t *testing.T) {
@@ -316,30 +293,26 @@ func TestService_ListSidechainProposals(t *testing.T) {
 
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
 
 		mockValidator.EXPECT().
 			GetSidechainProposals(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainProposalsResponse]{
-				Msg: &mainchainv1.GetSidechainProposalsResponse{
-					SidechainProposals: []*mainchainv1.GetSidechainProposalsResponse_SidechainProposal{},
-				},
+			Return(&mainchainv1.GetSidechainProposalsResponse{
+				SidechainProposals: []*mainchainv1.GetSidechainProposalsResponse_SidechainProposal{},
 			}, nil)
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		resp, err := cli.ListSidechainProposals(t.Context(), connect.NewRequest(&pb.ListSidechainProposalsRequest{}))
+		resp, err := cli.ListSidechainProposals(t.Context(), &pb.ListSidechainProposalsRequest{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Proposals)
+		assert.Empty(t, resp.Proposals)
 	})
 }
 
@@ -350,12 +323,12 @@ func TestService_ProposeSidechain(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db))
 
-		_, err := cli.ProposeSidechain(t.Context(), connect.NewRequest(&pb.ProposeSidechainRequest{
+		_, err := cli.ProposeSidechain(t.Context(), &pb.ProposeSidechainRequest{
 			Slot:  256, // invalid, must be 0-255
 			Title: "Test",
-		}))
+		})
 		require.ErrorContains(t, err, "slot must be 0-255")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -364,12 +337,12 @@ func TestService_ProposeSidechain(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db))
 
-		_, err := cli.ProposeSidechain(t.Context(), connect.NewRequest(&pb.ProposeSidechainRequest{
+		_, err := cli.ProposeSidechain(t.Context(), &pb.ProposeSidechainRequest{
 			Slot:  0,
 			Title: "", // empty title
-		}))
+		})
 		require.ErrorContains(t, err, "title required")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -378,13 +351,13 @@ func TestService_ProposeSidechain(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db))
 
-		_, err := cli.ProposeSidechain(t.Context(), connect.NewRequest(&pb.ProposeSidechainRequest{
+		_, err := cli.ProposeSidechain(t.Context(), &pb.ProposeSidechainRequest{
 			Slot:    0,
 			Title:   "Test",
 			Hashid1: "tooshort", // must be 64 hex chars
-		}))
+		})
 		require.ErrorContains(t, err, "hashid1 must be 64 hex chars")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -393,28 +366,28 @@ func TestService_ProposeSidechain(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db))
 
-		_, err := cli.ProposeSidechain(t.Context(), connect.NewRequest(&pb.ProposeSidechainRequest{
+		_, err := cli.ProposeSidechain(t.Context(), &pb.ProposeSidechainRequest{
 			Slot:    0,
 			Title:   "Test",
 			Hashid2: "tooshort", // must be 40 hex chars
-		}))
+		})
 		require.ErrorContains(t, err, "hashid2 must be 40 hex chars")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 
-	proposeWith := func(t *testing.T, producer *fakeProducer) (*connect.Response[pb.ProposeSidechainResponse], error) {
+	proposeWith := func(t *testing.T, producer *fakeProducer) (*pb.ProposeSidechainResponse, error) {
 		orchestrator := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 		apitests.ExpectOrchestratorReads(orchestrator)
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, database.Test(t),
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, database.Test(t),
 			apitests.WithOrchestrator(orchestrator),
 			apitests.WithBlockProducer(producer),
 		))
-		return cli.ProposeSidechain(t.Context(), connect.NewRequest(&pb.ProposeSidechainRequest{
+		return cli.ProposeSidechain(t.Context(), &pb.ProposeSidechainRequest{
 			Slot:  3,
 			Title: "RISCy",
-		}))
+		})
 	}
 
 	t.Run("submits the proposal", func(t *testing.T) {
@@ -423,7 +396,7 @@ func TestService_ProposeSidechain(t *testing.T) {
 		producer := &fakeProducer{}
 		resp, err := proposeWith(t, producer)
 		require.NoError(t, err)
-		assert.True(t, resp.Msg.Success)
+		assert.True(t, resp.Success)
 		require.NotNil(t, producer.submitted)
 		assert.Equal(t, uint32(3), producer.submitted.GetSidechainId().GetValue())
 		assert.Equal(t, "RISCy", producer.submitted.GetDeclaration().GetV0().GetTitle().GetValue())
@@ -432,7 +405,7 @@ func TestService_ProposeSidechain(t *testing.T) {
 	t.Run("reports an enforcer refusal", func(t *testing.T) {
 		t.Parallel()
 
-		producer := &fakeProducer{err: connect.NewError(connect.CodeAlreadyExists, errors.New("Sidechain proposal already exists"))}
+		producer := &fakeProducer{err: connect.NewError(connect.CodeAlreadyExists, "Sidechain proposal already exists")}
 		_, err := proposeWith(t, producer)
 		require.ErrorContains(t, err, "Sidechain proposal already exists")
 		assert.Equal(t, connect.CodeAlreadyExists, connect.CodeOf(err))
@@ -445,12 +418,12 @@ type fakeProducer struct {
 	submitted *mainchainv1.SubmitSidechainProposalRequest
 }
 
-func (f *fakeProducer) SubmitSidechainProposal(_ context.Context, req *connect.Request[mainchainv1.SubmitSidechainProposalRequest]) (*connect.Response[mainchainv1.SubmitSidechainProposalResponse], error) {
-	f.submitted = req.Msg
+func (f *fakeProducer) SubmitSidechainProposal(_ context.Context, req *mainchainv1.SubmitSidechainProposalRequest) (*mainchainv1.SubmitSidechainProposalResponse, error) {
+	f.submitted = req
 	if f.err != nil {
 		return nil, f.err
 	}
-	return connect.NewResponse(&mainchainv1.SubmitSidechainProposalResponse{}), nil
+	return &mainchainv1.SubmitSidechainProposalResponse{}, nil
 }
 
 func TestService_ListWithdrawals(t *testing.T) {
@@ -466,30 +439,26 @@ func TestService_ListWithdrawals(t *testing.T) {
 
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
 
 		mockValidator.EXPECT().
 			GetSidechains(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainsResponse]{
-				Msg: &mainchainv1.GetSidechainsResponse{
-					Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{},
-				},
+			Return(&mainchainv1.GetSidechainsResponse{
+				Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{},
 			}, nil)
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		_, err := cli.ListWithdrawals(t.Context(), connect.NewRequest(&pb.ListWithdrawalsRequest{
+		_, err := cli.ListWithdrawals(t.Context(), &pb.ListWithdrawalsRequest{
 			SidechainId: 99, // non-existent
-		}))
+		})
 		require.ErrorContains(t, err, "sidechain 99 not found")
 		assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
@@ -500,14 +469,14 @@ func TestService_ListWithdrawals(t *testing.T) {
 		mockValidator := mocks.NewMockValidatorServiceClient(gomock.NewController(t))
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&mainchainv1.GetChainTipResponse{BlockHeaderInfo: header(100, activationHash)}), nil)
+			Return(&mainchainv1.GetChainTipResponse{BlockHeaderInfo: header(100, activationHash)}, nil)
 		mockValidator.EXPECT().
 			GetSidechains(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, errors.New("enforcer went away")))
+			Return(nil, connect.NewError(connect.CodeUnavailable, "enforcer went away"))
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, database.Test(t), apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, database.Test(t), apitests.WithValidator(mockValidator)))
 
-		_, err := cli.ListWithdrawals(t.Context(), connect.NewRequest(&pb.ListWithdrawalsRequest{SidechainId: 0}))
+		_, err := cli.ListWithdrawals(t.Context(), &pb.ListWithdrawalsRequest{SidechainId: 0})
 		require.ErrorContains(t, err, "enforcer went away")
 		assert.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	})
@@ -522,30 +491,26 @@ func TestService_ListWithdrawals(t *testing.T) {
 
 		mockValidator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainTipResponse]{
-				Msg: &mainchainv1.GetChainTipResponse{
-					BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
-						Height: 100,
-						BlockHash: &commonv1.ReverseHex{
-							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
-						},
+			Return(&mainchainv1.GetChainTipResponse{
+				BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{
+					Height: 100,
+					BlockHash: &commonv1.ReverseHex{
+						Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000001"),
 					},
 				},
 			}, nil)
 
 		mockValidator.EXPECT().
 			GetSidechains(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetSidechainsResponse]{
-				Msg: &mainchainv1.GetSidechainsResponse{
-					Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
-						{
-							SidechainNumber:  wrapperspb.UInt32(0),
-							ActivationHeight: wrapperspb.UInt32(50),
-							Declaration: &mainchainv1.SidechainDeclaration{
-								SidechainDeclaration: &mainchainv1.SidechainDeclaration_V0_{
-									V0: &mainchainv1.SidechainDeclaration_V0{
-										Title: wrapperspb.String("Test"),
-									},
+			Return(&mainchainv1.GetSidechainsResponse{
+				Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{
+					{
+						SidechainNumber:  wrapperspb.UInt32(0),
+						ActivationHeight: wrapperspb.UInt32(50),
+						Declaration: &mainchainv1.SidechainDeclaration{
+							SidechainDeclaration: &mainchainv1.SidechainDeclaration_V0_{
+								V0: &mainchainv1.SidechainDeclaration_V0{
+									Title: wrapperspb.String("Test"),
 								},
 							},
 						},
@@ -556,14 +521,12 @@ func TestService_ListWithdrawals(t *testing.T) {
 		// Mock GetBlockHeaderInfo for activation block lookup
 		mockValidator.EXPECT().
 			GetBlockHeaderInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetBlockHeaderInfoResponse]{
-				Msg: &mainchainv1.GetBlockHeaderInfoResponse{
-					HeaderInfos: []*mainchainv1.BlockHeaderInfo{
-						{
-							Height: 50,
-							BlockHash: &commonv1.ReverseHex{
-								Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000050"),
-							},
+			Return(&mainchainv1.GetBlockHeaderInfoResponse{
+				HeaderInfos: []*mainchainv1.BlockHeaderInfo{
+					{
+						Height: 50,
+						BlockHash: &commonv1.ReverseHex{
+							Hex: wrapperspb.String("0000000000000000000000000000000000000000000000000000000000000050"),
 						},
 					},
 				},
@@ -572,19 +535,17 @@ func TestService_ListWithdrawals(t *testing.T) {
 		// Mock GetTwoWayPegData
 		mockValidator.EXPECT().
 			GetTwoWayPegData(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetTwoWayPegDataResponse]{
-				Msg: &mainchainv1.GetTwoWayPegDataResponse{
-					Blocks: []*mainchainv1.GetTwoWayPegDataResponse_ResponseItem{},
-				},
+			Return(&mainchainv1.GetTwoWayPegDataResponse{
+				Blocks: []*mainchainv1.GetTwoWayPegDataResponse_ResponseItem{},
 			}, nil)
 
-		cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+		cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 
-		resp, err := cli.ListWithdrawals(t.Context(), connect.NewRequest(&pb.ListWithdrawalsRequest{
+		resp, err := cli.ListWithdrawals(t.Context(), &pb.ListWithdrawalsRequest{
 			SidechainId: 0,
-		}))
+		})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Bundles)
+		assert.Empty(t, resp.Bundles)
 	})
 
 	t.Run("reads on from the cached block while it stays on the chain", func(t *testing.T) {
@@ -625,38 +586,38 @@ func listWithdrawalsTwice(t *testing.T, ancestorAt100 string) []string {
 
 	gomock.InOrder(
 		mockValidator.EXPECT().GetChainTip(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&mainchainv1.GetChainTipResponse{BlockHeaderInfo: header(100, firstTip)}), nil),
+			Return(&mainchainv1.GetChainTipResponse{BlockHeaderInfo: header(100, firstTip)}, nil),
 		mockValidator.EXPECT().GetChainTip(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&mainchainv1.GetChainTipResponse{BlockHeaderInfo: header(101, secondTip)}), nil),
+			Return(&mainchainv1.GetChainTipResponse{BlockHeaderInfo: header(101, secondTip)}, nil),
 	)
 
 	mockValidator.EXPECT().GetSidechains(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&mainchainv1.GetSidechainsResponse{
+		Return(&mainchainv1.GetSidechainsResponse{
 			Sidechains: []*mainchainv1.GetSidechainsResponse_SidechainInfo{{
 				SidechainNumber:  wrapperspb.UInt32(0),
 				ActivationHeight: wrapperspb.UInt32(50),
 			}},
-		}), nil).AnyTimes()
+		}, nil).AnyTimes()
 
 	mockValidator.EXPECT().GetBlockHeaderInfo(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(_ context.Context, req *connect.Request[mainchainv1.GetBlockHeaderInfoRequest]) (*connect.Response[mainchainv1.GetBlockHeaderInfoResponse], error) {
+		DoAndReturn(func(_ context.Context, req *mainchainv1.GetBlockHeaderInfoRequest) (*mainchainv1.GetBlockHeaderInfoResponse, error) {
 			headers := []*mainchainv1.BlockHeaderInfo{header(50, activationHash)}
-			if req.Msg.BlockHash.Hex.Value == secondTip {
+			if req.BlockHash.Hex.Value == secondTip {
 				headers = append(headers, header(101, secondTip), header(100, ancestorAt100))
 			}
-			return connect.NewResponse(&mainchainv1.GetBlockHeaderInfoResponse{HeaderInfos: headers}), nil
+			return &mainchainv1.GetBlockHeaderInfoResponse{HeaderInfos: headers}, nil
 		}).AnyTimes()
 
 	var starts []string
 	mockValidator.EXPECT().GetTwoWayPegData(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(_ context.Context, req *connect.Request[mainchainv1.GetTwoWayPegDataRequest]) (*connect.Response[mainchainv1.GetTwoWayPegDataResponse], error) {
-			starts = append(starts, req.Msg.StartBlockHash.Hex.Value)
-			return connect.NewResponse(&mainchainv1.GetTwoWayPegDataResponse{}), nil
+		DoAndReturn(func(_ context.Context, req *mainchainv1.GetTwoWayPegDataRequest) (*mainchainv1.GetTwoWayPegDataResponse, error) {
+			starts = append(starts, req.StartBlockHash.Hex.Value)
+			return &mainchainv1.GetTwoWayPegDataResponse{}, nil
 		}).Times(2)
 
-	cli := rpc.NewDrivechainServiceClient(apitests.API(t, db, apitests.WithValidator(mockValidator)))
+	cli := rpc.NewDrivechainServiceClient(apitests.RPC(t, db, apitests.WithValidator(mockValidator)))
 	for range 2 {
-		_, err := cli.ListWithdrawals(t.Context(), connect.NewRequest(&pb.ListWithdrawalsRequest{SidechainId: 0}))
+		_, err := cli.ListWithdrawals(t.Context(), &pb.ListWithdrawalsRequest{SidechainId: 0})
 		require.NoError(t, err)
 	}
 	return starts
diff --git a/bitwindow/server/api/drivechain/light_mode_test.go b/bitwindow/server/api/drivechain/light_mode_test.go
index 12d21b4f09..3d60d5f504 100644
--- a/bitwindow/server/api/drivechain/light_mode_test.go
+++ b/bitwindow/server/api/drivechain/light_mode_test.go
@@ -2,10 +2,9 @@ package drivechain
 
 import (
 	"context"
-	"errors"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
@@ -22,7 +21,7 @@ func TestLightModeReadsTheRemoteValidator(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	walletClient := mocks.NewMockWalletManagerServiceClient(ctrl)
 	walletClient.EXPECT().GetNodeMode(gomock.Any(), gomock.Any()).AnyTimes().Return(
-		connect.NewResponse(&walletpb.GetNodeModeResponse{Mode: walletpb.NodeMode_NODE_MODE_LIGHT}), nil,
+		&walletpb.GetNodeModeResponse{Mode: walletpb.NodeMode_NODE_MODE_LIGHT}, nil,
 	)
 	walletEngine := engines.NewWalletEngine(nil, walletClient, &chaincfg.RegressionNetParams, nil)
 	mode, err := walletEngine.NodeMode().Mode(t.Context())
@@ -31,17 +30,17 @@ func TestLightModeReadsTheRemoteValidator(t *testing.T) {
 
 	validator := mocks.NewMockValidatorServiceClient(ctrl)
 	validator.EXPECT().GetChainTip(gomock.Any(), gomock.Any()).Times(3).Return(
-		nil, connect.NewError(connect.CodeUnavailable, errors.New("remote validator is unavailable")),
+		nil, connect.NewError(connect.CodeUnavailable, "remote validator is unavailable"),
 	)
 	client := service.New("validator", func(context.Context) (enforcerrpc.ValidatorServiceClient, error) {
 		return validator, nil
 	})
 	server := New(client, nil, walletEngine, 10)
 
-	_, err = server.ListSidechains(t.Context(), connect.NewRequest(&pb.ListSidechainsRequest{}))
+	_, err = server.ListSidechains(t.Context(), &pb.ListSidechainsRequest{})
 	require.ErrorContains(t, err, "remote validator is unavailable")
-	_, err = server.ListSidechainProposals(t.Context(), connect.NewRequest(&pb.ListSidechainProposalsRequest{}))
+	_, err = server.ListSidechainProposals(t.Context(), &pb.ListSidechainProposalsRequest{})
 	require.ErrorContains(t, err, "remote validator is unavailable")
-	_, err = server.ListWithdrawals(t.Context(), connect.NewRequest(&pb.ListWithdrawalsRequest{SidechainId: 9}))
+	_, err = server.ListWithdrawals(t.Context(), &pb.ListWithdrawalsRequest{SidechainId: 9})
 	require.ErrorContains(t, err, "remote validator is unavailable")
 }
diff --git a/bitwindow/server/api/drivechain/list_proposals_test.go b/bitwindow/server/api/drivechain/list_proposals_test.go
index 0c839d250b..7e1eeaaeb0 100644
--- a/bitwindow/server/api/drivechain/list_proposals_test.go
+++ b/bitwindow/server/api/drivechain/list_proposals_test.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 
@@ -23,18 +22,18 @@ type fakeValidator struct {
 	proposalCalls int
 }
 
-func (f *fakeValidator) GetChainTip(context.Context, *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error) {
+func (f *fakeValidator) GetChainTip(context.Context, *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error) {
 	f.chainTipCalls++
-	return connect.NewResponse(&v1.GetChainTipResponse{
+	return &v1.GetChainTipResponse{
 		BlockHeaderInfo: &v1.BlockHeaderInfo{
 			BlockHash: &commonpb.ReverseHex{Hex: wrapperspb.String("deadbeef")},
 		},
-	}), nil
+	}, nil
 }
 
-func (f *fakeValidator) GetSidechainProposals(context.Context, *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error) {
+func (f *fakeValidator) GetSidechainProposals(context.Context, *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error) {
 	f.proposalCalls++
-	return connect.NewResponse(&v1.GetSidechainProposalsResponse{}), nil
+	return &v1.GetSidechainProposalsResponse{}, nil
 }
 
 func TestListSidechainProposalsReadsTheEnforcer(t *testing.T) {
@@ -45,10 +44,10 @@ func TestListSidechainProposalsReadsTheEnforcer(t *testing.T) {
 		}),
 	}
 
-	resp, err := s.ListSidechainProposals(t.Context(), connect.NewRequest(&pb.ListSidechainProposalsRequest{}))
+	resp, err := s.ListSidechainProposals(t.Context(), &pb.ListSidechainProposalsRequest{})
 	require.NoError(t, err)
 	require.NotNil(t, resp)
-	require.Empty(t, resp.Msg.Proposals)
+	require.Empty(t, resp.Proposals)
 	require.Equal(t, 1, fake.chainTipCalls)
 	require.Equal(t, 1, fake.proposalCalls)
 }
diff --git a/bitwindow/server/api/enforcer/enforcer.go b/bitwindow/server/api/enforcer/enforcer.go
index 868ebddd37..1dc1bfbafd 100644
--- a/bitwindow/server/api/enforcer/enforcer.go
+++ b/bitwindow/server/api/enforcer/enforcer.go
@@ -2,9 +2,11 @@ package enforcer
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"io"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 
 	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/engines"
@@ -46,42 +48,104 @@ type Server struct {
 	walletEngine  *engines.WalletEngine
 }
 
-// forwardStream sends each message of in to out until in ends.
-func forwardStream[Res any](ctx context.Context, name string, in *connect.ServerStreamForClient[Res], out *connect.ServerStream[Res]) error {
-	for in.Receive() {
-		if err := out.Send(in.Msg()); err != nil {
+func clientContext(ctx context.Context) (context.Context, *connect.CallInfo) {
+	callCtx, info := connect.NewClientContext(ctx)
+	if request, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range request.RequestHeader().All() {
+			info.RequestHeader().SetValues(key, values)
+		}
+	}
+	return callCtx, info
+}
+
+func copyResponseHeader(ctx context.Context, info *connect.CallInfo) {
+	if result, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range info.ResponseHeader().All() {
+			result.ResponseHeader().SetValues(key, values)
+		}
+	}
+}
+
+func copyResponseTrailer(ctx context.Context, info *connect.CallInfo) {
+	if result, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range info.ResponseTrailer().All() {
+			result.ResponseTrailer().SetValues(key, values)
+		}
+	}
+}
+
+func copyResponseMetadata(ctx context.Context, info *connect.CallInfo) {
+	copyResponseHeader(ctx, info)
+	copyResponseTrailer(ctx, info)
+}
+
+func proxyCall[Request, Response any](ctx context.Context, req *Request, call func(context.Context, *Request) (*Response, error)) (*Response, error) {
+	callCtx, info := clientContext(ctx)
+	response, err := call(callCtx, req)
+	copyResponseMetadata(ctx, info)
+	return response, err
+}
+
+type streamReader[Res any] interface {
+	Receive() (*Res, error)
+	Close() error
+}
+
+type streamWriter[Res any] interface {
+	Send(*Res) error
+}
+
+// forwardStream copies the upstream header before the first message and the trailer at the end.
+func forwardStream[Res any](ctx context.Context, name string, info *connect.CallInfo, in streamReader[Res], out streamWriter[Res]) (err error) {
+	defer func() {
+		err = errors.Join(err, in.Close())
+		copyResponseTrailer(ctx, info)
+	}()
+	for first := true; ; first = false {
+		msg, err := in.Receive()
+		if first {
+			copyResponseHeader(ctx, info)
+		}
+		if errors.Is(err, io.EOF) {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		if err := out.Send(msg); err != nil {
 			zerolog.Ctx(ctx).Error().Err(err).Str("stream", name).Msg("send stream message")
 			return fmt.Errorf("forward stream message: %w", err)
 		}
 	}
-	return in.Err()
 }
 
-// Stop implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) Stop(ctx context.Context, c *connect.Request[mainchainv1.StopRequest]) (*connect.Response[mainchainv1.StopResponse], error) {
+// Stop implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) Stop(ctx context.Context, c *mainchainv1.StopRequest) (*mainchainv1.StopResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.Stop(ctx, c)
+	return proxyCall(ctx, c, validator.Stop)
 }
 
-// SubscribeHeaderSyncProgress implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) SubscribeHeaderSyncProgress(ctx context.Context, c *connect.Request[mainchainv1.SubscribeHeaderSyncProgressRequest], stream *connect.ServerStream[mainchainv1.SubscribeHeaderSyncProgressResponse]) error {
+// SubscribeHeaderSyncProgress implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) SubscribeHeaderSyncProgress(ctx context.Context, c *mainchainv1.SubscribeHeaderSyncProgressRequest, stream validatorrpc.ValidatorServiceSubscribeHeaderSyncProgressServerStream) error {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return err
 	}
-	clientStream, err := validator.SubscribeHeaderSyncProgress(ctx, c)
+	callCtx, info := clientContext(ctx)
+	clientStream, err := validator.SubscribeHeaderSyncProgress(callCtx, c)
 	if err != nil {
+		copyResponseMetadata(ctx, info)
 		zerolog.Ctx(ctx).Error().Err(err).Msg("subscribe to header sync progress")
 		return err
 	}
-	return forwardStream(ctx, "header sync progress", clientStream, stream)
+	return forwardStream(ctx, "header sync progress", info, clientStream, stream)
 }
 
-// CreateSidechainProposal implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) CreateSidechainProposal(ctx context.Context, c *connect.Request[mainchainv1.CreateSidechainProposalRequest], stream *connect.ServerStream[mainchainv1.CreateSidechainProposalResponse]) error {
+// CreateSidechainProposal implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) CreateSidechainProposal(ctx context.Context, c *mainchainv1.CreateSidechainProposalRequest, stream validatorrpc.BlockProducerServiceCreateSidechainProposalServerStream) error {
 	if err := s.walletEngine.RequireFullNode(ctx, "creating a sidechain proposal"); err != nil {
 		return err
 	}
@@ -89,16 +153,18 @@ func (s *Server) CreateSidechainProposal(ctx context.Context, c *connect.Request
 	if err != nil {
 		return err
 	}
-	clientStream, err := producer.CreateSidechainProposal(ctx, c)
+	callCtx, info := clientContext(ctx)
+	clientStream, err := producer.CreateSidechainProposal(callCtx, c)
 	if err != nil {
+		copyResponseMetadata(ctx, info)
 		zerolog.Ctx(ctx).Error().Err(err).Msg("create sidechain proposal")
 		return err
 	}
-	return forwardStream(ctx, "sidechain proposal", clientStream, stream)
+	return forwardStream(ctx, "sidechain proposal", info, clientStream, stream)
 }
 
-// SubmitSidechainProposal implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) SubmitSidechainProposal(ctx context.Context, c *connect.Request[mainchainv1.SubmitSidechainProposalRequest]) (*connect.Response[mainchainv1.SubmitSidechainProposalResponse], error) {
+// SubmitSidechainProposal implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) SubmitSidechainProposal(ctx context.Context, c *mainchainv1.SubmitSidechainProposalRequest) (*mainchainv1.SubmitSidechainProposalResponse, error) {
 	if err := s.walletEngine.RequireFullNode(ctx, "submitting a sidechain proposal"); err != nil {
 		return nil, err
 	}
@@ -106,235 +172,237 @@ func (s *Server) SubmitSidechainProposal(ctx context.Context, c *connect.Request
 	if err != nil {
 		return nil, err
 	}
-	return producer.SubmitSidechainProposal(ctx, c)
+	return proxyCall(ctx, c, producer.SubmitSidechainProposal)
 }
 
-// GenerateToAddress implements mainchainv1connect.MiningServiceHandler.
-func (s *Server) GenerateToAddress(ctx context.Context, c *connect.Request[mainchainv1.GenerateToAddressRequest]) (*connect.Response[mainchainv1.GenerateToAddressResponse], error) {
+// GenerateToAddress implements validatorrpc.MiningServiceHandler.
+func (s *Server) GenerateToAddress(ctx context.Context, c *mainchainv1.GenerateToAddressRequest) (*mainchainv1.GenerateToAddressResponse, error) {
 	mining, err := s.mining.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return mining.GenerateToAddress(ctx, c)
+	return proxyCall(ctx, c, mining.GenerateToAddress)
 }
 
-// SetSidechainAck implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) SetSidechainAck(ctx context.Context, c *connect.Request[mainchainv1.SetSidechainAckRequest]) (*connect.Response[mainchainv1.SetSidechainAckResponse], error) {
+// SetSidechainAck implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) SetSidechainAck(ctx context.Context, c *mainchainv1.SetSidechainAckRequest) (*mainchainv1.SetSidechainAckResponse, error) {
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return producer.SetSidechainAck(ctx, c)
+	return proxyCall(ctx, c, producer.SetSidechainAck)
 }
 
-// SetAckAllProposals implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) SetAckAllProposals(ctx context.Context, c *connect.Request[mainchainv1.SetAckAllProposalsRequest]) (*connect.Response[mainchainv1.SetAckAllProposalsResponse], error) {
+// SetAckAllProposals implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) SetAckAllProposals(ctx context.Context, c *mainchainv1.SetAckAllProposalsRequest) (*mainchainv1.SetAckAllProposalsResponse, error) {
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return producer.SetAckAllProposals(ctx, c)
+	return proxyCall(ctx, c, producer.SetAckAllProposals)
 }
 
-// SetWithdrawalBundleAck implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) SetWithdrawalBundleAck(ctx context.Context, c *connect.Request[mainchainv1.SetWithdrawalBundleAckRequest]) (*connect.Response[mainchainv1.SetWithdrawalBundleAckResponse], error) {
+// SetWithdrawalBundleAck implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) SetWithdrawalBundleAck(ctx context.Context, c *mainchainv1.SetWithdrawalBundleAckRequest) (*mainchainv1.SetWithdrawalBundleAckResponse, error) {
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return producer.SetWithdrawalBundleAck(ctx, c)
+	return proxyCall(ctx, c, producer.SetWithdrawalBundleAck)
 }
 
-// SetWithdrawalBundlePolicy implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) SetWithdrawalBundlePolicy(ctx context.Context, c *connect.Request[mainchainv1.SetWithdrawalBundlePolicyRequest]) (*connect.Response[mainchainv1.SetWithdrawalBundlePolicyResponse], error) {
+// SetWithdrawalBundlePolicy implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) SetWithdrawalBundlePolicy(ctx context.Context, c *mainchainv1.SetWithdrawalBundlePolicyRequest) (*mainchainv1.SetWithdrawalBundlePolicyResponse, error) {
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return producer.SetWithdrawalBundlePolicy(ctx, c)
+	return proxyCall(ctx, c, producer.SetWithdrawalBundlePolicy)
 }
 
-// ProposeWithdrawalBundle implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) ProposeWithdrawalBundle(ctx context.Context, c *connect.Request[mainchainv1.ProposeWithdrawalBundleRequest]) (*connect.Response[mainchainv1.ProposeWithdrawalBundleResponse], error) {
+// ProposeWithdrawalBundle implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) ProposeWithdrawalBundle(ctx context.Context, c *mainchainv1.ProposeWithdrawalBundleRequest) (*mainchainv1.ProposeWithdrawalBundleResponse, error) {
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return producer.ProposeWithdrawalBundle(ctx, c)
+	return proxyCall(ctx, c, producer.ProposeWithdrawalBundle)
 }
 
-// GetBlockProducerState implements mainchainv1connect.BlockProducerServiceHandler.
-func (s *Server) GetBlockProducerState(ctx context.Context, c *connect.Request[mainchainv1.GetBlockProducerStateRequest]) (*connect.Response[mainchainv1.GetBlockProducerStateResponse], error) {
+// GetBlockProducerState implements validatorrpc.BlockProducerServiceHandler.
+func (s *Server) GetBlockProducerState(ctx context.Context, c *mainchainv1.GetBlockProducerStateRequest) (*mainchainv1.GetBlockProducerStateResponse, error) {
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return producer.GetBlockProducerState(ctx, c)
+	return proxyCall(ctx, c, producer.GetBlockProducerState)
 }
 
-// GetWithdrawalBundleProposals implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetWithdrawalBundleProposals(ctx context.Context, c *connect.Request[mainchainv1.GetWithdrawalBundleProposalsRequest]) (*connect.Response[mainchainv1.GetWithdrawalBundleProposalsResponse], error) {
+// GetWithdrawalBundleProposals implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetWithdrawalBundleProposals(ctx context.Context, c *mainchainv1.GetWithdrawalBundleProposalsRequest) (*mainchainv1.GetWithdrawalBundleProposalsResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetWithdrawalBundleProposals(ctx, c)
+	return proxyCall(ctx, c, validator.GetWithdrawalBundleProposals)
 }
 
-// GetBlockHeaderInfo implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetBlockHeaderInfo(ctx context.Context, c *connect.Request[mainchainv1.GetBlockHeaderInfoRequest]) (*connect.Response[mainchainv1.GetBlockHeaderInfoResponse], error) {
+// GetBlockHeaderInfo implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetBlockHeaderInfo(ctx context.Context, c *mainchainv1.GetBlockHeaderInfoRequest) (*mainchainv1.GetBlockHeaderInfoResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetBlockHeaderInfo(ctx, c)
+	return proxyCall(ctx, c, validator.GetBlockHeaderInfo)
 }
 
-// GetBlockInfo implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetBlockInfo(ctx context.Context, c *connect.Request[mainchainv1.GetBlockInfoRequest]) (*connect.Response[mainchainv1.GetBlockInfoResponse], error) {
+// GetBlockInfo implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetBlockInfo(ctx context.Context, c *mainchainv1.GetBlockInfoRequest) (*mainchainv1.GetBlockInfoResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetBlockInfo(ctx, c)
+	return proxyCall(ctx, c, validator.GetBlockInfo)
 }
 
-// GetBmmHStarCommitment implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetBmmHStarCommitment(ctx context.Context, c *connect.Request[mainchainv1.GetBmmHStarCommitmentRequest]) (*connect.Response[mainchainv1.GetBmmHStarCommitmentResponse], error) {
+// GetBmmHStarCommitment implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetBmmHStarCommitment(ctx context.Context, c *mainchainv1.GetBmmHStarCommitmentRequest) (*mainchainv1.GetBmmHStarCommitmentResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetBmmHStarCommitment(ctx, c)
+	return proxyCall(ctx, c, validator.GetBmmHStarCommitment)
 }
 
-// GetChainInfo implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetChainInfo(ctx context.Context, c *connect.Request[mainchainv1.GetChainInfoRequest]) (*connect.Response[mainchainv1.GetChainInfoResponse], error) {
+// GetChainInfo implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetChainInfo(ctx context.Context, c *mainchainv1.GetChainInfoRequest) (*mainchainv1.GetChainInfoResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetChainInfo(ctx, c)
+	return proxyCall(ctx, c, validator.GetChainInfo)
 }
 
-// GetChainTip implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetChainTip(ctx context.Context, c *connect.Request[mainchainv1.GetChainTipRequest]) (*connect.Response[mainchainv1.GetChainTipResponse], error) {
+// GetChainTip implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetChainTip(ctx context.Context, c *mainchainv1.GetChainTipRequest) (*mainchainv1.GetChainTipResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetChainTip(ctx, c)
+	return proxyCall(ctx, c, validator.GetChainTip)
 }
 
-// GetCoinbasePSBT implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetCoinbasePSBT(ctx context.Context, c *connect.Request[mainchainv1.GetCoinbasePSBTRequest]) (*connect.Response[mainchainv1.GetCoinbasePSBTResponse], error) {
+// GetCoinbasePSBT implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetCoinbasePSBT(ctx context.Context, c *mainchainv1.GetCoinbasePSBTRequest) (*mainchainv1.GetCoinbasePSBTResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetCoinbasePSBT(ctx, c)
+	return proxyCall(ctx, c, validator.GetCoinbasePSBT)
 }
 
-// GetCtip implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetCtip(ctx context.Context, c *connect.Request[mainchainv1.GetCtipRequest]) (*connect.Response[mainchainv1.GetCtipResponse], error) {
+// GetCtip implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetCtip(ctx context.Context, c *mainchainv1.GetCtipRequest) (*mainchainv1.GetCtipResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetCtip(ctx, c)
+	return proxyCall(ctx, c, validator.GetCtip)
 }
 
-// GetSidechainProposals implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetSidechainProposals(ctx context.Context, c *connect.Request[mainchainv1.GetSidechainProposalsRequest]) (*connect.Response[mainchainv1.GetSidechainProposalsResponse], error) {
+// GetSidechainProposals implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetSidechainProposals(ctx context.Context, c *mainchainv1.GetSidechainProposalsRequest) (*mainchainv1.GetSidechainProposalsResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetSidechainProposals(ctx, c)
+	return proxyCall(ctx, c, validator.GetSidechainProposals)
 }
 
-// GetSeenBmmRequests implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetSeenBmmRequests(ctx context.Context, c *connect.Request[mainchainv1.GetSeenBmmRequestsRequest]) (*connect.Response[mainchainv1.GetSeenBmmRequestsResponse], error) {
+// GetSeenBmmRequests implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetSeenBmmRequests(ctx context.Context, c *mainchainv1.GetSeenBmmRequestsRequest) (*mainchainv1.GetSeenBmmRequestsResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetSeenBmmRequests(ctx, c)
+	return proxyCall(ctx, c, validator.GetSeenBmmRequests)
 }
 
-// GetSidechains implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetSidechains(ctx context.Context, c *connect.Request[mainchainv1.GetSidechainsRequest]) (*connect.Response[mainchainv1.GetSidechainsResponse], error) {
+// GetSidechains implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetSidechains(ctx context.Context, c *mainchainv1.GetSidechainsRequest) (*mainchainv1.GetSidechainsResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetSidechains(ctx, c)
+	return proxyCall(ctx, c, validator.GetSidechains)
 }
 
-// GetTwoWayPegData implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) GetTwoWayPegData(ctx context.Context, c *connect.Request[mainchainv1.GetTwoWayPegDataRequest]) (*connect.Response[mainchainv1.GetTwoWayPegDataResponse], error) {
+// GetTwoWayPegData implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) GetTwoWayPegData(ctx context.Context, c *mainchainv1.GetTwoWayPegDataRequest) (*mainchainv1.GetTwoWayPegDataResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetTwoWayPegData(ctx, c)
+	return proxyCall(ctx, c, validator.GetTwoWayPegData)
 }
 
-// SubscribeEvents implements mainchainv1connect.ValidatorServiceHandler.
-func (s *Server) SubscribeEvents(ctx context.Context, c *connect.Request[mainchainv1.SubscribeEventsRequest], stream *connect.ServerStream[mainchainv1.SubscribeEventsResponse]) error {
+// SubscribeEvents implements validatorrpc.ValidatorServiceHandler.
+func (s *Server) SubscribeEvents(ctx context.Context, c *mainchainv1.SubscribeEventsRequest, stream validatorrpc.ValidatorServiceSubscribeEventsServerStream) error {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return err
 	}
-	clientStream, err := validator.SubscribeEvents(ctx, c)
+	callCtx, info := clientContext(ctx)
+	clientStream, err := validator.SubscribeEvents(callCtx, c)
 	if err != nil {
+		copyResponseMetadata(ctx, info)
 		zerolog.Ctx(ctx).Error().Err(err).Msg("subscribe to events")
 		return err
 	}
-	return forwardStream(ctx, "events", clientStream, stream)
+	return forwardStream(ctx, "events", info, clientStream, stream)
 }
 
 // HmacSha512 implements cryptov1connect.CryptoServiceHandler.
-func (s *Server) HmacSha512(ctx context.Context, c *connect.Request[cryptov1.HmacSha512Request]) (*connect.Response[cryptov1.HmacSha512Response], error) {
+func (s *Server) HmacSha512(ctx context.Context, c *cryptov1.HmacSha512Request) (*cryptov1.HmacSha512Response, error) {
 	crypto, err := s.crypto.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return crypto.HmacSha512(ctx, c)
+	return proxyCall(ctx, c, crypto.HmacSha512)
 }
 
 // Ripemd160 implements cryptov1connect.CryptoServiceHandler.
-func (s *Server) Ripemd160(ctx context.Context, c *connect.Request[cryptov1.Ripemd160Request]) (*connect.Response[cryptov1.Ripemd160Response], error) {
+func (s *Server) Ripemd160(ctx context.Context, c *cryptov1.Ripemd160Request) (*cryptov1.Ripemd160Response, error) {
 	crypto, err := s.crypto.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return crypto.Ripemd160(ctx, c)
+	return proxyCall(ctx, c, crypto.Ripemd160)
 }
 
 // Secp256K1SecretKeyToPublicKey implements cryptov1connect.CryptoServiceHandler.
-func (s *Server) Secp256K1SecretKeyToPublicKey(ctx context.Context, c *connect.Request[cryptov1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[cryptov1.Secp256K1SecretKeyToPublicKeyResponse], error) {
+func (s *Server) Secp256K1SecretKeyToPublicKey(ctx context.Context, c *cryptov1.Secp256K1SecretKeyToPublicKeyRequest) (*cryptov1.Secp256K1SecretKeyToPublicKeyResponse, error) {
 	crypto, err := s.crypto.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return crypto.Secp256K1SecretKeyToPublicKey(ctx, c)
+	return proxyCall(ctx, c, crypto.Secp256K1SecretKeyToPublicKey)
 }
 
 // Secp256K1Sign implements cryptov1connect.CryptoServiceHandler.
-func (s *Server) Secp256K1Sign(ctx context.Context, c *connect.Request[cryptov1.Secp256K1SignRequest]) (*connect.Response[cryptov1.Secp256K1SignResponse], error) {
+func (s *Server) Secp256K1Sign(ctx context.Context, c *cryptov1.Secp256K1SignRequest) (*cryptov1.Secp256K1SignResponse, error) {
 	crypto, err := s.crypto.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return crypto.Secp256K1Sign(ctx, c)
+	return proxyCall(ctx, c, crypto.Secp256K1Sign)
 }
 
 // Secp256K1Verify implements cryptov1connect.CryptoServiceHandler.
-func (s *Server) Secp256K1Verify(ctx context.Context, c *connect.Request[cryptov1.Secp256K1VerifyRequest]) (*connect.Response[cryptov1.Secp256K1VerifyResponse], error) {
+func (s *Server) Secp256K1Verify(ctx context.Context, c *cryptov1.Secp256K1VerifyRequest) (*cryptov1.Secp256K1VerifyResponse, error) {
 	crypto, err := s.crypto.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return crypto.Secp256K1Verify(ctx, c)
+	return proxyCall(ctx, c, crypto.Secp256K1Verify)
 }
diff --git a/bitwindow/server/api/enforcer/enforcer_test.go b/bitwindow/server/api/enforcer/enforcer_test.go
new file mode 100644
index 0000000000..5407b25ab2
--- /dev/null
+++ b/bitwindow/server/api/enforcer/enforcer_test.go
@@ -0,0 +1,339 @@
+package enforcer
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/service"
+	mainchainv1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
+	validatorrpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect"
+)
+
+type testStreamReader struct {
+	receive func() (*wrapperspb.Int32Value, error)
+	close   func() error
+}
+
+func (r testStreamReader) Receive() (*wrapperspb.Int32Value, error) {
+	return r.receive()
+}
+
+func (r testStreamReader) Close() error {
+	return r.close()
+}
+
+func testCallInfo(t *testing.T) *connect.CallInfo {
+	t.Helper()
+	_, info := connect.NewClientContext(t.Context())
+	return info
+}
+
+type testStreamWriter func(*wrapperspb.Int32Value) error
+
+func (w testStreamWriter) Send(msg *wrapperspb.Int32Value) error {
+	return w(msg)
+}
+
+func TestForwardStreamMessages(t *testing.T) {
+	messages := []*wrapperspb.Int32Value{wrapperspb.Int32(1), wrapperspb.Int32(2), wrapperspb.Int32(3)}
+	reads, closes := 0, 0
+	in := testStreamReader{
+		receive: func() (*wrapperspb.Int32Value, error) {
+			reads++
+			if reads > len(messages) {
+				return nil, io.EOF
+			}
+			return messages[reads-1], nil
+		},
+		close: func() error {
+			closes++
+			return nil
+		},
+	}
+	var sent []*wrapperspb.Int32Value
+	out := testStreamWriter(func(msg *wrapperspb.Int32Value) error {
+		sent = append(sent, msg)
+		return nil
+	})
+
+	require.NoError(t, forwardStream(t.Context(), "test", testCallInfo(t), in, out))
+	require.Equal(t, len(messages)+1, reads)
+	require.Equal(t, 1, closes)
+	require.Len(t, sent, len(messages))
+	for i := range messages {
+		require.Same(t, messages[i], sent[i])
+	}
+}
+
+func TestForwardStreamErrors(t *testing.T) {
+	receiveErr := connect.NewError(connect.CodeUnavailable, "receive failed")
+	sendErr := errors.New("send failed")
+	closeErr := errors.New("close failed")
+	for _, tt := range []struct {
+		name       string
+		receiveErr error
+		sendErr    error
+		closeErr   error
+	}{
+		{name: "empty stream", receiveErr: io.EOF},
+		{name: "receive fails", receiveErr: receiveErr},
+		{name: "send fails", sendErr: sendErr},
+		{name: "close fails", closeErr: closeErr},
+		{name: "receive and close fail", receiveErr: receiveErr, closeErr: closeErr},
+		{name: "send and close fail", sendErr: sendErr, closeErr: closeErr},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			reads, sends, closes := 0, 0, 0
+			in := testStreamReader{
+				receive: func() (*wrapperspb.Int32Value, error) {
+					reads++
+					if tt.receiveErr != nil {
+						return nil, tt.receiveErr
+					}
+					if reads > 1 {
+						return nil, io.EOF
+					}
+					return wrapperspb.Int32(1), nil
+				},
+				close: func() error {
+					closes++
+					return tt.closeErr
+				},
+			}
+			out := testStreamWriter(func(*wrapperspb.Int32Value) error {
+				sends++
+				return tt.sendErr
+			})
+
+			err := forwardStream(t.Context(), "test", testCallInfo(t), in, out)
+			require.Equal(t, 1, closes)
+			switch {
+			case tt.receiveErr != nil:
+				require.Equal(t, 1, reads)
+				require.Zero(t, sends)
+			case tt.sendErr != nil:
+				require.Equal(t, 1, reads)
+				require.Equal(t, 1, sends)
+			default:
+				require.Equal(t, 2, reads)
+				require.Equal(t, 1, sends)
+			}
+			if tt.receiveErr == io.EOF {
+				require.NoError(t, err)
+				return
+			}
+			if tt.receiveErr != nil {
+				require.ErrorIs(t, err, tt.receiveErr)
+				require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
+			}
+			if tt.sendErr != nil {
+				require.ErrorIs(t, err, tt.sendErr)
+				require.ErrorContains(t, err, "forward stream message")
+			}
+			if tt.closeErr != nil {
+				require.ErrorIs(t, err, tt.closeErr)
+			}
+		})
+	}
+}
+
+func TestForwardStreamCancellation(t *testing.T) {
+	for _, method := range []string{"receive", "send"} {
+		t.Run(method, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(t.Context())
+			defer cancel()
+			entered := make(chan struct{})
+			closes := 0
+			in := testStreamReader{
+				receive: func() (*wrapperspb.Int32Value, error) {
+					if method == "receive" {
+						close(entered)
+						<-ctx.Done()
+						return nil, ctx.Err()
+					}
+					return wrapperspb.Int32(1), nil
+				},
+				close: func() error {
+					closes++
+					return nil
+				},
+			}
+			out := testStreamWriter(func(*wrapperspb.Int32Value) error {
+				close(entered)
+				<-ctx.Done()
+				return ctx.Err()
+			})
+			result := make(chan error, 1)
+			go func() {
+				result <- forwardStream(ctx, "test", testCallInfo(t), in, out)
+			}()
+
+			select {
+			case <-entered:
+			case <-time.After(5 * time.Second):
+				t.Fatal("the stream did not start")
+			}
+			cancel()
+			select {
+			case err := <-result:
+				require.ErrorIs(t, err, context.Canceled)
+				require.Equal(t, 1, closes)
+			case <-time.After(5 * time.Second):
+				t.Fatal("the stream did not stop")
+			}
+		})
+	}
+}
+
+type metadataValidator struct {
+	validatorrpc.UnimplementedValidatorServiceHandler
+	requests chan []string
+	fail     bool
+}
+
+var errUpstream = connect.NewError(connect.CodeFailedPrecondition, "upstream failed")
+
+func (s metadataValidator) GetChainTip(ctx context.Context, _ *mainchainv1.GetChainTipRequest) (*mainchainv1.GetChainTipResponse, error) {
+	info, ok := connect.CallInfoForServerContext(ctx)
+	if !ok {
+		return nil, errors.New("the call info is absent")
+	}
+	s.requests <- info.RequestHeader().Values("X-Test-Request")
+	info.ResponseHeader().SetValues("X-Test-Header", []string{"header one", "header two"})
+	info.ResponseTrailer().SetValues("X-Test-Trailer", []string{"trailer one", "trailer two"})
+	if s.fail {
+		return nil, errUpstream
+	}
+	return &mainchainv1.GetChainTipResponse{}, nil
+}
+
+func (s metadataValidator) SubscribeHeaderSyncProgress(ctx context.Context, _ *mainchainv1.SubscribeHeaderSyncProgressRequest, stream validatorrpc.ValidatorServiceSubscribeHeaderSyncProgressServerStream) error {
+	info, ok := connect.CallInfoForServerContext(ctx)
+	if !ok {
+		return errors.New("the call info is absent")
+	}
+	s.requests <- info.RequestHeader().Values("X-Test-Request")
+	info.ResponseHeader().SetValues("X-Test-Header", []string{"header one", "header two"})
+	info.ResponseTrailer().SetValues("X-Test-Trailer", []string{"trailer one", "trailer two"})
+	if err := stream.Send(&mainchainv1.SubscribeHeaderSyncProgressResponse{CurrentHeight: wrapperspb.UInt32(42)}); err != nil {
+		return err
+	}
+	if s.fail {
+		return errUpstream
+	}
+	return nil
+}
+
+func metadataProxy(t *testing.T, requests chan []string, fail bool) *httptest.Server {
+	t.Helper()
+	upstream := connect.NewServer()
+	validatorrpc.RegisterValidatorServiceHandler(upstream, metadataValidator{requests: requests, fail: fail})
+	upstreamMux := http.NewServeMux()
+	connecthttp.Mount(upstreamMux, upstream, connecthttp.WithReadMaxBytes(0))
+	upstreamServer := httptest.NewUnstartedServer(upstreamMux)
+	upstreamServer.EnableHTTP2 = true
+	upstreamServer.StartTLS()
+	t.Cleanup(upstreamServer.Close)
+
+	client := validatorrpc.NewValidatorServiceClient(connect.NewClient(
+		connecthttp.NewTransport(upstreamServer.Client(), upstreamServer.URL, connecthttp.WithGRPC(), connecthttp.WithReadMaxBytes(0)),
+	))
+	validator := service.New("validator", func(context.Context) (validatorrpc.ValidatorServiceClient, error) {
+		return client, nil
+	})
+	proxy := connect.NewServer()
+	validatorrpc.RegisterValidatorServiceHandler(proxy, New(validator, nil, nil, nil, nil))
+	mux := http.NewServeMux()
+	connecthttp.Mount(mux, proxy, connecthttp.WithReadMaxBytes(0))
+	server := httptest.NewServer(mux)
+	t.Cleanup(server.Close)
+	return server
+}
+
+func TestProxyUnaryMetadata(t *testing.T) {
+	requests := make(chan []string, 1)
+	server := metadataProxy(t, requests, false)
+	client := connectv1.NewClient[mainchainv1.GetChainTipRequest, mainchainv1.GetChainTipResponse](
+		server.Client(), server.URL+validatorrpc.ValidatorServiceGetChainTipProcedure,
+	)
+	req := connectv1.NewRequest(&mainchainv1.GetChainTipRequest{})
+	req.Header()["X-Test-Request"] = []string{"request one", "request two"}
+
+	resp, err := client.CallUnary(t.Context(), req)
+	require.NoError(t, err)
+	assert.Equal(t, []string{"request one", "request two"}, <-requests)
+	assert.Equal(t, []string{"header one", "header two"}, resp.Header().Values("X-Test-Header"))
+	assert.Equal(t, []string{"trailer one", "trailer two"}, resp.Trailer().Values("X-Test-Trailer"))
+}
+
+func TestProxyStreamRequestMetadata(t *testing.T) {
+	requests := make(chan []string, 1)
+	server := metadataProxy(t, requests, false)
+	client := connectv1.NewClient[mainchainv1.SubscribeHeaderSyncProgressRequest, mainchainv1.SubscribeHeaderSyncProgressResponse](
+		server.Client(), server.URL+validatorrpc.ValidatorServiceSubscribeHeaderSyncProgressProcedure,
+	)
+	req := connectv1.NewRequest(&mainchainv1.SubscribeHeaderSyncProgressRequest{})
+	req.Header()["X-Test-Request"] = []string{"request one", "request two"}
+
+	stream, err := client.CallServerStream(t.Context(), req)
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, stream.Close()) })
+	require.True(t, stream.Receive())
+	require.Equal(t, uint32(42), stream.Msg().GetCurrentHeight().GetValue())
+	require.False(t, stream.Receive())
+	require.NoError(t, stream.Err())
+	assert.Equal(t, []string{"request one", "request two"}, <-requests)
+}
+
+func TestProxyUnaryErrorMetadata(t *testing.T) {
+	requests := make(chan []string, 1)
+	server := metadataProxy(t, requests, true)
+	client := connectv1.NewClient[mainchainv1.GetChainTipRequest, mainchainv1.GetChainTipResponse](
+		server.Client(), server.URL+validatorrpc.ValidatorServiceGetChainTipProcedure,
+	)
+
+	_, err := client.CallUnary(t.Context(), connectv1.NewRequest(&mainchainv1.GetChainTipRequest{}))
+	<-requests
+	var connectErr *connectv1.Error
+	require.ErrorAs(t, err, &connectErr)
+	assert.Equal(t, []string{"header one", "header two"}, connectErr.Meta().Values("X-Test-Header"))
+	assert.Equal(t, []string{"trailer one", "trailer two"}, connectErr.Meta().Values("X-Test-Trailer"))
+}
+
+func TestProxyStreamResponseMetadata(t *testing.T) {
+	for _, fail := range []bool{false, true} {
+		t.Run(map[bool]string{false: "success", true: "failure"}[fail], func(t *testing.T) {
+			requests := make(chan []string, 1)
+			server := metadataProxy(t, requests, fail)
+			client := connectv1.NewClient[mainchainv1.SubscribeHeaderSyncProgressRequest, mainchainv1.SubscribeHeaderSyncProgressResponse](
+				server.Client(), server.URL+validatorrpc.ValidatorServiceSubscribeHeaderSyncProgressProcedure,
+			)
+
+			stream, err := client.CallServerStream(t.Context(), connectv1.NewRequest(&mainchainv1.SubscribeHeaderSyncProgressRequest{}))
+			require.NoError(t, err)
+			t.Cleanup(func() { require.NoError(t, stream.Close()) })
+			require.True(t, stream.Receive())
+			require.False(t, stream.Receive())
+			<-requests
+			if fail {
+				assert.Equal(t, connectv1.CodeInternal, connectv1.CodeOf(stream.Err()))
+			} else {
+				require.NoError(t, stream.Err())
+			}
+			assert.Equal(t, []string{"header one", "header two"}, stream.ResponseHeader().Values("X-Test-Header"))
+			assert.Equal(t, []string{"trailer one", "trailer two"}, stream.ResponseTrailer().Values("X-Test-Trailer"))
+		})
+	}
+}
diff --git a/bitwindow/server/api/health/health.go b/bitwindow/server/api/health/health.go
index 7abcadfcf9..7303bf38b5 100644
--- a/bitwindow/server/api/health/health.go
+++ b/bitwindow/server/api/health/health.go
@@ -6,7 +6,8 @@ import (
 	"errors"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/rs/zerolog"
@@ -49,20 +50,20 @@ type Server struct {
 	crypto   *service.Service[cryptorpc.CryptoServiceClient]
 }
 
-// Check implements healthv1connect.HealthServiceHandler.
-func (s *Server) Check(ctx context.Context, _ *connect.Request[emptypb.Empty]) (*connect.Response[healthv1.CheckResponse], error) {
+// Check implements rpc.HealthServiceHandler.
+func (s *Server) Check(ctx context.Context, _ *emptypb.Empty) (*healthv1.CheckResponse, error) {
 
 	statuses, err := s.getServiceStatuses(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&healthv1.CheckResponse{
+	return &healthv1.CheckResponse{
 		ServiceStatuses: statuses,
-	}), nil
+	}, nil
 }
 
-func (s *Server) Watch(ctx context.Context, _ *connect.Request[emptypb.Empty], stream *connect.ServerStream[healthv1.CheckResponse]) error {
+func (s *Server) Watch(ctx context.Context, _ *emptypb.Empty, stream rpc.HealthServiceWatchServerStream) error {
 	type serviceStatusEvent struct {
 		name   string
 		status bool
@@ -202,21 +203,21 @@ func (s *Server) getServiceStatuses(ctx context.Context) ([]*healthv1.CheckRespo
 
 	pool.Go("bitcoind", func(ctx context.Context) (*healthv1.CheckResponse_ServiceStatus, error) {
 		return checkHealth(ctx, "bitcoind", s.bitcoind, func(ctx context.Context, client corerpc.BitcoinServiceClient) error {
-			_, err := client.GetBlockchainInfo(ctx, connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+			_, err := client.GetBlockchainInfo(ctx, connectv1.NewRequest(&corepb.GetBlockchainInfoRequest{}))
 			return err
 		}), nil
 	})
 
 	pool.Go("enforcer", func(ctx context.Context) (*healthv1.CheckResponse_ServiceStatus, error) {
 		return checkHealth(ctx, "enforcer", s.enforcer, func(ctx context.Context, client validatorrpc.ValidatorServiceClient) error {
-			_, err := client.GetChainInfo(ctx, connect.NewRequest(&mainchainv1.GetChainInfoRequest{}))
+			_, err := client.GetChainInfo(ctx, &mainchainv1.GetChainInfoRequest{})
 			return err
 		}), nil
 	})
 
 	pool.Go("crypto", func(ctx context.Context) (*healthv1.CheckResponse_ServiceStatus, error) {
 		return checkHealth(ctx, "crypto", s.crypto, func(ctx context.Context, client cryptorpc.CryptoServiceClient) error {
-			_, err := client.Ripemd160(ctx, connect.NewRequest(&cryptov1.Ripemd160Request{
+			_, err := client.Ripemd160(ctx, &cryptov1.Ripemd160Request{
 				Msg: &commonv1.Hex{
 					Hex: &wrapperspb.StringValue{
 						// pass a valid hex string here, so that the
@@ -224,7 +225,7 @@ func (s *Server) getServiceStatuses(ctx context.Context) ([]*healthv1.CheckRespo
 						Value: "deadbeef",
 					},
 				},
-			}))
+			})
 			return err
 		}), nil
 	})
diff --git a/bitwindow/server/api/health/health_test.go b/bitwindow/server/api/health/health_test.go
index 087cbceb26..b11a0bed90 100644
--- a/bitwindow/server/api/health/health_test.go
+++ b/bitwindow/server/api/health/health_test.go
@@ -3,13 +3,16 @@ package health_test
 import (
 	"context"
 	"errors"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"sync/atomic"
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/stretchr/testify/assert"
@@ -49,38 +52,34 @@ func TestService_Check(t *testing.T) {
 		// Health check calls
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Chain: "signet"},
 			}, nil).
 			AnyTimes()
 
 		mockValidator.EXPECT().
 			GetChainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[mainchainv1.GetChainInfoResponse]{
-				Msg: &mainchainv1.GetChainInfoResponse{},
-			}, nil).
+			Return(&mainchainv1.GetChainInfoResponse{}, nil).
 			AnyTimes()
 
 		mockCrypto.EXPECT().
 			Ripemd160(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[cryptov1.Ripemd160Response]{
-				Msg: &cryptov1.Ripemd160Response{},
-			}, nil).
+			Return(&cryptov1.Ripemd160Response{}, nil).
 			AnyTimes()
 
-		cli := rpc.NewHealthServiceClient(apitests.API(t, db,
+		cli := rpc.NewHealthServiceClient(apitests.RPC(t, db,
 			apitests.WithBitcoind(mockBitcoind),
 			apitests.WithValidator(mockValidator),
 			apitests.WithCrypto(mockCrypto),
 		))
 
-		resp, err := cli.Check(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.Check(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		require.NotEmpty(t, resp.Msg.ServiceStatuses)
+		require.NotEmpty(t, resp.ServiceStatuses)
 
 		// Check that we have status for each service
 		serviceNames := make(map[string]bool)
-		for _, status := range resp.Msg.ServiceStatuses {
+		for _, status := range resp.ServiceStatuses {
 			serviceNames[status.ServiceName] = true
 		}
 		assert.True(t, serviceNames["database"])
@@ -102,19 +101,19 @@ func TestService_Check(t *testing.T) {
 		// Health check
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Chain: "signet"},
 			}, nil).
 			AnyTimes()
 
-		cli := rpc.NewHealthServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := rpc.NewHealthServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.Check(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.Check(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 
 		// Find database status
 		var dbStatus *healthv1.CheckResponse_ServiceStatus
-		for _, status := range resp.Msg.ServiceStatuses {
+		for _, status := range resp.ServiceStatuses {
 			if status.ServiceName == "database" {
 				dbStatus = status
 				break
@@ -138,17 +137,17 @@ func TestService_Check(t *testing.T) {
 		// Health check fails
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, nil)).
+			Return(nil, connectv1.NewError(connectv1.CodeUnavailable, nil)).
 			AnyTimes()
 
-		cli := rpc.NewHealthServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := rpc.NewHealthServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.Check(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.Check(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 
 		// Find bitcoind status
 		var bitcoindStatus *healthv1.CheckResponse_ServiceStatus
-		for _, status := range resp.Msg.ServiceStatuses {
+		for _, status := range resp.ServiceStatuses {
 			if status.ServiceName == "bitcoind" {
 				bitcoindStatus = status
 				break
@@ -170,7 +169,7 @@ func TestService_Check(t *testing.T) {
 		// Health check
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Chain: "signet"},
 			}, nil).
 			AnyTimes()
@@ -179,20 +178,20 @@ func TestService_Check(t *testing.T) {
 		// Health check fails
 		mockValidator.EXPECT().
 			GetChainInfo(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, nil)).
+			Return(nil, connect.NewError(connect.CodeUnavailable, "")).
 			AnyTimes()
 
-		cli := rpc.NewHealthServiceClient(apitests.API(t, db,
+		cli := rpc.NewHealthServiceClient(apitests.RPC(t, db,
 			apitests.WithBitcoind(mockBitcoind),
 			apitests.WithValidator(mockValidator),
 		))
 
-		resp, err := cli.Check(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.Check(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 
 		// Find enforcer status
 		var enforcerStatus *healthv1.CheckResponse_ServiceStatus
-		for _, status := range resp.Msg.ServiceStatuses {
+		for _, status := range resp.ServiceStatuses {
 			if status.ServiceName == "enforcer" {
 				enforcerStatus = status
 				break
@@ -214,7 +213,7 @@ func TestService_Check(t *testing.T) {
 		// Health check
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Chain: "signet"},
 			}, nil).
 			AnyTimes()
@@ -224,20 +223,20 @@ func TestService_Check(t *testing.T) {
 		// Health check fails
 		mockCrypto.EXPECT().
 			Ripemd160(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, nil)).
+			Return(nil, connect.NewError(connect.CodeUnavailable, "")).
 			AnyTimes()
 
-		cli := rpc.NewHealthServiceClient(apitests.API(t, db,
+		cli := rpc.NewHealthServiceClient(apitests.RPC(t, db,
 			apitests.WithBitcoind(mockBitcoind),
 			apitests.WithCrypto(mockCrypto),
 		))
 
-		resp, err := cli.Check(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.Check(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 
 		// Find crypto status
 		var cryptoStatus *healthv1.CheckResponse_ServiceStatus
-		for _, status := range resp.Msg.ServiceStatuses {
+		for _, status := range resp.ServiceStatuses {
 			if status.ServiceName == "crypto" {
 				cryptoStatus = status
 				break
@@ -258,7 +257,7 @@ func TestService_Check(t *testing.T) {
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{Chain: "signet"},
 			}, nil).
 			AnyTimes()
@@ -267,7 +266,7 @@ func TestService_Check(t *testing.T) {
 		mockValidator := mocks.NewMockValidatorServiceClient(ctrl)
 		mockValidator.EXPECT().
 			GetChainInfo(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, nil)).
+			Return(nil, connect.NewError(connect.CodeUnavailable, "")).
 			AnyTimes()
 
 		// wallet healthy
@@ -275,21 +274,21 @@ func TestService_Check(t *testing.T) {
 		mockCrypto := mocks.NewMockCryptoServiceClient(ctrl)
 		mockCrypto.EXPECT().
 			Ripemd160(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, nil)).
+			Return(nil, connect.NewError(connect.CodeUnavailable, "")).
 			AnyTimes()
 
-		cli := rpc.NewHealthServiceClient(apitests.API(t, db,
+		cli := rpc.NewHealthServiceClient(apitests.RPC(t, db,
 			apitests.WithBitcoind(mockBitcoind),
 			apitests.WithValidator(mockValidator),
 			apitests.WithCrypto(mockCrypto),
 		))
 
-		resp, err := cli.Check(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.Check(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 
 		// Check statuses
 		statusMap := make(map[string]healthv1.CheckResponse_Status)
-		for _, status := range resp.Msg.ServiceStatuses {
+		for _, status := range resp.ServiceStatuses {
 			statusMap[status.ServiceName] = status.Status
 		}
 
@@ -328,19 +327,21 @@ func TestService_Watch(t *testing.T) {
 			service.New("crypto", refuse[cryptorpc.CryptoServiceClient]),
 		)
 		mux := http.NewServeMux()
-		mux.Handle(rpc.NewHealthServiceHandler(srv))
+		srv2 := connect.NewServer()
+		rpc.RegisterHealthServiceHandler(srv2, srv)
+		connecthttp.Mount(mux, srv2, connecthttp.WithReadMaxBytes(0))
 		server := httptest.NewServer(mux)
 		t.Cleanup(server.Close)
 
 		ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
 		defer cancel()
-		stream, err := rpc.NewHealthServiceClient(server.Client(), server.URL).
-			Watch(ctx, connect.NewRequest(&emptypb.Empty{}))
+		stream, err := rpc.NewHealthServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0)))).
+			Watch(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
 		t.Cleanup(func() { require.NoError(t, stream.Close()) })
 
-		statusOf := func(name string) healthv1.CheckResponse_Status {
-			for _, st := range stream.Msg().ServiceStatuses {
+		statusOf := func(response *healthv1.CheckResponse, name string) healthv1.CheckResponse_Status {
+			for _, st := range response.ServiceStatuses {
 				if st.ServiceName == name {
 					return st.Status
 				}
@@ -349,20 +350,30 @@ func TestService_Watch(t *testing.T) {
 			return 0
 		}
 
-		require.True(t, stream.Receive())
-		assert.Equal(t, healthv1.CheckResponse_STATUS_SERVING, statusOf("database"))
-		assert.Equal(t, healthv1.CheckResponse_STATUS_NOT_SERVING, statusOf("enforcer"))
+		response, err := stream.Receive()
+		require.NoError(t, err)
+		assert.Equal(t, healthv1.CheckResponse_STATUS_SERVING, statusOf(response, "database"))
+		assert.Equal(t, healthv1.CheckResponse_STATUS_NOT_SERVING, statusOf(response, "enforcer"))
 
 		enforcerUp.Store(true)
 		_, err = enforcer.Connect(ctx)
 		require.NoError(t, err)
 
-		for stream.Receive() {
-			if statusOf("enforcer") == healthv1.CheckResponse_STATUS_SERVING {
-				assert.Equal(t, healthv1.CheckResponse_STATUS_NOT_SERVING, statusOf("bitcoind"))
+		var streamErr error
+		for {
+			response, err := stream.Receive()
+			if err != nil {
+				streamErr = err
+				break
+			}
+			if statusOf(response, "enforcer") == healthv1.CheckResponse_STATUS_SERVING {
+				assert.Equal(t, healthv1.CheckResponse_STATUS_NOT_SERVING, statusOf(response, "bitcoind"))
 				return
 			}
 		}
-		t.Fatalf("the stream ended before the enforcer was serving: %v", stream.Err())
+		if errors.Is(streamErr, io.EOF) {
+			streamErr = nil
+		}
+		t.Fatalf("the stream ended before the enforcer was serving: %v", streamErr)
 	})
 }
diff --git a/bitwindow/server/api/log_level_test.go b/bitwindow/server/api/log_level_test.go
index ab41bdca97..8f3e2190db 100644
--- a/bitwindow/server/api/log_level_test.go
+++ b/bitwindow/server/api/log_level_test.go
@@ -7,13 +7,13 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/emptypb"
 
-	notificationv1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/notification/v1"
 	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/notification/v1/notificationv1connect"
 	utilsv1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/utils/v1"
 	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/utils/v1/utilsv1connect"
@@ -70,50 +70,52 @@ type panicUtils struct {
 	utilsv1connect.UnimplementedUtilsServiceHandler
 }
 
-func (panicUtils) ParseBitcoinURI(context.Context, *connect.Request[utilsv1.ParseBitcoinURIRequest]) (*connect.Response[utilsv1.ParseBitcoinURIResponse], error) {
+func (panicUtils) ParseBitcoinURI(context.Context, *utilsv1.ParseBitcoinURIRequest) (*utilsv1.ParseBitcoinURIResponse, error) {
 	panic("boom")
 }
 
-func (panicUtils) ValidateBitcoinURI(context.Context, *connect.Request[utilsv1.ValidateBitcoinURIRequest]) (*connect.Response[utilsv1.ValidateBitcoinURIResponse], error) {
-	return connect.NewResponse(&utilsv1.ValidateBitcoinURIResponse{Valid: true}), nil
+func (panicUtils) ValidateBitcoinURI(context.Context, *utilsv1.ValidateBitcoinURIRequest) (*utilsv1.ValidateBitcoinURIResponse, error) {
+	return &utilsv1.ValidateBitcoinURIResponse{Valid: true}, nil
 }
 
 type panicNotification struct {
 	notificationv1connect.UnimplementedNotificationServiceHandler
 }
 
-func (panicNotification) Watch(context.Context, *connect.Request[emptypb.Empty], *connect.ServerStream[notificationv1.WatchResponse]) error {
+func (panicNotification) Watch(context.Context, *emptypb.Empty, notificationv1connect.NotificationServiceWatchServerStream) error {
 	panic("boom")
 }
 
 func TestRecoverInterceptor(t *testing.T) {
-	opts := connect.WithInterceptors(logInterceptor(), recoverInterceptor{})
 	mux := http.NewServeMux()
-	mux.Handle(utilsv1connect.NewUtilsServiceHandler(panicUtils{}, opts))
-	mux.Handle(notificationv1connect.NewNotificationServiceHandler(panicNotification{}, opts))
+	server := connect.NewServer(logInterceptor(), recoverInterceptor())
+	utilsv1connect.RegisterUtilsServiceHandler(server, panicUtils{})
+	notificationv1connect.RegisterNotificationServiceHandler(server, panicNotification{})
+	connecthttp.Mount(mux, server, connecthttp.WithReadMaxBytes(0))
+
 	srv := httptest.NewServer(mux)
 	t.Cleanup(srv.Close)
 
 	t.Run("a unary panic gives CodeInternal and the server keeps serving", func(t *testing.T) {
-		cli := utilsv1connect.NewUtilsServiceClient(srv.Client(), srv.URL)
+		cli := utilsv1connect.NewUtilsServiceClient(connect.NewClient(connecthttp.NewTransport(srv.Client(), srv.URL, connecthttp.WithReadMaxBytes(0))))
 
-		_, err := cli.ParseBitcoinURI(t.Context(), connect.NewRequest(&utilsv1.ParseBitcoinURIRequest{}))
+		_, err := cli.ParseBitcoinURI(t.Context(), &utilsv1.ParseBitcoinURIRequest{})
 		require.ErrorContains(t, err, "panic in /utils.v1.UtilsService/ParseBitcoinURI")
 		require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 
-		resp, err := cli.ValidateBitcoinURI(t.Context(), connect.NewRequest(&utilsv1.ValidateBitcoinURIRequest{}))
+		resp, err := cli.ValidateBitcoinURI(t.Context(), &utilsv1.ValidateBitcoinURIRequest{})
 		require.NoError(t, err)
-		require.True(t, resp.Msg.Valid)
+		require.True(t, resp.Valid)
 	})
 
 	t.Run("a stream panic gives CodeInternal", func(t *testing.T) {
-		cli := notificationv1connect.NewNotificationServiceClient(srv.Client(), srv.URL)
+		cli := notificationv1connect.NewNotificationServiceClient(connect.NewClient(connecthttp.NewTransport(srv.Client(), srv.URL, connecthttp.WithReadMaxBytes(0))))
 
-		stream, err := cli.Watch(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		stream, err := cli.Watch(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		require.False(t, stream.Receive())
-		require.ErrorContains(t, stream.Err(), "panic in /notification.v1.NotificationService/Watch")
-		require.Equal(t, connect.CodeInternal, connect.CodeOf(stream.Err()))
+		_, err = stream.Receive()
+		require.ErrorContains(t, err, "panic in /notification.v1.NotificationService/Watch")
+		require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 		require.NoError(t, stream.Close())
 	})
 }
diff --git a/bitwindow/server/api/m4/m4.go b/bitwindow/server/api/m4/m4.go
index e00219526b..b60f949087 100644
--- a/bitwindow/server/api/m4/m4.go
+++ b/bitwindow/server/api/m4/m4.go
@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"sync"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 
@@ -30,9 +30,9 @@ func NewServer(m4Engine *engines.M4Engine, blockProducer *service.Service[valida
 
 func (s *Server) GetM4History(
 	ctx context.Context,
-	req *connect.Request[m4pb.GetM4HistoryRequest],
-) (*connect.Response[m4pb.GetM4HistoryResponse], error) {
-	limit := int(req.Msg.Limit)
+	req *m4pb.GetM4HistoryRequest,
+) (*m4pb.GetM4HistoryResponse, error) {
+	limit := int(req.Limit)
 	if limit == 0 {
 		limit = 6 // Default to last 6 blocks
 	}
@@ -67,52 +67,52 @@ func (s *Server) GetM4History(
 		}
 	}
 
-	return connect.NewResponse(&m4pb.GetM4HistoryResponse{
+	return &m4pb.GetM4HistoryResponse{
 		History: pbHistory,
-	}), nil
+	}, nil
 }
 
 func (s *Server) GetVotes(
 	ctx context.Context,
-	req *connect.Request[m4pb.GetVotesRequest],
-) (*connect.Response[m4pb.GetVotesResponse], error) {
+	req *m4pb.GetVotesRequest,
+) (*m4pb.GetVotesResponse, error) {
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("block producer: %w", err)
 	}
-	state, err := producer.GetBlockProducerState(ctx, connect.NewRequest(&validatorpb.GetBlockProducerStateRequest{}))
+	state, err := producer.GetBlockProducerState(ctx, &validatorpb.GetBlockProducerStateRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("get block producer state: %w", err)
 	}
 
-	upvotes := lo.Map(state.Msg.GetExplicitBundleAcks(), func(ack *validatorpb.WithdrawalBundleAck, _ int) *m4pb.BundleUpvote {
+	upvotes := lo.Map(state.GetExplicitBundleAcks(), func(ack *validatorpb.WithdrawalBundleAck, _ int) *m4pb.BundleUpvote {
 		return &m4pb.BundleUpvote{
 			SidechainSlot: ack.GetSidechainNumber().GetValue(),
 			M6Id:          ack.GetM6Id().GetHex().GetValue(),
 		}
 	})
 
-	return connect.NewResponse(&m4pb.GetVotesResponse{
-		Policy:  votePolicyFromEnforcer[state.Msg.GetWithdrawalBundlePolicy()],
+	return &m4pb.GetVotesResponse{
+		Policy:  votePolicyFromEnforcer[state.GetWithdrawalBundlePolicy()],
 		Upvotes: upvotes,
-	}), nil
+	}, nil
 }
 
 func (s *Server) SetBundleUpvote(
 	ctx context.Context,
-	req *connect.Request[m4pb.SetBundleUpvoteRequest],
-) (*connect.Response[m4pb.SetBundleUpvoteResponse], error) {
-	slot := req.Msg.SidechainSlot
+	req *m4pb.SetBundleUpvoteRequest,
+) (*m4pb.SetBundleUpvoteResponse, error) {
+	slot := req.SidechainSlot
 	if slot > 255 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid sidechain slot: %d", slot))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "invalid sidechain slot: %d", slot)
 	}
-	if req.Msg.M6Id != nil {
-		m6id, err := hex.DecodeString(req.Msg.GetM6Id())
+	if req.M6Id != nil {
+		m6id, err := hex.DecodeString(req.GetM6Id())
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("decode m6id %q: %w", req.Msg.GetM6Id(), err))
+			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("decode m6id %q: %s", req.GetM6Id(), err)).WithCause(err)
 		}
 		if len(m6id) != 32 {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("m6id %q is %d bytes, want 32", req.Msg.GetM6Id(), len(m6id)))
+			return nil, connect.Errorf(connect.CodeInvalidArgument, "m6id %q is %d bytes, want 32", req.GetM6Id(), len(m6id))
 		}
 	}
 
@@ -123,50 +123,50 @@ func (s *Server) SetBundleUpvote(
 	if err != nil {
 		return nil, fmt.Errorf("block producer: %w", err)
 	}
-	state, err := producer.GetBlockProducerState(ctx, connect.NewRequest(&validatorpb.GetBlockProducerStateRequest{}))
+	state, err := producer.GetBlockProducerState(ctx, &validatorpb.GetBlockProducerStateRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("get block producer state: %w", err)
 	}
 
 	// The enforcer upvotes the first ACKed bundle of a sidechain, so a sidechain must hold one ACK at most.
-	for _, ack := range state.Msg.GetExplicitBundleAcks() {
+	for _, ack := range state.GetExplicitBundleAcks() {
 		m6id := ack.GetM6Id().GetHex().GetValue()
-		if ack.GetSidechainNumber().GetValue() != slot || m6id == req.Msg.GetM6Id() {
+		if ack.GetSidechainNumber().GetValue() != slot || m6id == req.GetM6Id() {
 			continue
 		}
 		if err := setBundleAck(ctx, producer, slot, m6id, false); err != nil {
 			return nil, err
 		}
 	}
-	if req.Msg.M6Id != nil {
-		if err := setBundleAck(ctx, producer, slot, req.Msg.GetM6Id(), true); err != nil {
+	if req.M6Id != nil {
+		if err := setBundleAck(ctx, producer, slot, req.GetM6Id(), true); err != nil {
 			return nil, err
 		}
 	}
 
-	return connect.NewResponse(&m4pb.SetBundleUpvoteResponse{}), nil
+	return &m4pb.SetBundleUpvoteResponse{}, nil
 }
 
 func (s *Server) SetVotePolicy(
 	ctx context.Context,
-	req *connect.Request[m4pb.SetVotePolicyRequest],
-) (*connect.Response[m4pb.SetVotePolicyResponse], error) {
-	policy, ok := lo.FindKey(votePolicyFromEnforcer, req.Msg.Policy)
-	if !ok || req.Msg.Policy == m4pb.VotePolicy_VOTE_POLICY_UNSPECIFIED {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid vote policy: %s", req.Msg.Policy))
+	req *m4pb.SetVotePolicyRequest,
+) (*m4pb.SetVotePolicyResponse, error) {
+	policy, ok := lo.FindKey(votePolicyFromEnforcer, req.Policy)
+	if !ok || req.Policy == m4pb.VotePolicy_VOTE_POLICY_UNSPECIFIED {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "invalid vote policy: %s", req.Policy)
 	}
 
 	producer, err := s.blockProducer.Get(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("block producer: %w", err)
 	}
-	if _, err := producer.SetWithdrawalBundlePolicy(ctx, connect.NewRequest(&validatorpb.SetWithdrawalBundlePolicyRequest{
+	if _, err := producer.SetWithdrawalBundlePolicy(ctx, &validatorpb.SetWithdrawalBundlePolicyRequest{
 		Policy: policy,
-	})); err != nil {
+	}); err != nil {
 		return nil, fmt.Errorf("set withdrawal bundle policy: %w", err)
 	}
 
-	return connect.NewResponse(&m4pb.SetVotePolicyResponse{}), nil
+	return &m4pb.SetVotePolicyResponse{}, nil
 }
 
 var votePolicyFromEnforcer = map[validatorpb.WithdrawalBundlePolicy]m4pb.VotePolicy{
@@ -178,11 +178,11 @@ var votePolicyFromEnforcer = map[validatorpb.WithdrawalBundlePolicy]m4pb.VotePol
 }
 
 func setBundleAck(ctx context.Context, producer validatorrpc.BlockProducerServiceClient, slot uint32, m6id string, ack bool) error {
-	_, err := producer.SetWithdrawalBundleAck(ctx, connect.NewRequest(&validatorpb.SetWithdrawalBundleAckRequest{
+	_, err := producer.SetWithdrawalBundleAck(ctx, &validatorpb.SetWithdrawalBundleAckRequest{
 		SidechainNumber: wrapperspb.UInt32(slot),
 		M6Id:            &commonv1.ConsensusHex{Hex: wrapperspb.String(m6id)},
 		Ack:             ack,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("set withdrawal bundle ack for sidechain %d: %w", slot, err)
 	}
diff --git a/bitwindow/server/api/m4/m4_test.go b/bitwindow/server/api/m4/m4_test.go
index a4934a4a7a..80c93e0ee2 100644
--- a/bitwindow/server/api/m4/m4_test.go
+++ b/bitwindow/server/api/m4/m4_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -30,11 +30,11 @@ func TestService_GetM4History(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := m4v1connect.NewM4ServiceClient(apitests.API(t, db))
+		cli := m4v1connect.NewM4ServiceClient(apitests.RPC(t, db))
 
-		resp, err := cli.GetM4History(t.Context(), connect.NewRequest(&m4pb.GetM4HistoryRequest{}))
+		resp, err := cli.GetM4History(t.Context(), &m4pb.GetM4HistoryRequest{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.History)
+		assert.Empty(t, resp.History)
 	})
 
 	t.Run("respects limit parameter", func(t *testing.T) {
@@ -47,11 +47,11 @@ func TestService_GetM4History(t *testing.T) {
 				height, fmt.Sprintf("hash%d", height))
 			require.NoError(t, err)
 		}
-		cli := m4v1connect.NewM4ServiceClient(apitests.API(t, db))
+		cli := m4v1connect.NewM4ServiceClient(apitests.RPC(t, db))
 		heights := func(limit uint32) []uint32 {
-			resp, err := cli.GetM4History(t.Context(), connect.NewRequest(&m4pb.GetM4HistoryRequest{Limit: limit}))
+			resp, err := cli.GetM4History(t.Context(), &m4pb.GetM4HistoryRequest{Limit: limit})
 			require.NoError(t, err)
-			return lo.Map(resp.Msg.History, func(e *m4pb.M4HistoryEntry, _ int) uint32 { return e.BlockHeight })
+			return lo.Map(resp.History, func(e *m4pb.M4HistoryEntry, _ int) uint32 { return e.BlockHeight })
 		}
 
 		assert.Equal(t, []uint32{8, 7, 6, 5, 4, 3}, heights(0))
@@ -71,7 +71,7 @@ type fakeProducer struct {
 	acks   []*mainchainv1.WithdrawalBundleAck
 }
 
-func (f *fakeProducer) GetBlockProducerState(context.Context, *connect.Request[mainchainv1.GetBlockProducerStateRequest]) (*connect.Response[mainchainv1.GetBlockProducerStateResponse], error) {
+func (f *fakeProducer) GetBlockProducerState(context.Context, *mainchainv1.GetBlockProducerStateRequest) (*mainchainv1.GetBlockProducerStateResponse, error) {
 	f.mu.Lock()
 	resp := &mainchainv1.GetBlockProducerStateResponse{
 		WithdrawalBundlePolicy: f.policy,
@@ -80,30 +80,30 @@ func (f *fakeProducer) GetBlockProducerState(context.Context, *connect.Request[m
 	f.mu.Unlock()
 	// Widen the gap between a read and the write that follows it.
 	time.Sleep(time.Millisecond)
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
-func (f *fakeProducer) SetWithdrawalBundleAck(_ context.Context, req *connect.Request[mainchainv1.SetWithdrawalBundleAckRequest]) (*connect.Response[mainchainv1.SetWithdrawalBundleAckResponse], error) {
+func (f *fakeProducer) SetWithdrawalBundleAck(_ context.Context, req *mainchainv1.SetWithdrawalBundleAckRequest) (*mainchainv1.SetWithdrawalBundleAckResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.acks = slices.DeleteFunc(f.acks, func(ack *mainchainv1.WithdrawalBundleAck) bool {
-		return ack.GetSidechainNumber().GetValue() == req.Msg.GetSidechainNumber().GetValue() &&
-			ack.GetM6Id().GetHex().GetValue() == req.Msg.GetM6Id().GetHex().GetValue()
+		return ack.GetSidechainNumber().GetValue() == req.GetSidechainNumber().GetValue() &&
+			ack.GetM6Id().GetHex().GetValue() == req.GetM6Id().GetHex().GetValue()
 	})
-	if req.Msg.Ack {
+	if req.Ack {
 		f.acks = append(f.acks, &mainchainv1.WithdrawalBundleAck{
-			SidechainNumber: req.Msg.SidechainNumber,
-			M6Id:            req.Msg.M6Id,
+			SidechainNumber: req.SidechainNumber,
+			M6Id:            req.M6Id,
 		})
 	}
-	return connect.NewResponse(&mainchainv1.SetWithdrawalBundleAckResponse{}), nil
+	return &mainchainv1.SetWithdrawalBundleAckResponse{}, nil
 }
 
-func (f *fakeProducer) SetWithdrawalBundlePolicy(_ context.Context, req *connect.Request[mainchainv1.SetWithdrawalBundlePolicyRequest]) (*connect.Response[mainchainv1.SetWithdrawalBundlePolicyResponse], error) {
+func (f *fakeProducer) SetWithdrawalBundlePolicy(_ context.Context, req *mainchainv1.SetWithdrawalBundlePolicyRequest) (*mainchainv1.SetWithdrawalBundlePolicyResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	f.policy = req.Msg.Policy
-	return connect.NewResponse(&mainchainv1.SetWithdrawalBundlePolicyResponse{}), nil
+	f.policy = req.Policy
+	return &mainchainv1.SetWithdrawalBundlePolicyResponse{}, nil
 }
 
 func ack(slot uint32, m6id string) *mainchainv1.WithdrawalBundleAck {
@@ -114,7 +114,7 @@ func ack(slot uint32, m6id string) *mainchainv1.WithdrawalBundleAck {
 }
 
 func newClient(t *testing.T, producer *fakeProducer) m4v1connect.M4ServiceClient {
-	return m4v1connect.NewM4ServiceClient(apitests.API(t, database.Test(t), apitests.WithBlockProducer(producer)))
+	return m4v1connect.NewM4ServiceClient(apitests.RPC(t, database.Test(t), apitests.WithBlockProducer(producer)))
 }
 
 func TestService_GetVotes(t *testing.T) {
@@ -124,12 +124,12 @@ func TestService_GetVotes(t *testing.T) {
 		policy: mainchainv1.WithdrawalBundlePolicy_WITHDRAWAL_BUNDLE_POLICY_ALARM,
 		acks:   []*mainchainv1.WithdrawalBundleAck{ack(9, m6idA)},
 	}
-	resp, err := newClient(t, producer).GetVotes(t.Context(), connect.NewRequest(&m4pb.GetVotesRequest{}))
+	resp, err := newClient(t, producer).GetVotes(t.Context(), &m4pb.GetVotesRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, m4pb.VotePolicy_VOTE_POLICY_ALARM, resp.Msg.Policy)
-	require.Len(t, resp.Msg.Upvotes, 1)
-	assert.Equal(t, uint32(9), resp.Msg.Upvotes[0].SidechainSlot)
-	assert.Equal(t, m6idA, resp.Msg.Upvotes[0].M6Id)
+	assert.Equal(t, m4pb.VotePolicy_VOTE_POLICY_ALARM, resp.Policy)
+	require.Len(t, resp.Upvotes, 1)
+	assert.Equal(t, uint32(9), resp.Upvotes[0].SidechainSlot)
+	assert.Equal(t, m6idA, resp.Upvotes[0].M6Id)
 }
 
 func TestService_SetBundleUpvote(t *testing.T) {
@@ -146,10 +146,10 @@ func TestService_SetBundleUpvote(t *testing.T) {
 
 		producer := &fakeProducer{}
 		m6id := m6idA
-		_, err := newClient(t, producer).SetBundleUpvote(t.Context(), connect.NewRequest(&m4pb.SetBundleUpvoteRequest{
+		_, err := newClient(t, producer).SetBundleUpvote(t.Context(), &m4pb.SetBundleUpvoteRequest{
 			SidechainSlot: 9,
 			M6Id:          &m6id,
-		}))
+		})
 		require.NoError(t, err)
 		assert.Equal(t, []string{"9:aa"}, upvoted(producer))
 	})
@@ -159,10 +159,10 @@ func TestService_SetBundleUpvote(t *testing.T) {
 
 		producer := &fakeProducer{acks: []*mainchainv1.WithdrawalBundleAck{ack(9, m6idA), ack(2, m6idB)}}
 		m6id := m6idB
-		_, err := newClient(t, producer).SetBundleUpvote(t.Context(), connect.NewRequest(&m4pb.SetBundleUpvoteRequest{
+		_, err := newClient(t, producer).SetBundleUpvote(t.Context(), &m4pb.SetBundleUpvoteRequest{
 			SidechainSlot: 9,
 			M6Id:          &m6id,
-		}))
+		})
 		require.NoError(t, err)
 		assert.ElementsMatch(t, []string{"2:bb", "9:bb"}, upvoted(producer))
 	})
@@ -176,10 +176,10 @@ func TestService_SetBundleUpvote(t *testing.T) {
 		for i := range 20 {
 			m6id := []string{m6idA, m6idB}[i%2]
 			wg.Go(func() {
-				_, err := cli.SetBundleUpvote(t.Context(), connect.NewRequest(&m4pb.SetBundleUpvoteRequest{
+				_, err := cli.SetBundleUpvote(t.Context(), &m4pb.SetBundleUpvoteRequest{
 					SidechainSlot: 9,
 					M6Id:          &m6id,
-				}))
+				})
 				assert.NoError(t, err)
 			})
 		}
@@ -191,9 +191,9 @@ func TestService_SetBundleUpvote(t *testing.T) {
 		t.Parallel()
 
 		producer := &fakeProducer{acks: []*mainchainv1.WithdrawalBundleAck{ack(9, m6idA), ack(2, m6idB)}}
-		_, err := newClient(t, producer).SetBundleUpvote(t.Context(), connect.NewRequest(&m4pb.SetBundleUpvoteRequest{
+		_, err := newClient(t, producer).SetBundleUpvote(t.Context(), &m4pb.SetBundleUpvoteRequest{
 			SidechainSlot: 9,
-		}))
+		})
 		require.NoError(t, err)
 		assert.Equal(t, []string{"2:bb"}, upvoted(producer))
 	})
@@ -202,19 +202,19 @@ func TestService_SetBundleUpvote(t *testing.T) {
 		t.Parallel()
 
 		m6id := "bundle-a"
-		_, err := newClient(t, &fakeProducer{}).SetBundleUpvote(t.Context(), connect.NewRequest(&m4pb.SetBundleUpvoteRequest{
+		_, err := newClient(t, &fakeProducer{}).SetBundleUpvote(t.Context(), &m4pb.SetBundleUpvoteRequest{
 			SidechainSlot: 9,
 			M6Id:          &m6id,
-		}))
+		})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 
 	t.Run("rejects a slot above 255", func(t *testing.T) {
 		t.Parallel()
 
-		_, err := newClient(t, &fakeProducer{}).SetBundleUpvote(t.Context(), connect.NewRequest(&m4pb.SetBundleUpvoteRequest{
+		_, err := newClient(t, &fakeProducer{}).SetBundleUpvote(t.Context(), &m4pb.SetBundleUpvoteRequest{
 			SidechainSlot: 256,
-		}))
+		})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 }
@@ -226,9 +226,9 @@ func TestService_SetVotePolicy(t *testing.T) {
 		t.Parallel()
 
 		producer := &fakeProducer{}
-		_, err := newClient(t, producer).SetVotePolicy(t.Context(), connect.NewRequest(&m4pb.SetVotePolicyRequest{
+		_, err := newClient(t, producer).SetVotePolicy(t.Context(), &m4pb.SetVotePolicyRequest{
 			Policy: m4pb.VotePolicy_VOTE_POLICY_UPVOTE_ALL,
-		}))
+		})
 		require.NoError(t, err)
 		assert.Equal(t, mainchainv1.WithdrawalBundlePolicy_WITHDRAWAL_BUNDLE_POLICY_ALL, producer.policy)
 	})
@@ -236,7 +236,7 @@ func TestService_SetVotePolicy(t *testing.T) {
 	t.Run("rejects an unspecified policy", func(t *testing.T) {
 		t.Parallel()
 
-		_, err := newClient(t, &fakeProducer{}).SetVotePolicy(t.Context(), connect.NewRequest(&m4pb.SetVotePolicyRequest{}))
+		_, err := newClient(t, &fakeProducer{}).SetVotePolicy(t.Context(), &m4pb.SetVotePolicyRequest{})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 }
diff --git a/bitwindow/server/api/misc/misc.go b/bitwindow/server/api/misc/misc.go
index 06014147eb..615e969aa2 100644
--- a/bitwindow/server/api/misc/misc.go
+++ b/bitwindow/server/api/misc/misc.go
@@ -8,7 +8,8 @@ import (
 	"math"
 	"strings"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
@@ -60,15 +61,15 @@ type Server struct {
 const listOPReturnLimit = 1000
 
 // ListOPReturn implements miscv1connect.MiscServiceHandler.
-func (s *Server) ListOPReturn(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[miscv1.ListOPReturnResponse], error) {
+func (s *Server) ListOPReturn(ctx context.Context, req *emptypb.Empty) (*miscv1.ListOPReturnResponse, error) {
 	opReturns, err := opreturns.List(ctx, s.database, listOPReturnLimit)
 	if err != nil {
 		return nil, err
 	}
 
-	return connect.NewResponse(&miscv1.ListOPReturnResponse{
+	return &miscv1.ListOPReturnResponse{
 		OpReturns: lo.Map(opReturns, opReturnToProto),
-	}), nil
+	}, nil
 }
 
 func opReturnToProto(opReturn opreturns.OPReturn, _ int) *miscv1.OPReturn {
@@ -87,23 +88,23 @@ func opReturnToProto(opReturn opreturns.OPReturn, _ int) *miscv1.OPReturn {
 }
 
 // BroadcastNews implements miscv1connect.MiscServiceHandler.
-func (s *Server) BroadcastNews(ctx context.Context, req *connect.Request[miscv1.BroadcastNewsRequest]) (*connect.Response[miscv1.BroadcastNewsResponse], error) {
-	if req.Msg.Topic == "" {
+func (s *Server) BroadcastNews(ctx context.Context, req *miscv1.BroadcastNewsRequest) (*miscv1.BroadcastNewsResponse, error) {
+	if req.Topic == "" {
 		err := errors.New("topic must be set")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	topicID, err := opreturns.ValidNewsTopicID(req.Msg.Topic)
+	topicID, err := opreturns.ValidNewsTopicID(req.Topic)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	if strings.TrimSpace(req.Msg.Headline) == "" {
+	if strings.TrimSpace(req.Headline) == "" {
 		err := errors.New("headline must be set")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	if len([]byte(req.Msg.Headline)) > 64 {
+	if len([]byte(req.Headline)) > 64 {
 		err := errors.New("headline cannot be longer than 64 bytes")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	exists, err := opreturns.TopicExists(ctx, s.database, topicID)
 	if err != nil {
@@ -111,20 +112,20 @@ func (s *Server) BroadcastNews(ctx context.Context, req *connect.Request[miscv1.
 	}
 	if !exists {
 		err := errors.New("topic does not exist")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	storyBytes, err := opreturns.EncodeNewsMessageWithOptions(topicID, req.Msg.Headline, req.Msg.Content, opreturns.StoryOptions{
-		URL:     req.Msg.Url,
-		Lang:    req.Msg.Lang,
-		Subtype: req.Msg.Subtype,
-		NSFW:    req.Msg.Nsfw,
+	storyBytes, err := opreturns.EncodeNewsMessageWithOptions(topicID, req.Headline, req.Content, opreturns.StoryOptions{
+		URL:     req.Url,
+		Lang:    req.Lang,
+		Subtype: req.Subtype,
+		NSFW:    req.Nsfw,
 	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	txid, err := s.walletEngine.BroadcastOpReturn(ctx, storyBytes, req.Msg.FeeSatPerVbyte, req.Msg.FeeSats)
+	txid, err := s.walletEngine.BroadcastOpReturn(ctx, storyBytes, req.FeeSatPerVbyte, req.FeeSats)
 	if err != nil {
 		return nil, fmt.Errorf("broadcast news: %w", err)
 	}
@@ -132,40 +133,40 @@ func (s *Server) BroadcastNews(ctx context.Context, req *connect.Request[miscv1.
 	log := zerolog.Ctx(ctx)
 	log.Info().
 		Hex("topic", topicID[:]).
-		Str("headline", req.Msg.Headline).
+		Str("headline", req.Headline).
 		Str("txid", txid).
 		Msg("broadcast news transaction")
 
-	return connect.NewResponse(&miscv1.BroadcastNewsResponse{
+	return &miscv1.BroadcastNewsResponse{
 		Txid: txid,
-	}), nil
+	}, nil
 }
 
 // UpvoteNews implements miscv1connect.MiscServiceHandler. It signs a
 // CoinNews Vote (kind=0x04) over the target story with this node's
 // identity key and broadcasts it as an OP_RETURN.
-func (s *Server) UpvoteNews(ctx context.Context, req *connect.Request[miscv1.UpvoteNewsRequest]) (*connect.Response[miscv1.UpvoteNewsResponse], error) {
-	return s.broadcastVote(ctx, req.Msg, codec.TypeUpvote)
+func (s *Server) UpvoteNews(ctx context.Context, req *miscv1.UpvoteNewsRequest) (*miscv1.UpvoteNewsResponse, error) {
+	return s.broadcastVote(ctx, req, codec.TypeUpvote)
 }
 
 // DownvoteNews implements miscv1connect.MiscServiceHandler. Same as
 // UpvoteNews but signs a downvote (kind=0x05).
-func (s *Server) DownvoteNews(ctx context.Context, req *connect.Request[miscv1.UpvoteNewsRequest]) (*connect.Response[miscv1.UpvoteNewsResponse], error) {
-	return s.broadcastVote(ctx, req.Msg, codec.TypeDownvote)
+func (s *Server) DownvoteNews(ctx context.Context, req *miscv1.UpvoteNewsRequest) (*miscv1.UpvoteNewsResponse, error) {
+	return s.broadcastVote(ctx, req, codec.TypeDownvote)
 }
 
 func parseItemID(hexID, field string) (codec.ItemID, error) {
 	id, err := codec.ParseItemID(hexID)
 	if err != nil {
 		return codec.ItemID{}, connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("%s must be %d-byte hex: %w", field, codec.ItemIDLen, err))
+			fmt.Sprintf("%s must be %d-byte hex: %s", field, codec.ItemIDLen, err)).WithCause(err)
 	}
 	return id, nil
 }
 
 // broadcastVote signs a CoinNews Vote of the given kind over the target
 // story with this node's identity key and broadcasts it as an OP_RETURN.
-func (s *Server) broadcastVote(ctx context.Context, req *miscv1.UpvoteNewsRequest, kind codec.TypeTag) (*connect.Response[miscv1.UpvoteNewsResponse], error) {
+func (s *Server) broadcastVote(ctx context.Context, req *miscv1.UpvoteNewsRequest, kind codec.TypeTag) (*miscv1.UpvoteNewsResponse, error) {
 	target, err := parseItemID(req.ItemId, "item_id")
 	if err != nil {
 		return nil, err
@@ -200,30 +201,30 @@ func (s *Server) broadcastVote(ctx context.Context, req *miscv1.UpvoteNewsReques
 		Str("txid", txid).
 		Msg("broadcast vote transaction")
 
-	return connect.NewResponse(&miscv1.UpvoteNewsResponse{
+	return &miscv1.UpvoteNewsResponse{
 		Txid: txid,
-	}), nil
+	}, nil
 }
 
 // EstimateNewsFee implements miscv1connect.MiscServiceHandler. It encodes the
 // payload the action would broadcast and prices the transaction that holds it.
-func (s *Server) EstimateNewsFee(ctx context.Context, req *connect.Request[miscv1.EstimateNewsFeeRequest]) (*connect.Response[miscv1.EstimateNewsFeeResponse], error) {
-	payload, err := newsPayloadFor(req.Msg)
+func (s *Server) EstimateNewsFee(ctx context.Context, req *miscv1.EstimateNewsFeeRequest) (*miscv1.EstimateNewsFeeResponse, error) {
+	payload, err := newsPayloadFor(req)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	rate, err := s.walletEngine.EstimateFeeRate(ctx, 6)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("estimate fee rate: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Sprintf("estimate fee rate: %s", err)).WithCause(err)
 	}
 
 	vsize := engines.OpReturnTxVbytes(len(payload))
-	return connect.NewResponse(&miscv1.EstimateNewsFeeResponse{
+	return &miscv1.EstimateNewsFeeResponse{
 		Vsize:          vsize,
 		FeeSatPerVbyte: rate,
 		FeeSats:        uint64(math.Ceil(float64(vsize) * rate)),
-	}), nil
+	}, nil
 }
 
 // newsPayloadFor encodes the exact bytes the action would put in the OP_RETURN.
@@ -258,18 +259,18 @@ func newsPayloadFor(req *miscv1.EstimateNewsFeeRequest) ([]byte, error) {
 }
 
 // CreateTopic implements miscv1connect.MiscServiceHandler.
-func (s *Server) CreateTopic(ctx context.Context, req *connect.Request[miscv1.CreateTopicRequest]) (*connect.Response[miscv1.CreateTopicResponse], error) {
-	topicID, err := opreturns.ValidNewsTopicID(req.Msg.Topic)
+func (s *Server) CreateTopic(ctx context.Context, req *miscv1.CreateTopicRequest) (*miscv1.CreateTopicResponse, error) {
+	topicID, err := opreturns.ValidNewsTopicID(req.Topic)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	if req.Msg.Name == "" {
+	if req.Name == "" {
 		err := errors.New("title must be set")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	if len([]byte(req.Msg.Name)) > 64 {
+	if len([]byte(req.Name)) > 64 {
 		err := errors.New("title cannot be longer than 64 bytes")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	exists, err := opreturns.TopicExists(ctx, s.database, topicID)
@@ -279,18 +280,18 @@ func (s *Server) CreateTopic(ctx context.Context, req *connect.Request[miscv1.Cr
 
 	if exists {
 		err := errors.New("topic already exists")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// Calculate retention days (default to 7)
-	retentionDays := req.Msg.RetentionDays
+	retentionDays := req.RetentionDays
 	if retentionDays == 0 {
 		retentionDays = 7 // Default to 7 days
 	}
 
-	topicCreationBytes, err := opreturns.EncodeTopicCreationMessageNewFormat(topicID, req.Msg.Name, retentionDays)
+	topicCreationBytes, err := opreturns.EncodeTopicCreationMessageNewFormat(topicID, req.Name, retentionDays)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	txid, err := s.walletEngine.BroadcastOpReturn(ctx, topicCreationBytes, 0, 0)
 	if err != nil {
@@ -300,25 +301,25 @@ func (s *Server) CreateTopic(ctx context.Context, req *connect.Request[miscv1.Cr
 	log := zerolog.Ctx(ctx)
 	log.Info().
 		Stringer("topic", topicID).
-		Str("title", req.Msg.Name).
+		Str("title", req.Name).
 		Str("txid", txid).
 		Msg("broadcast create topic transaction")
 
-	return connect.NewResponse(&miscv1.CreateTopicResponse{
+	return &miscv1.CreateTopicResponse{
 		Txid: txid,
-	}), nil
+	}, nil
 }
 
 // ListTopics implements miscv1connect.MiscServiceHandler.
-func (s *Server) ListTopics(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[miscv1.ListTopicsResponse], error) {
+func (s *Server) ListTopics(ctx context.Context, req *emptypb.Empty) (*miscv1.ListTopicsResponse, error) {
 	topics, err := opreturns.ListTopics(ctx, s.database)
 	if err != nil {
 		return nil, err
 	}
 
-	return connect.NewResponse(&miscv1.ListTopicsResponse{
+	return &miscv1.ListTopicsResponse{
 		Topics: lo.Map(topics, topicToProto),
-	}), nil
+	}, nil
 }
 
 func topicToProto(topic opreturns.Topic, _ int) *miscv1.Topic {
@@ -334,16 +335,16 @@ func topicToProto(topic opreturns.Topic, _ int) *miscv1.Topic {
 }
 
 // ListCoinNews implements miscv1connect.MiscServiceHandler.
-func (s *Server) ListCoinNews(ctx context.Context, req *connect.Request[miscv1.ListCoinNewsRequest]) (*connect.Response[miscv1.ListCoinNewsResponse], error) {
+func (s *Server) ListCoinNews(ctx context.Context, req *miscv1.ListCoinNewsRequest) (*miscv1.ListCoinNewsResponse, error) {
 	var topicID opreturns.TopicID
-	if req.Msg.Topic != nil {
+	if req.Topic != nil {
 		var err error
-		topicID, err = opreturns.ValidNewsTopicID(*req.Msg.Topic)
+		topicID, err = opreturns.ValidNewsTopicID(*req.Topic)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 	}
-	res, err := s.listRemoteCoinNews(ctx, req.Msg.Topic)
+	res, err := s.listRemoteCoinNews(ctx, req.Topic)
 	// No published indexer for this network, so the local index answers.
 	if !errors.Is(err, engines.ErrNoIndexer) {
 		return res, err
@@ -355,7 +356,7 @@ func (s *Server) ListCoinNews(ctx context.Context, req *connect.Request[miscv1.L
 	}
 
 	// Filter by topic if provided
-	if req.Msg.Topic != nil {
+	if req.Topic != nil {
 		news = lo.Filter(news, func(coinNews opreturns.CoinNews, _ int) bool {
 			return coinNews.Topic == topicID
 		})
@@ -367,14 +368,14 @@ func (s *Server) ListCoinNews(ctx context.Context, req *connect.Request[miscv1.L
 		news = news[:100]
 	}
 
-	return connect.NewResponse(&miscv1.ListCoinNewsResponse{
+	return &miscv1.ListCoinNewsResponse{
 		CoinNews: lo.Map(news, coinNewsToProto),
-	}), nil
+	}, nil
 }
 
 // listRemoteCoinNews serves the feed straight from the network's indexer.
 // The indexer already ranks and decodes, so nothing is re-parsed here.
-func (s *Server) listRemoteCoinNews(ctx context.Context, topic *string) (*connect.Response[miscv1.ListCoinNewsResponse], error) {
+func (s *Server) listRemoteCoinNews(ctx context.Context, topic *string) (*miscv1.ListCoinNewsResponse, error) {
 	var topicHex string
 	if topic != nil {
 		// already validated as four-byte hex by the caller
@@ -383,7 +384,7 @@ func (s *Server) listRemoteCoinNews(ctx context.Context, topic *string) (*connec
 
 	items, err := s.remoteCoinNews.ListFrontPage(ctx, topicHex, 100)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read coin news indexer: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Sprintf("read coin news indexer: %s", err)).WithCause(err)
 	}
 
 	out := make([]*miscv1.CoinNews, len(items))
@@ -404,7 +405,7 @@ func (s *Server) listRemoteCoinNews(ctx context.Context, topic *string) (*connec
 			Vout:       item.Vout,
 		}
 	}
-	return connect.NewResponse(&miscv1.ListCoinNewsResponse{CoinNews: out}), nil
+	return &miscv1.ListCoinNewsResponse{CoinNews: out}, nil
 }
 
 func coinNewsToProto(coinNews opreturns.CoinNews, _ int) *miscv1.CoinNews {
@@ -433,15 +434,15 @@ func coinNewsToProto(coinNews opreturns.CoinNews, _ int) *miscv1.CoinNews {
 // CoinNews Comment (0x03) on the parent Item with this node's identity
 // key and broadcasts it as an OP_RETURN. The body and optional url/lang/
 // reply_quote ride in the trailing TLV section (spec §7, §10).
-func (s *Server) CommentNews(ctx context.Context, req *connect.Request[miscv1.CommentNewsRequest]) (*connect.Response[miscv1.CommentNewsResponse], error) {
-	parent, err := parseItemID(req.Msg.ParentId, "parent_id")
+func (s *Server) CommentNews(ctx context.Context, req *miscv1.CommentNewsRequest) (*miscv1.CommentNewsResponse, error) {
+	parent, err := parseItemID(req.ParentId, "parent_id")
 	if err != nil {
 		return nil, err
 	}
 
-	if strings.TrimSpace(req.Msg.Body) == "" && req.Msg.Url == "" {
+	if strings.TrimSpace(req.Body) == "" && req.Url == "" {
 		err := errors.New("comment must have a body or url")
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	priv, xpk, err := cnstore.LoadOrCreateIdentity(ctx, s.database)
@@ -449,7 +450,7 @@ func (s *Server) CommentNews(ctx context.Context, req *connect.Request[miscv1.Co
 		return nil, fmt.Errorf("comment news: load identity: %w", err)
 	}
 
-	tlvs := commentTLVs(req.Msg)
+	tlvs := commentTLVs(req)
 	blob, err := codec.SerialiseTLVs(tlvs)
 	if err != nil {
 		return nil, fmt.Errorf("comment news: serialise tlvs: %w", err)
@@ -467,19 +468,19 @@ func (s *Server) CommentNews(ctx context.Context, req *connect.Request[miscv1.Co
 		return nil, fmt.Errorf("comment news: encode comment: %w", err)
 	}
 
-	txid, err := s.walletEngine.BroadcastOpReturn(ctx, commentBytes, req.Msg.FeeSatPerVbyte, req.Msg.FeeSats)
+	txid, err := s.walletEngine.BroadcastOpReturn(ctx, commentBytes, req.FeeSatPerVbyte, req.FeeSats)
 	if err != nil {
 		return nil, fmt.Errorf("comment news: %w", err)
 	}
 
 	zerolog.Ctx(ctx).Info().
-		Str("parent_id", req.Msg.ParentId).
+		Str("parent_id", req.ParentId).
 		Str("txid", txid).
 		Msg("broadcast comment transaction")
 
-	return connect.NewResponse(&miscv1.CommentNewsResponse{
+	return &miscv1.CommentNewsResponse{
 		Txid: txid,
-	}), nil
+	}, nil
 }
 
 // commentTLVs builds the trailing TLV section for a comment from the
@@ -503,8 +504,8 @@ func commentTLVs(req *miscv1.CommentNewsRequest) []codec.TLV {
 }
 
 // ListComments implements miscv1connect.MiscServiceHandler.
-func (s *Server) ListComments(ctx context.Context, req *connect.Request[miscv1.ListCommentsRequest]) (*connect.Response[miscv1.ListCommentsResponse], error) {
-	root, err := parseItemID(req.Msg.ItemId, "item_id")
+func (s *Server) ListComments(ctx context.Context, req *miscv1.ListCommentsRequest) (*miscv1.ListCommentsResponse, error) {
+	root, err := parseItemID(req.ItemId, "item_id")
 	if err != nil {
 		return nil, err
 	}
@@ -513,9 +514,9 @@ func (s *Server) ListComments(ctx context.Context, req *connect.Request[miscv1.L
 	if err != nil {
 		return nil, fmt.Errorf("list comments: %w", err)
 	}
-	return connect.NewResponse(&miscv1.ListCommentsResponse{
+	return &miscv1.ListCommentsResponse{
 		Comments: lo.Map(comments, commentToProto),
-	}), nil
+	}, nil
 }
 
 func commentToProto(c cnstore.Comment, _ int) *miscv1.Comment {
@@ -535,15 +536,15 @@ func commentToProto(c cnstore.Comment, _ int) *miscv1.Comment {
 }
 
 // TimestampFile implements miscv1connect.MiscServiceHandler.
-func (s *Server) TimestampFile(ctx context.Context, req *connect.Request[miscv1.TimestampFileRequest]) (*connect.Response[miscv1.TimestampFileResponse], error) {
-	if req.Msg.Filename == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("filename must be set"))
+func (s *Server) TimestampFile(ctx context.Context, req *miscv1.TimestampFileRequest) (*miscv1.TimestampFileResponse, error) {
+	if req.Filename == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "filename must be set")
 	}
-	if len(req.Msg.FileData) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("file data must be set"))
+	if len(req.FileData) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "file data must be set")
 	}
 
-	ts, err := s.timestampEngine.TimestampFile(ctx, req.Msg.Filename, req.Msg.FileData)
+	ts, err := s.timestampEngine.TimestampFile(ctx, req.Filename, req.FileData)
 	if err != nil {
 		return nil, fmt.Errorf("timestamp file: %w", err)
 	}
@@ -553,15 +554,15 @@ func (s *Server) TimestampFile(ctx context.Context, req *connect.Request[miscv1.
 		txid = *ts.TxID
 	}
 
-	return connect.NewResponse(&miscv1.TimestampFileResponse{
+	return &miscv1.TimestampFileResponse{
 		Id:       ts.ID,
 		FileHash: ts.FileHash,
 		Txid:     txid,
-	}), nil
+	}, nil
 }
 
 // ListTimestamps implements miscv1connect.MiscServiceHandler.
-func (s *Server) ListTimestamps(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[miscv1.ListTimestampsResponse], error) {
+func (s *Server) ListTimestamps(ctx context.Context, req *emptypb.Empty) (*miscv1.ListTimestampsResponse, error) {
 	tsList, err := s.timestampEngine.ListTimestamps(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("list timestamps: %w", err)
@@ -572,11 +573,11 @@ func (s *Server) ListTimestamps(ctx context.Context, req *connect.Request[emptyp
 		return nil, err
 	}
 
-	return connect.NewResponse(&miscv1.ListTimestampsResponse{
+	return &miscv1.ListTimestampsResponse{
 		Timestamps: lo.Map(tsList, func(ts timestamps.FileTimestamp, _ int) *miscv1.FileTimestamp {
 			return timestampToProto(ts, currentBlockHeight)
 		}),
-	}), nil
+	}, nil
 }
 
 func timestampToProto(ts timestamps.FileTimestamp, currentBlockHeight int64) *miscv1.FileTimestamp {
@@ -605,28 +606,28 @@ func timestampToProto(ts timestamps.FileTimestamp, currentBlockHeight int64) *mi
 }
 
 // VerifyTimestamp implements miscv1connect.MiscServiceHandler.
-func (s *Server) VerifyTimestamp(ctx context.Context, req *connect.Request[miscv1.VerifyTimestampRequest]) (*connect.Response[miscv1.VerifyTimestampResponse], error) {
-	if len(req.Msg.FileData) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("file data must be set"))
+func (s *Server) VerifyTimestamp(ctx context.Context, req *miscv1.VerifyTimestampRequest) (*miscv1.VerifyTimestampResponse, error) {
+	if len(req.FileData) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "file data must be set")
 	}
 
 	filename := ""
-	if req.Msg.Filename != nil {
-		filename = *req.Msg.Filename
+	if req.Filename != nil {
+		filename = *req.Filename
 	}
 
-	ts, err := s.timestampEngine.VerifyTimestamp(ctx, req.Msg.FileData, filename)
+	ts, err := s.timestampEngine.VerifyTimestamp(ctx, req.FileData, filename)
 	switch {
 	case errors.Is(err, engines.ErrTimestampNotFound):
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("verify timestamp: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("verify timestamp: %s", err)).WithCause(err)
 	}
 	if ts.Status == timestamps.StatusFailed {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("the timestamp transaction failed"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "the timestamp transaction failed")
 	}
 	if ts.Status != timestamps.StatusConfirmed {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("the timestamp is not confirmed yet"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "the timestamp is not confirmed yet")
 	}
 
 	currentBlockHeight, err := s.getCurrentBlockHeight(ctx)
@@ -634,10 +635,10 @@ func (s *Server) VerifyTimestamp(ctx context.Context, req *connect.Request[miscv
 		return nil, err
 	}
 
-	return connect.NewResponse(&miscv1.VerifyTimestampResponse{
+	return &miscv1.VerifyTimestampResponse{
 		Timestamp: timestampToProto(*ts, currentBlockHeight),
 		Message:   fmt.Sprintf("File verified! Transaction: %s", *ts.TxID),
-	}), nil
+	}, nil
 }
 
 // getCurrentBlockHeight gives 0 in light mode, which runs no local Bitcoin Core.
@@ -649,7 +650,7 @@ func (s *Server) getCurrentBlockHeight(ctx context.Context) (int64, error) {
 	if err != nil {
 		return 0, err
 	}
-	info, err := bitcoind.GetBlockchainInfo(ctx, &connect.Request[corepb.GetBlockchainInfoRequest]{})
+	info, err := bitcoind.GetBlockchainInfo(ctx, &connectv1.Request[corepb.GetBlockchainInfoRequest]{})
 	if err != nil {
 		return 0, fmt.Errorf("get blockchain info: %w", err)
 	}
diff --git a/bitwindow/server/api/misc/misc_test.go b/bitwindow/server/api/misc/misc_test.go
index 88e2b26611..fb016ebac5 100644
--- a/bitwindow/server/api/misc/misc_test.go
+++ b/bitwindow/server/api/misc/misc_test.go
@@ -12,7 +12,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
@@ -39,11 +40,11 @@ func TestService_ListOPReturn(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListOPReturn(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListOPReturn(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.OpReturns)
+		assert.Empty(t, resp.OpReturns)
 	})
 
 	t.Run("list op returns with data", func(t *testing.T) {
@@ -63,15 +64,15 @@ func TestService_ListOPReturn(t *testing.T) {
 		})
 		require.NoError(t, err)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListOPReturn(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListOPReturn(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.OpReturns, 1)
-		assert.Equal(t, "test message", resp.Msg.OpReturns[0].Message)
-		assert.Equal(t, "txid1", resp.Msg.OpReturns[0].Txid)
-		assert.EqualValues(t, 0, resp.Msg.OpReturns[0].Vout)
-		assert.EqualValues(t, 100, lo.FromPtr(resp.Msg.OpReturns[0].Height))
+		require.Len(t, resp.OpReturns, 1)
+		assert.Equal(t, "test message", resp.OpReturns[0].Message)
+		assert.Equal(t, "txid1", resp.OpReturns[0].Txid)
+		assert.EqualValues(t, 0, resp.OpReturns[0].Vout)
+		assert.EqualValues(t, 100, lo.FromPtr(resp.OpReturns[0].Height))
 	})
 }
 
@@ -87,37 +88,35 @@ func TestService_BroadcastNews(t *testing.T) {
 
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "test-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "test-txid"}, nil)
 
 		database := database.Test(t)
 		ctx := t.Context()
 		topicID := validTopicID()
 		seedCurrentTopic(t, ctx, database, topicID, "Test Topic", 50)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
-		resp, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		resp, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    topicID.String(),
 			Headline: "Test News Headline",
 			Content:  "https://example.com/news",
-		}))
+		})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Txid)
 	})
 
 	t.Run("broadcast news with empty topic", func(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		_, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    "",
 			Headline: "Test News Headline",
 			Content:  "https://example.com/news",
-		}))
+		})
 		require.ErrorContains(t, err, "topic must be set")
 	})
 
@@ -125,13 +124,13 @@ func TestService_BroadcastNews(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		_, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    "123456", // Too short, should be 8 hex characters (4 bytes)
 			Headline: "Test News Headline",
 			Content:  "https://example.com/news",
-		}))
+		})
 		require.ErrorContains(t, err, "is not 4 bytes")
 	})
 
@@ -145,13 +144,13 @@ func TestService_BroadcastNews(t *testing.T) {
 		topicID := validTopicID()
 		seedCurrentTopic(t, ctx, database, topicID, "Test Topic", 50)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		_, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    topicID.String(),
 			Headline: "",
 			Content:  "https://example.com/news",
-		}))
+		})
 		require.ErrorContains(t, err, "headline must be set")
 	})
 
@@ -163,17 +162,17 @@ func TestService_BroadcastNews(t *testing.T) {
 		topicID := validTopicID()
 		seedCurrentTopic(t, ctx, database, topicID, "Test Topic", 50)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
 		// Whitespace-only headlines previously passed validation, got
 		// stored as spaces, and rendered blank in the UI Title column.
 		for _, h := range []string{"   ", "\t", "\n", " \t "} {
 			t.Run(fmt.Sprintf("%q", h), func(t *testing.T) {
-				_, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+				_, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 					Topic:    topicID.String(),
 					Headline: h,
 					Content:  "content",
-				}))
+				})
 				require.ErrorContains(t, err, "headline must be set")
 			})
 		}
@@ -188,14 +187,14 @@ func TestService_BroadcastNews(t *testing.T) {
 		topicID := validTopicID()
 		seedCurrentTopic(t, ctx, database, topicID, "Test Topic", 50)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
 		longHeadline := strings.Repeat("a", 65) // 65 characters, exceeds 64 limit
-		_, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		_, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    topicID.String(),
 			Headline: longHeadline,
 			Content:  "https://example.com/news",
-		}))
+		})
 		require.ErrorContains(t, err, "headline cannot be longer than 64 bytes")
 	})
 
@@ -203,13 +202,13 @@ func TestService_BroadcastNews(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		_, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    "87654321", // Non-existent topic (4 bytes)
 			Headline: "Test News Headline",
 			Content:  "https://example.com/news",
-		}))
+		})
 		require.ErrorContains(t, err, "topic does not exist")
 	})
 
@@ -224,23 +223,21 @@ func TestService_BroadcastNews(t *testing.T) {
 
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "test-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "test-txid"}, nil)
 
 		database := database.Test(t)
 		ctx := t.Context()
 		seedCurrentTopic(t, ctx, database, topicID, "Test Topic", 50)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
-		resp, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		resp, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    topicID.String(),
 			Headline: "Test News Headline",
 			Content:  "This is the news content",
-		}))
+		})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Txid)
 	})
 
 	t.Run("broadcast news with hex content", func(t *testing.T) {
@@ -252,25 +249,23 @@ func TestService_BroadcastNews(t *testing.T) {
 
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "test-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "test-txid"}, nil)
 
 		database := database.Test(t)
 		ctx := t.Context()
 		topicID := validTopicID()
 		seedCurrentTopic(t, ctx, database, topicID, "Test Topic", 50)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
 		hexContent := hex.EncodeToString([]byte("hex content"))
-		resp, err := cli.BroadcastNews(t.Context(), connect.NewRequest(&miscv1.BroadcastNewsRequest{
+		resp, err := cli.BroadcastNews(t.Context(), &miscv1.BroadcastNewsRequest{
 			Topic:    topicID.String(),
 			Headline: "Test News Headline",
 			Content:  hexContent,
-		}))
+		})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Txid)
 	})
 }
 
@@ -285,70 +280,68 @@ func TestService_VotesAndComments(t *testing.T) {
 		apitests.ExpectOrchestratorReads(mockOrch)
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "test-txid"},
-			}, nil).AnyTimes()
+			Return(&orchpb.SendTransactionResponse{Txid: "test-txid"}, nil).AnyTimes()
 		return mockOrch
 	}
 
 	t.Run("upvote success", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(walletReturningTxid(t))))
-		resp, err := cli.UpvoteNews(t.Context(), connect.NewRequest(&miscv1.UpvoteNewsRequest{ItemId: validItemID}))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(walletReturningTxid(t))))
+		resp, err := cli.UpvoteNews(t.Context(), &miscv1.UpvoteNewsRequest{ItemId: validItemID})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Txid)
 	})
 
 	t.Run("downvote success", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(walletReturningTxid(t))))
-		resp, err := cli.DownvoteNews(t.Context(), connect.NewRequest(&miscv1.UpvoteNewsRequest{ItemId: validItemID}))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(walletReturningTxid(t))))
+		resp, err := cli.DownvoteNews(t.Context(), &miscv1.UpvoteNewsRequest{ItemId: validItemID})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Txid)
 	})
 
 	t.Run("vote rejects malformed item_id", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t)))
-		_, err := cli.UpvoteNews(t.Context(), connect.NewRequest(&miscv1.UpvoteNewsRequest{ItemId: "nothex"}))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t)))
+		_, err := cli.UpvoteNews(t.Context(), &miscv1.UpvoteNewsRequest{ItemId: "nothex"})
 		require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		assert.Contains(t, err.Error(), "item_id must be")
 	})
 
 	t.Run("comment rejects a short parent_id", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t)))
-		_, err := cli.CommentNews(t.Context(), connect.NewRequest(&miscv1.CommentNewsRequest{ParentId: "abcd", Body: "hi"}))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t)))
+		_, err := cli.CommentNews(t.Context(), &miscv1.CommentNewsRequest{ParentId: "abcd", Body: "hi"})
 		require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		assert.Contains(t, err.Error(), "parent_id must be")
 	})
 
 	t.Run("list comments rejects a malformed item_id", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t)))
-		_, err := cli.ListComments(t.Context(), connect.NewRequest(&miscv1.ListCommentsRequest{ItemId: "nothex"}))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t)))
+		_, err := cli.ListComments(t.Context(), &miscv1.ListCommentsRequest{ItemId: "nothex"})
 		require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		assert.Contains(t, err.Error(), "item_id must be")
 	})
 
 	t.Run("comment success", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(walletReturningTxid(t))))
-		resp, err := cli.CommentNews(t.Context(), connect.NewRequest(&miscv1.CommentNewsRequest{
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(walletReturningTxid(t))))
+		resp, err := cli.CommentNews(t.Context(), &miscv1.CommentNewsRequest{
 			ParentId: validItemID,
 			Body:     "great article",
-		}))
+		})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Txid)
 	})
 
 	t.Run("comment rejects empty body and url", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t)))
-		_, err := cli.CommentNews(t.Context(), connect.NewRequest(&miscv1.CommentNewsRequest{
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t)))
+		_, err := cli.CommentNews(t.Context(), &miscv1.CommentNewsRequest{
 			ParentId: validItemID,
 			Body:     "  ",
-		}))
+		})
 		require.ErrorContains(t, err, "body or url")
 	})
 
@@ -358,16 +351,16 @@ func TestService_VotesAndComments(t *testing.T) {
 		apitests.ExpectOrchestratorReads(mockOrch)
 		mockOrch.EXPECT().
 			EstimateFee(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.EstimateFeeResponse{SatPerVbyte: 1}), nil).
+			Return(&orchpb.EstimateFeeResponse{SatPerVbyte: 1}, nil).
 			AnyTimes()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
 
-		estimate := func(body, url string) (*connect.Response[miscv1.EstimateNewsFeeResponse], error) {
-			return cli.EstimateNewsFee(t.Context(), connect.NewRequest(&miscv1.EstimateNewsFeeRequest{
+		estimate := func(body, url string) (*miscv1.EstimateNewsFeeResponse, error) {
+			return cli.EstimateNewsFee(t.Context(), &miscv1.EstimateNewsFeeRequest{
 				Action: miscv1.NewsAction_NEWS_ACTION_COMMENT,
 				Body:   body,
 				Url:    url,
-			}))
+			})
 		}
 
 		urlOnly, err := estimate("", "https://example.com/a")
@@ -376,8 +369,8 @@ func TestService_VotesAndComments(t *testing.T) {
 		require.NoError(t, err)
 		both, err := estimate("hi", "https://example.com/a")
 		require.NoError(t, err)
-		assert.Greater(t, both.Msg.Vsize, bodyOnly.Msg.Vsize)
-		assert.Greater(t, both.Msg.Vsize, urlOnly.Msg.Vsize)
+		assert.Greater(t, both.Vsize, bodyOnly.Vsize)
+		assert.Greater(t, both.Vsize, urlOnly.Vsize)
 
 		_, err = estimate("  ", "")
 		require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
@@ -386,10 +379,10 @@ func TestService_VotesAndComments(t *testing.T) {
 
 	t.Run("list comments empty", func(t *testing.T) {
 		t.Parallel()
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t)))
-		resp, err := cli.ListComments(t.Context(), connect.NewRequest(&miscv1.ListCommentsRequest{ItemId: validItemID}))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t)))
+		resp, err := cli.ListComments(t.Context(), &miscv1.ListCommentsRequest{ItemId: validItemID})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Comments)
+		assert.Empty(t, resp.Comments)
 	})
 }
 
@@ -405,31 +398,29 @@ func TestService_CreateTopic(t *testing.T) {
 
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "test-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "test-txid"}, nil)
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
-		resp, err := cli.CreateTopic(t.Context(), connect.NewRequest(&miscv1.CreateTopicRequest{
+		resp, err := cli.CreateTopic(t.Context(), &miscv1.CreateTopicRequest{
 			Topic: "deadbeef",
 			Name:  "Test Topic",
-		}))
+		})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Txid)
 	})
 
 	t.Run("create topic with empty topic", func(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateTopic(t.Context(), connect.NewRequest(&miscv1.CreateTopicRequest{
+		_, err := cli.CreateTopic(t.Context(), &miscv1.CreateTopicRequest{
 			Topic: "",
 			Name:  "Test Topic",
-		}))
+		})
 		require.ErrorContains(t, err, "topic ID is empty")
 	})
 
@@ -437,12 +428,12 @@ func TestService_CreateTopic(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateTopic(t.Context(), connect.NewRequest(&miscv1.CreateTopicRequest{
+		_, err := cli.CreateTopic(t.Context(), &miscv1.CreateTopicRequest{
 			Topic: "123456", // Too short, should be 8 hex characters (4 bytes)
 			Name:  "Test Topic",
-		}))
+		})
 		require.ErrorContains(t, err, "is not 4 bytes")
 	})
 
@@ -450,12 +441,12 @@ func TestService_CreateTopic(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateTopic(t.Context(), connect.NewRequest(&miscv1.CreateTopicRequest{
+		_, err := cli.CreateTopic(t.Context(), &miscv1.CreateTopicRequest{
 			Topic: validTopicID().String(),
 			Name:  "",
-		}))
+		})
 		require.ErrorContains(t, err, "title must be set")
 	})
 
@@ -463,13 +454,13 @@ func TestService_CreateTopic(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
 		longName := bytes.Repeat(make([]byte, 65), 64) // 65 bytes, exceeds 64 limit
-		_, err := cli.CreateTopic(t.Context(), connect.NewRequest(&miscv1.CreateTopicRequest{
+		_, err := cli.CreateTopic(t.Context(), &miscv1.CreateTopicRequest{
 			Topic: validTopicID().String(),
 			Name:  string(longName),
-		}))
+		})
 		require.ErrorContains(t, err, "title cannot be longer than 64 bytes")
 	})
 
@@ -481,12 +472,12 @@ func TestService_CreateTopic(t *testing.T) {
 		topicID := validTopicID()
 		seedCurrentTopic(t, ctx, database, topicID, "Existing Topic", 50)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.CreateTopic(t.Context(), connect.NewRequest(&miscv1.CreateTopicRequest{
+		_, err := cli.CreateTopic(t.Context(), &miscv1.CreateTopicRequest{
 			Topic: topicID.String(),
 			Name:  "New Topic",
-		}))
+		})
 		require.ErrorContains(t, err, "topic already exists")
 	})
 }
@@ -498,14 +489,14 @@ func TestService_ListTopics(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListTopics(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListTopics(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 		// A fresh DB ships the two bootstrap default topics.
-		require.Len(t, resp.Msg.Topics, 2)
-		assert.True(t, lo.ContainsBy(resp.Msg.Topics, func(tp *miscv1.Topic) bool { return tp.Name == "US Weekly" }))
-		assert.True(t, lo.ContainsBy(resp.Msg.Topics, func(tp *miscv1.Topic) bool { return tp.Name == "Japan Weekly" }))
+		require.Len(t, resp.Topics, 2)
+		assert.True(t, lo.ContainsBy(resp.Topics, func(tp *miscv1.Topic) bool { return tp.Name == "US Weekly" }))
+		assert.True(t, lo.ContainsBy(resp.Topics, func(tp *miscv1.Topic) bool { return tp.Name == "Japan Weekly" }))
 	})
 
 	t.Run("list topics with data", func(t *testing.T) {
@@ -518,16 +509,16 @@ func TestService_ListTopics(t *testing.T) {
 		topicID2 := validTopicID()
 		seedCurrentTopic(t, ctx, database, topicID2, "Bitcoin Weekly", 51)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListTopics(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListTopics(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Topics, 4) // 2 seeded + 2 bootstrap defaults
+		require.Len(t, resp.Topics, 4) // 2 seeded + 2 bootstrap defaults
 
-		assert.True(t, lo.ContainsBy(resp.Msg.Topics, func(topic *miscv1.Topic) bool {
+		assert.True(t, lo.ContainsBy(resp.Topics, func(topic *miscv1.Topic) bool {
 			return topic.Topic == topicID1.String()
 		}), "topic 1 not found")
-		assert.True(t, lo.ContainsBy(resp.Msg.Topics, func(topic *miscv1.Topic) bool {
+		assert.True(t, lo.ContainsBy(resp.Topics, func(topic *miscv1.Topic) bool {
 			return topic.Topic == topicID2.String()
 		}), "topic 2 not found")
 	})
@@ -540,11 +531,11 @@ func TestService_ListCoinNews(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListCoinNews(t.Context(), connect.NewRequest(&miscv1.ListCoinNewsRequest{}))
+		resp, err := cli.ListCoinNews(t.Context(), &miscv1.ListCoinNewsRequest{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.CoinNews)
+		assert.Empty(t, resp.CoinNews)
 	})
 
 	t.Run("list coin news with data", func(t *testing.T) {
@@ -563,20 +554,20 @@ func TestService_ListCoinNews(t *testing.T) {
 		headline2 := "News Headline 2"
 		seedCurrentNews(t, ctx, database, topicID2, headline2, "Content for news 2", 4, time.Now().Add(-1*time.Hour))
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListCoinNews(t.Context(), connect.NewRequest(&miscv1.ListCoinNewsRequest{}))
+		resp, err := cli.ListCoinNews(t.Context(), &miscv1.ListCoinNewsRequest{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.CoinNews, 2)
+		require.Len(t, resp.CoinNews, 2)
 
 		// Ranked by §13 score: with no votes the older story scores
 		// higher (numerator −1 over a larger age denominator).
-		assert.Equal(t, topicID1.String(), resp.Msg.CoinNews[0].Topic)
-		assert.Equal(t, "News Headline 1", resp.Msg.CoinNews[0].Headline)
-		assert.Equal(t, "Content for news 1", resp.Msg.CoinNews[0].Content)
-		assert.Equal(t, topicID2.String(), resp.Msg.CoinNews[1].Topic)
-		assert.Equal(t, "News Headline 2", resp.Msg.CoinNews[1].Headline)
-		assert.Equal(t, "Content for news 2", resp.Msg.CoinNews[1].Content)
+		assert.Equal(t, topicID1.String(), resp.CoinNews[0].Topic)
+		assert.Equal(t, "News Headline 1", resp.CoinNews[0].Headline)
+		assert.Equal(t, "Content for news 1", resp.CoinNews[0].Content)
+		assert.Equal(t, topicID2.String(), resp.CoinNews[1].Topic)
+		assert.Equal(t, "News Headline 2", resp.CoinNews[1].Headline)
+		assert.Equal(t, "Content for news 2", resp.CoinNews[1].Content)
 	})
 
 	t.Run("list coin news filtered by topic", func(t *testing.T) {
@@ -597,17 +588,17 @@ func TestService_ListCoinNews(t *testing.T) {
 		headline2 := "News Headline 2"
 		seedCurrentNews(t, ctx, database, secondTopicID, headline2, "Content for news 2", 4, time.Now().Add(time.Second))
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
 		// Filter by topic
 		topic := firstTopicID.String()
-		resp, err := cli.ListCoinNews(t.Context(), connect.NewRequest(&miscv1.ListCoinNewsRequest{
+		resp, err := cli.ListCoinNews(t.Context(), &miscv1.ListCoinNewsRequest{
 			Topic: &topic,
-		}))
+		})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.CoinNews, 1)
-		assert.Equal(t, topic, resp.Msg.CoinNews[0].Topic)
-		assert.Equal(t, "News Headline 1", resp.Msg.CoinNews[0].Headline)
+		require.Len(t, resp.CoinNews, 1)
+		assert.Equal(t, topic, resp.CoinNews[0].Topic)
+		assert.Equal(t, "News Headline 1", resp.CoinNews[0].Headline)
 	})
 
 	t.Run("list coin news ranked by score", func(t *testing.T) {
@@ -629,16 +620,16 @@ func TestService_ListCoinNews(t *testing.T) {
 		headline3 := "Latest News"
 		seedCurrentNews(t, ctx, database, firstTopicID, headline3, "Content for latest news", 5, time.Now().Add(-1*time.Hour))
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListCoinNews(t.Context(), connect.NewRequest(&miscv1.ListCoinNewsRequest{}))
+		resp, err := cli.ListCoinNews(t.Context(), &miscv1.ListCoinNewsRequest{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.CoinNews, 3)
+		require.Len(t, resp.CoinNews, 3)
 
 		// §13 ranking: with no votes, older stories score higher.
-		assert.Equal(t, "Old News", resp.Msg.CoinNews[0].Headline)
-		assert.Equal(t, "Recent News", resp.Msg.CoinNews[1].Headline)
-		assert.Equal(t, "Latest News", resp.Msg.CoinNews[2].Headline)
+		assert.Equal(t, "Old News", resp.CoinNews[0].Headline)
+		assert.Equal(t, "Recent News", resp.CoinNews[1].Headline)
+		assert.Equal(t, "Latest News", resp.CoinNews[2].Headline)
 	})
 
 	t.Run("list coin news limited to 100 entries", func(t *testing.T) {
@@ -657,12 +648,12 @@ func TestService_ListCoinNews(t *testing.T) {
 			seedCurrentNews(t, ctx, database, firstTopicID, headline, "Content for news", 3+i, time.Now().Add(time.Duration(i)*time.Second))
 		}
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		resp, err := cli.ListCoinNews(t.Context(), connect.NewRequest(&miscv1.ListCoinNewsRequest{}))
+		resp, err := cli.ListCoinNews(t.Context(), &miscv1.ListCoinNewsRequest{})
 		require.NoError(t, err)
 		// Should be limited to 100 entries
-		assert.Len(t, resp.Msg.CoinNews, 100)
+		assert.Len(t, resp.CoinNews, 100)
 	})
 }
 
@@ -734,33 +725,31 @@ func TestService_TimestampFile(t *testing.T) {
 
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "timestamp-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "timestamp-txid"}, nil)
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
-		resp, err := cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		resp, err := cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "test-document.pdf",
 			FileData: []byte("This is the content of the test document"),
-		}))
+		})
 		require.NoError(t, err)
-		assert.NotEmpty(t, resp.Msg.Id)
-		assert.NotEmpty(t, resp.Msg.FileHash)
-		assert.NotEmpty(t, resp.Msg.Txid)
+		assert.NotEmpty(t, resp.Id)
+		assert.NotEmpty(t, resp.FileHash)
+		assert.NotEmpty(t, resp.Txid)
 	})
 
 	t.Run("timestamp file with empty filename", func(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		_, err := cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "",
 			FileData: []byte("content"),
-		}))
+		})
 		require.ErrorContains(t, err, "filename must be set")
 	})
 
@@ -768,12 +757,12 @@ func TestService_TimestampFile(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		_, err := cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "test.pdf",
 			FileData: []byte{},
-		}))
+		})
 		require.ErrorContains(t, err, "file data must be set")
 	})
 
@@ -787,33 +776,31 @@ func TestService_TimestampFile(t *testing.T) {
 		// Only one transaction should be sent
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "timestamp-txid"},
-			}, nil).
+			Return(&orchpb.SendTransactionResponse{Txid: "timestamp-txid"}, nil).
 			Times(1)
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
 		fileData := []byte("duplicate content")
 
 		// First timestamp
-		resp1, err := cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		resp1, err := cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "first.pdf",
 			FileData: fileData,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Second timestamp with same content
-		resp2, err := cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		resp2, err := cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "second.pdf",
 			FileData: fileData,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Should return the same timestamp ID and hash
-		assert.Equal(t, resp1.Msg.Id, resp2.Msg.Id)
-		assert.Equal(t, resp1.Msg.FileHash, resp2.Msg.FileHash)
+		assert.Equal(t, resp1.Id, resp2.Id)
+		assert.Equal(t, resp1.FileHash, resp2.FileHash)
 	})
 }
 
@@ -829,20 +816,20 @@ func TestService_ListTimestamps(t *testing.T) {
 		// Background operations
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).
 			AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).
 			AnyTimes()
 		// Required for ListTimestamps to get current block height
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Chain:  "signet",
 					Blocks: 1000,
@@ -851,11 +838,11 @@ func TestService_ListTimestamps(t *testing.T) {
 			AnyTimes()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListTimestamps(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListTimestamps(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Timestamps)
+		assert.Empty(t, resp.Timestamps)
 	})
 
 	t.Run("list timestamps with data", func(t *testing.T) {
@@ -868,28 +855,26 @@ func TestService_ListTimestamps(t *testing.T) {
 
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "timestamp-txid-1"},
-			}, nil).
+			Return(&orchpb.SendTransactionResponse{Txid: "timestamp-txid-1"}, nil).
 			Times(2)
 
 		// Background operations
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).
 			AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).
 			AnyTimes()
 		// Required for ListTimestamps to get current block height
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Chain:  "signet",
 					Blocks: 1000,
@@ -898,27 +883,27 @@ func TestService_ListTimestamps(t *testing.T) {
 			AnyTimes()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database,
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database,
 			apitests.WithOrchestrator(mockOrch),
 			apitests.WithBitcoind(mockBitcoind),
 		))
 
 		// Create some timestamps
-		_, err := cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		_, err := cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "file1.pdf",
 			FileData: []byte("content 1"),
-		}))
+		})
 		require.NoError(t, err)
 
-		_, err = cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		_, err = cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "file2.pdf",
 			FileData: []byte("content 2"),
-		}))
+		})
 		require.NoError(t, err)
 
-		resp, err := cli.ListTimestamps(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListTimestamps(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Timestamps, 2)
+		require.Len(t, resp.Timestamps, 2)
 	})
 }
 
@@ -933,12 +918,12 @@ func TestService_ListTimestampsBlockHeight(t *testing.T) {
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, errors.New("core is down"))).
+			Return(nil, connectv1.NewError(connectv1.CodeUnavailable, errors.New("core is down"))).
 			AnyTimes()
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.ListTimestamps(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := cli.ListTimestamps(t.Context(), &emptypb.Empty{})
 		require.ErrorContains(t, err, "core is down")
 	})
 
@@ -949,22 +934,20 @@ func TestService_ListTimestampsBlockHeight(t *testing.T) {
 		mockOrch := mocks.NewMockWalletManagerServiceClient(ctrl)
 		mockOrch.EXPECT().
 			GetNodeMode(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.GetNodeModeResponse]{
-				Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_LIGHT},
-			}, nil).
+			Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_LIGHT}, nil).
 			AnyTimes()
 		apitests.ExpectOrchestratorReads(mockOrch)
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database.Test(t),
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database.Test(t),
 			apitests.WithOrchestrator(mockOrch),
 			apitests.WithBitcoind(mockBitcoind),
 		))
 
-		resp, err := cli.ListTimestamps(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		resp, err := cli.ListTimestamps(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Timestamps)
+		assert.Empty(t, resp.Timestamps)
 	})
 }
 
@@ -975,11 +958,11 @@ func TestService_VerifyTimestamp(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.VerifyTimestamp(t.Context(), connect.NewRequest(&miscv1.VerifyTimestampRequest{
+		_, err := cli.VerifyTimestamp(t.Context(), &miscv1.VerifyTimestampRequest{
 			FileData: []byte("unknown content"),
-		}))
+		})
 		require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 	})
 
@@ -987,11 +970,11 @@ func TestService_VerifyTimestamp(t *testing.T) {
 		t.Parallel()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database))
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database))
 
-		_, err := cli.VerifyTimestamp(t.Context(), connect.NewRequest(&miscv1.VerifyTimestampRequest{
+		_, err := cli.VerifyTimestamp(t.Context(), &miscv1.VerifyTimestampRequest{
 			FileData: []byte{},
-		}))
+		})
 		require.ErrorContains(t, err, "file data must be set")
 	})
 
@@ -1005,27 +988,25 @@ func TestService_VerifyTimestamp(t *testing.T) {
 
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "timestamp-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "timestamp-txid"}, nil)
 
 		// Background operations
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.ListWalletsResponse]{
+			Return(&connectv1.Response[corepb.ListWalletsResponse]{
 				Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 			}, nil).
 			AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.CreateWalletResponse]{
+			Return(&connectv1.Response[corepb.CreateWalletResponse]{
 				Msg: &corepb.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).
 			AnyTimes()
 		// Required for VerifyTimestamp to get current block height
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[corepb.GetBlockchainInfoResponse]{
+			Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{
 				Msg: &corepb.GetBlockchainInfoResponse{
 					Chain:  "signet",
 					Blocks: 1000,
@@ -1034,7 +1015,7 @@ func TestService_VerifyTimestamp(t *testing.T) {
 			AnyTimes()
 
 		database := database.Test(t)
-		cli := miscv1connect.NewMiscServiceClient(apitests.API(t, database,
+		cli := miscv1connect.NewMiscServiceClient(apitests.RPC(t, database,
 			apitests.WithOrchestrator(mockOrch),
 			apitests.WithBitcoind(mockBitcoind),
 		))
@@ -1042,16 +1023,16 @@ func TestService_VerifyTimestamp(t *testing.T) {
 		fileData := []byte("content to verify")
 
 		// First create the timestamp
-		_, err := cli.TimestampFile(t.Context(), connect.NewRequest(&miscv1.TimestampFileRequest{
+		_, err := cli.TimestampFile(t.Context(), &miscv1.TimestampFileRequest{
 			Filename: "verify-test.pdf",
 			FileData: fileData,
-		}))
+		})
 		require.NoError(t, err)
 
-		verify := func() (*connect.Response[miscv1.VerifyTimestampResponse], error) {
-			return cli.VerifyTimestamp(t.Context(), connect.NewRequest(&miscv1.VerifyTimestampRequest{
+		verify := func() (*miscv1.VerifyTimestampResponse, error) {
+			return cli.VerifyTimestamp(t.Context(), &miscv1.VerifyTimestampRequest{
 				FileData: fileData,
-			}))
+			})
 		}
 
 		_, err = verify()
@@ -1072,7 +1053,7 @@ func TestService_VerifyTimestamp(t *testing.T) {
 		require.NoError(t, timestamps.Update(t.Context(), database, rows[0].ID, nil, &height, timestamps.StatusConfirmed, &confirmedAt))
 		resp, err := verify()
 		require.NoError(t, err)
-		assert.NotNil(t, resp.Msg.Timestamp)
-		assert.Contains(t, resp.Msg.Message, "verified")
+		assert.NotNil(t, resp.Timestamp)
+		assert.Contains(t, resp.Message, "verified")
 	})
 }
diff --git a/bitwindow/server/api/multisig/multisig.go b/bitwindow/server/api/multisig/multisig.go
index 6753cb7242..18e52cf7ce 100644
--- a/bitwindow/server/api/multisig/multisig.go
+++ b/bitwindow/server/api/multisig/multisig.go
@@ -3,11 +3,10 @@ package multisig
 import (
 	"context"
 	"database/sql"
-	"errors"
 	"fmt"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -31,35 +30,35 @@ func New(db *sql.DB) *Server {
 
 func (s *Server) ListGroups(
 	ctx context.Context,
-	req *connect.Request[emptypb.Empty],
-) (*connect.Response[pb.ListGroupsResponse], error) {
+	req *emptypb.Empty,
+) (*pb.ListGroupsResponse, error) {
 	groups, err := s.store.ListGroups(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("list groups: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("list groups: %s", err)).WithCause(err)
 	}
 
 	var pbGroups []*pb.MultisigGroup
 	for _, g := range groups {
 		pbGroup, err := s.groupToProto(ctx, g)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInternal, err)
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 		pbGroups = append(pbGroups, pbGroup)
 	}
 
-	return connect.NewResponse(&pb.ListGroupsResponse{Groups: pbGroups}), nil
+	return &pb.ListGroupsResponse{Groups: pbGroups}, nil
 }
 
 func (s *Server) SaveGroup(
 	ctx context.Context,
-	req *connect.Request[pb.SaveGroupRequest],
-) (*connect.Response[pb.SaveGroupResponse], error) {
-	pg := req.Msg.Group
+	req *pb.SaveGroupRequest,
+) (*pb.SaveGroupResponse, error) {
+	pg := req.Group
 	if pg == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("group is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "group is required")
 	}
 	if pg.Id == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("group id is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "group id is required")
 	}
 
 	g := multisig.Group{
@@ -152,97 +151,97 @@ func (s *Server) SaveGroup(
 		UtxoDetails:    utxos,
 		TransactionIDs: pg.TransactionIds,
 	}); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save group atomic: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("save group atomic: %s", err)).WithCause(err)
 	}
 
 	saved, err := s.groupToProto(ctx, g)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.SaveGroupResponse{Group: saved}), nil
+	return &pb.SaveGroupResponse{Group: saved}, nil
 }
 
 func (s *Server) DeleteGroup(
 	ctx context.Context,
-	req *connect.Request[pb.DeleteGroupRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	if err := s.store.DeleteGroup(ctx, req.Msg.GroupId); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("delete group: %w", err))
+	req *pb.DeleteGroupRequest,
+) (*emptypb.Empty, error) {
+	if err := s.store.DeleteGroup(ctx, req.GroupId); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("delete group: %s", err)).WithCause(err)
 	}
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // ─── Transactions ──────────────────────────────────────────────────
 
 func (s *Server) ListTransactions(
 	ctx context.Context,
-	req *connect.Request[pb.ListTransactionsRequest],
-) (*connect.Response[pb.ListTransactionsResponse], error) {
-	txns, err := s.store.ListTransactions(ctx, req.Msg.GroupId)
+	req *pb.ListTransactionsRequest,
+) (*pb.ListTransactionsResponse, error) {
+	txns, err := s.store.ListTransactions(ctx, req.GroupId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("list transactions: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("list transactions: %s", err)).WithCause(err)
 	}
 
 	var pbTxns []*pb.MultisigTransaction
 	for _, t := range txns {
 		pbTx, err := s.txToProto(ctx, t)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInternal, err)
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 		pbTxns = append(pbTxns, pbTx)
 	}
 
-	return connect.NewResponse(&pb.ListTransactionsResponse{Transactions: pbTxns}), nil
+	return &pb.ListTransactionsResponse{Transactions: pbTxns}, nil
 }
 
 func (s *Server) GetTransaction(
 	ctx context.Context,
-	req *connect.Request[pb.GetTransactionRequest],
-) (*connect.Response[pb.MultisigTransaction], error) {
-	t, err := s.store.GetTransaction(ctx, req.Msg.TransactionId)
+	req *pb.GetTransactionRequest,
+) (*pb.MultisigTransaction, error) {
+	t, err := s.store.GetTransaction(ctx, req.TransactionId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	if t == nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("transaction not found: %s", req.Msg.TransactionId))
+		return nil, connect.Errorf(connect.CodeNotFound, "transaction not found: %s", req.TransactionId)
 	}
 
 	pbTx, err := s.txToProto(ctx, *t)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(pbTx), nil
+	return pbTx, nil
 }
 
 func (s *Server) GetTransactionByTxid(
 	ctx context.Context,
-	req *connect.Request[pb.GetTransactionByTxidRequest],
-) (*connect.Response[pb.MultisigTransaction], error) {
-	t, err := s.store.GetTransactionByTxid(ctx, req.Msg.Txid)
+	req *pb.GetTransactionByTxidRequest,
+) (*pb.MultisigTransaction, error) {
+	t, err := s.store.GetTransactionByTxid(ctx, req.Txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	if t == nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("transaction not found for txid: %s", req.Msg.Txid))
+		return nil, connect.Errorf(connect.CodeNotFound, "transaction not found for txid: %s", req.Txid)
 	}
 
 	pbTx, err := s.txToProto(ctx, *t)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(pbTx), nil
+	return pbTx, nil
 }
 
 func (s *Server) SaveTransaction(
 	ctx context.Context,
-	req *connect.Request[pb.SaveTransactionRequest],
-) (*connect.Response[pb.SaveTransactionResponse], error) {
-	pt := req.Msg.Transaction
+	req *pb.SaveTransactionRequest,
+) (*pb.SaveTransactionResponse, error) {
+	pt := req.Transaction
 	if pt == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("transaction is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "transaction is required")
 	}
 
 	t := multisig.Transaction{
@@ -305,35 +304,35 @@ func (s *Server) SaveTransaction(
 		KeyPSBTs:    psbts,
 		Inputs:      inputs,
 	}); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save transaction atomic: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("save transaction atomic: %s", err)).WithCause(err)
 	}
 
 	// Re-read
 	saved, err := s.store.GetTransaction(ctx, pt.Id)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("re-read transaction: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("re-read transaction: %s", err)).WithCause(err)
 	}
 	if saved == nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("transaction %s missing after save", pt.Id))
+		return nil, connect.Errorf(connect.CodeInternal, "transaction %s missing after save", pt.Id)
 	}
 
 	pbTx, err := s.txToProto(ctx, *saved)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.SaveTransactionResponse{Transaction: pbTx}), nil
+	return &pb.SaveTransactionResponse{Transaction: pbTx}, nil
 }
 
 // ─── Solo Keys ─────────────────────────────────────────────────────
 
 func (s *Server) ListSoloKeys(
 	ctx context.Context,
-	req *connect.Request[emptypb.Empty],
-) (*connect.Response[pb.ListSoloKeysResponse], error) {
+	req *emptypb.Empty,
+) (*pb.ListSoloKeysResponse, error) {
 	keys, err := s.store.ListSoloKeys(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	pbKeys := lo.Map(keys, func(k multisig.SoloKey, _ int) *pb.SoloKey {
@@ -346,16 +345,16 @@ func (s *Server) ListSoloKeys(
 		}
 	})
 
-	return connect.NewResponse(&pb.ListSoloKeysResponse{Keys: pbKeys}), nil
+	return &pb.ListSoloKeysResponse{Keys: pbKeys}, nil
 }
 
 func (s *Server) AddSoloKey(
 	ctx context.Context,
-	req *connect.Request[pb.AddSoloKeyRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	k := req.Msg.Key
+	req *pb.AddSoloKeyRequest,
+) (*emptypb.Empty, error) {
+	k := req.Key
 	if k == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("key is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "key is required")
 	}
 
 	if err := s.store.AddSoloKey(ctx, multisig.SoloKey{
@@ -365,28 +364,28 @@ func (s *Server) AddSoloKey(
 		OriginPath:     k.OriginPath,
 		Owner:          k.Owner,
 	}); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // ─── Account Index ─────────────────────────────────────────────────
 
 func (s *Server) GetNextAccountIndex(
 	ctx context.Context,
-	req *connect.Request[pb.GetNextAccountIndexRequest],
-) (*connect.Response[pb.GetNextAccountIndexResponse], error) {
-	additional := lo.Map(req.Msg.AdditionalUsedIndices, func(idx int32, _ int) int {
+	req *pb.GetNextAccountIndexRequest,
+) (*pb.GetNextAccountIndexResponse, error) {
+	additional := lo.Map(req.AdditionalUsedIndices, func(idx int32, _ int) int {
 		return int(idx)
 	})
 
 	next, err := s.store.GetNextAccountIndex(ctx, additional)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.GetNextAccountIndexResponse{NextIndex: int32(next)}), nil
+	return &pb.GetNextAccountIndexResponse{NextIndex: int32(next)}, nil
 }
 
 // ─── Converters ────────────────────────────────────────────────────
diff --git a/bitwindow/server/api/multisig/multisig_test.go b/bitwindow/server/api/multisig/multisig_test.go
index 8f087009f4..ff341f1c1c 100644
--- a/bitwindow/server/api/multisig/multisig_test.go
+++ b/bitwindow/server/api/multisig/multisig_test.go
@@ -3,7 +3,7 @@ package multisig_test
 import (
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -20,7 +20,7 @@ func TestSaveGroup(t *testing.T) {
 	t.Run("each key keeps its own psbts", func(t *testing.T) {
 		t.Parallel()
 
-		cli := rpc.NewMultisigServiceClient(apitests.API(t, database.Test(t)))
+		cli := rpc.NewMultisigServiceClient(apitests.RPC(t, database.Test(t)))
 		group := &pb.MultisigGroup{
 			Id: "g1", Name: "family", N: 2, M: 2,
 			Keys: []*pb.MultisigKey{
@@ -38,13 +38,13 @@ func TestSaveGroup(t *testing.T) {
 			TransactionIds: []string{"tx1", "tx2"},
 		}
 
-		saved, err := cli.SaveGroup(t.Context(), connect.NewRequest(&pb.SaveGroupRequest{Group: group}))
+		saved, err := cli.SaveGroup(t.Context(), &pb.SaveGroupRequest{Group: group})
 		require.NoError(t, err)
-		listed, err := cli.ListGroups(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		listed, err := cli.ListGroups(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		require.Len(t, listed.Msg.Groups, 1)
+		require.Len(t, listed.Groups, 1)
 
-		for _, got := range []*pb.MultisigGroup{saved.Msg.Group, listed.Msg.Groups[0]} {
+		for _, got := range []*pb.MultisigGroup{saved.Group, listed.Groups[0]} {
 			require.Len(t, got.Keys, 2)
 			for i, key := range got.Keys {
 				assert.Equal(t, group.Keys[i].Xpub, key.Xpub)
@@ -58,9 +58,9 @@ func TestSaveGroup(t *testing.T) {
 	t.Run("refuses a group with no id", func(t *testing.T) {
 		t.Parallel()
 
-		cli := rpc.NewMultisigServiceClient(apitests.API(t, database.Test(t)))
+		cli := rpc.NewMultisigServiceClient(apitests.RPC(t, database.Test(t)))
 
-		_, err := cli.SaveGroup(t.Context(), connect.NewRequest(&pb.SaveGroupRequest{Group: &pb.MultisigGroup{Name: "family"}}))
+		_, err := cli.SaveGroup(t.Context(), &pb.SaveGroupRequest{Group: &pb.MultisigGroup{Name: "family"}})
 		require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 }
diff --git a/bitwindow/server/api/notification/notification.go b/bitwindow/server/api/notification/notification.go
index d888be4cbd..85f1a678b2 100644
--- a/bitwindow/server/api/notification/notification.go
+++ b/bitwindow/server/api/notification/notification.go
@@ -3,7 +3,6 @@ package notification
 import (
 	"context"
 
-	"connectrpc.com/connect"
 	"github.com/rs/zerolog"
 	"google.golang.org/protobuf/types/known/emptypb"
 
@@ -26,8 +25,8 @@ type Server struct {
 
 func (s *Server) Watch(
 	ctx context.Context,
-	req *connect.Request[emptypb.Empty],
-	stream *connect.ServerStream[notificationv1.WatchResponse],
+	req *emptypb.Empty,
+	stream rpc.NotificationServiceWatchServerStream,
 ) error {
 	log := zerolog.Ctx(ctx)
 	log.Info().Msg("notification watch stream started")
diff --git a/bitwindow/server/api/notification/notification_test.go b/bitwindow/server/api/notification/notification_test.go
index 4f7a2045cf..e733490a33 100644
--- a/bitwindow/server/api/notification/notification_test.go
+++ b/bitwindow/server/api/notification/notification_test.go
@@ -3,12 +3,14 @@ package notification_test
 import (
 	"context"
 	"errors"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/emptypb"
 
@@ -26,21 +28,32 @@ func TestWatch(t *testing.T) {
 		go func() { done <- engine.Run(runCtx) }()
 
 		mux := http.NewServeMux()
-		mux.Handle(rpc.NewNotificationServiceHandler(notification.New(engine)))
+		srv := connect.NewServer()
+		rpc.RegisterNotificationServiceHandler(srv, notification.New(engine))
+		connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 		server := httptest.NewServer(mux)
 		t.Cleanup(server.Close)
 
-		client := rpc.NewNotificationServiceClient(server.Client(), server.URL)
+		client := rpc.NewNotificationServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 		ended := make(chan error, 1)
 		go func() {
-			stream, err := client.Watch(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+			stream, err := client.Watch(t.Context(), &emptypb.Empty{})
 			if err != nil {
 				ended <- err
 				return
 			}
-			for stream.Receive() {
+			var streamErr error
+			for {
+				_, err := stream.Receive()
+				if err != nil {
+					streamErr = err
+					break
+				}
 			}
-			ended <- errors.Join(stream.Err(), stream.Close())
+			if errors.Is(streamErr, io.EOF) {
+				streamErr = nil
+			}
+			ended <- errors.Join(streamErr, stream.Close())
 		}()
 
 		stop()
diff --git a/bitwindow/server/api/runtime.go b/bitwindow/server/api/runtime.go
index c77380f28d..906508db3c 100644
--- a/bitwindow/server/api/runtime.go
+++ b/bitwindow/server/api/runtime.go
@@ -8,11 +8,15 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"slices"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"connectrpc.com/grpcreflect"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
@@ -101,7 +105,6 @@ type Runtime struct {
 	db       *sql.DB
 	bitcoind *service.Service[corerpc.BitcoinServiceClient]
 	mux      *http.ServeMux
-	services []string // service paths registered on mux, for grpcreflect
 
 	walletEngine       *engines.WalletEngine
 	chequeEngine       *engines.ChequeEngine
@@ -230,17 +233,7 @@ func (s *Server) buildRuntime(ctx context.Context, conf config.Config, networkID
 		return engines.NewZmqEngine(addr).SubscribeSequence(ctx)
 	}, rt.walletEngine.NodeMode())
 
-	// Register Connect sub-handlers on rt.mux. All registrations capture
-	// rt's db + engines, so when this runtime is replaced, none of these
-	// handler bodies are reachable through the new mux.
-	register := func(servicePath string, h http.Handler) {
-		rt.mux.Handle(servicePath, h)
-		rt.services = append(rt.services, servicePath)
-	}
-
-	// All bitwindowd endpoints require the local-auth cookie (one interceptor,
-	// every handler). Disabled automatically when no cookie exists.
-	stdOpts := []connect.HandlerOption{connect.WithInterceptors(logInterceptor(), recoverInterceptor{}, localauth.Interceptor(s.svcs.BitwindowDir))}
+	rpcServer := connect.NewServer(logInterceptor(), recoverInterceptor(), localauth.ServerInterceptor(s.svcs.BitwindowDir), errorInterceptor())
 
 	// bitwindowd — UpdateNetwork captured here calls back into Server.Recycle,
 	// which builds a fresh Runtime. Method value is bound to s, late-binds
@@ -248,94 +241,83 @@ func (s *Server) buildRuntime(ctx context.Context, conf config.Config, networkID
 	{
 		pools := miningpools.New(ctx, conf.BitcoinCoreNetwork, networkID, conf.Datadir, s.svcs.MiningPoolFetch)
 		bwSvc := api_bitwindowd.New(s.onShutdown, rt.db, s.Bitcoind, rt.walletEngine, rt.mempoolWatcher, pools, conf, s.Recycle)
-		path, h := bitwindowdv1connect.NewBitwindowdServiceHandler(bwSvc, stdOpts...)
-		register(path, h)
+		bitwindowdv1connect.RegisterBitwindowdServiceHandler(rpcServer, bwSvc)
 	}
 	{
 		drivechainSvc := api_drivechain.New(s.Enforcer, s.BlockProducer, rt.walletEngine, m4.WithdrawalMaxAge(conf.BitcoinCoreNetwork, networkID))
-		path, h := drivechainv1connect.NewDrivechainServiceHandler(drivechainSvc, stdOpts...)
-		register(path, h)
+		drivechainv1connect.RegisterDrivechainServiceHandler(rpcServer, drivechainSvc)
 	}
 	{
 		orchestrator := dial.Orchestrator(s.svcs.OrchestratorAddr, s.svcs.BitwindowDir)
 		restartL1 := func(ctx context.Context) error {
-			_, err := orchestrator.RestartL1(ctx, connect.NewRequest(&orchctlpb.RestartL1Request{}))
+			_, err := orchestrator.RestartL1(ctx, &orchctlpb.RestartL1Request{})
 			return err
 		}
 		rt.walletSvc = api_wallet.New(rt.db, s.Bitcoind, s.Enforcer, rt.chequeEngine, rt.chequeChain, rt.walletEngine, rt.walletDir, restartL1)
-		path, h := walletv1connect.NewWalletServiceHandler(rt.walletSvc, stdOpts...)
-		register(path, h)
+		walletv1connect.RegisterWalletServiceHandler(rpcServer, rt.walletSvc)
 	}
 	{
 		miscSvc := api_misc.New(rt.db, rt.timestampEngine, s.Bitcoind, rt.walletEngine,
 			engines.NewRemoteCoinNews(string(conf.BitcoinCoreNetwork), networkID))
-		path, h := miscv1connect.NewMiscServiceHandler(miscSvc, stdOpts...)
-		register(path, h)
+		miscv1connect.RegisterMiscServiceHandler(rpcServer, miscSvc)
 	}
 	{
 		healthSvc := api_health.New(rt.db, s.Bitcoind, s.Enforcer, s.Crypto)
-		path, h := healthv1connect.NewHealthServiceHandler(healthSvc, stdOpts...)
-		register(path, h)
+		healthv1connect.RegisterHealthServiceHandler(rpcServer, healthSvc)
 	}
 	{
 		m4Svc := api_m4.NewServer(rt.m4Engine, s.BlockProducer)
-		path, h := m4v1connect.NewM4ServiceHandler(m4Svc, stdOpts...)
-		register(path, h)
+		m4v1connect.RegisterM4ServiceHandler(rpcServer, m4Svc)
 	}
 	{
 		notifSvc := api_notification.New(rt.notificationEngine)
-		path, h := notificationv1connect.NewNotificationServiceHandler(notifSvc, stdOpts...)
-		register(path, h)
+		notificationv1connect.RegisterNotificationServiceHandler(rpcServer, notifSvc)
 	}
 	{
 		bitdriveSvc := api_bitdrive.New(rt.db, rt.bitdriveEngine)
-		path, h := bitdrivev1connect.NewBitDriveServiceHandler(bitdriveSvc, stdOpts...)
-		register(path, h)
+		bitdrivev1connect.RegisterBitDriveServiceHandler(rpcServer, bitdriveSvc)
 	}
 	{
 		utilsSvc := api_utils.New(rt.chainParams)
-		path, h := utilsv1connect.NewUtilsServiceHandler(utilsSvc, stdOpts...)
-		register(path, h)
+		utilsv1connect.RegisterUtilsServiceHandler(rpcServer, utilsSvc)
 	}
 	{
 		sidechainSvc := api_sidechain.New(rt.sidechainMonitor)
-		path, h := sidechainv1connect.NewSidechainServiceHandler(sidechainSvc, stdOpts...)
-		register(path, h)
+		sidechainv1connect.RegisterSidechainServiceHandler(rpcServer, sidechainSvc)
 	}
 	{
 		multisigSvc := api_multisig.New(rt.db)
-		path, h := multisigv1connect.NewMultisigServiceHandler(multisigSvc, stdOpts...)
-		register(path, h)
+		multisigv1connect.RegisterMultisigServiceHandler(rpcServer, multisigSvc)
 	}
 	{
 		walletPsbtSvc := api_walletpsbt.New(rt.db)
-		path, h := walletpsbtv1connect.NewWalletPsbtServiceHandler(walletPsbtSvc, stdOpts...)
-		register(path, h)
+		walletpsbtv1connect.RegisterWalletPsbtServiceHandler(rpcServer, walletPsbtSvc)
 	}
 	// Enforcer bridge — single impl serves three separate services
 	enforcerSvc := api_enforcer.New(s.Enforcer, s.Crypto, s.BlockProducer, s.Mining, rt.walletEngine)
 	{
-		path, h := validatorrpc.NewValidatorServiceHandler(enforcerSvc, stdOpts...)
-		register(path, h)
+		validatorrpc.RegisterValidatorServiceHandler(rpcServer, enforcerSvc)
 	}
 	{
-		path, h := cryptorpc.NewCryptoServiceHandler(enforcerSvc, stdOpts...)
-		register(path, h)
+		cryptorpc.RegisterCryptoServiceHandler(rpcServer, enforcerSvc)
 	}
 	{
-		path, h := validatorrpc.NewBlockProducerServiceHandler(enforcerSvc, stdOpts...)
-		register(path, h)
+		validatorrpc.RegisterBlockProducerServiceHandler(rpcServer, enforcerSvc)
 	}
 	{
-		path, h := validatorrpc.NewMiningServiceHandler(enforcerSvc, stdOpts...)
-		register(path, h)
+		validatorrpc.RegisterMiningServiceHandler(rpcServer, enforcerSvc)
 	}
 	rt.mux.Handle("/enforcer/jsonrpc", localauth.Middleware(s.svcs.BitwindowDir, enforcerproxy.JSONRPC(s.svcs.EnforcerJSONRPCAddr)))
 
-	// gRPC reflection. Each runtime mux gets its own reflector so listing
-	// stays accurate after a recycle (set is identical across runtimes,
-	// but rt-local for clarity).
-	reflector := grpcreflect.NewStaticReflector(rt.services...)
+	connecthttp.Mount(rt.mux, rpcServer, connecthttp.WithReadMaxBytes(0))
+	var services []string
+	for spec := range rpcServer.Specs() {
+		name := strings.TrimPrefix(spec.Procedure[:strings.LastIndex(spec.Procedure, "/")], "/")
+		if !slices.Contains(services, name) {
+			services = append(services, name)
+		}
+	}
+	reflector := grpcreflect.NewStaticReflector(services...)
 	rt.mux.Handle(grpcreflect.NewHandlerV1(reflector))
 	rt.mux.Handle(grpcreflect.NewHandlerV1Alpha(reflector))
 
@@ -415,7 +397,9 @@ func (rt *Runtime) runZMQ(ctx context.Context, log *zerolog.Logger) {
 				log.Warn().Err(err).Msg("ZMQ engine stopped, retrying")
 			case ctx.Err() != nil:
 				return
-			case connect.CodeOf(err) == connect.CodeUnavailable || isBitcoinCoreStartupError(err.Error()):
+			case connect.CodeOf(err) == connect.CodeUnavailable,
+				connectv1.CodeOf(err) == connectv1.CodeUnavailable,
+				isBitcoinCoreStartupError(err.Error()):
 				log.Debug().Msg("ZMQ engine: waiting for Bitcoin Core connection")
 			default:
 				log.Error().Err(err).Msg("acquire ZMQ engine")
@@ -464,14 +448,14 @@ func coreRawCall(s *Server) engines.RawCall {
 		if err != nil {
 			return nil, err
 		}
-		resp, err := client.CoreRawCall(ctx, connect.NewRequest(&orchctlpb.CoreRawCallRequest{
+		resp, err := client.CoreRawCall(ctx, &orchctlpb.CoreRawCallRequest{
 			Method:     method,
 			ParamsJson: string(paramsJSON),
-		}))
+		})
 		if err != nil {
 			return nil, err
 		}
-		return json.RawMessage(resp.Msg.ResultJson), nil
+		return json.RawMessage(resp.ResultJson), nil
 	}
 }
 
@@ -481,7 +465,7 @@ func zmqAddress(ctx context.Context, bitcoind *service.Service[corerpc.BitcoinSe
 	if err != nil {
 		return "", err
 	}
-	notifs, err := btc.GetZmqNotifications(ctx, connect.NewRequest(&emptypb.Empty{}))
+	notifs, err := btc.GetZmqNotifications(ctx, connectv1.NewRequest(&emptypb.Empty{}))
 	if err != nil {
 		return "", fmt.Errorf("get zmq notifications: %w", err)
 	}
@@ -573,12 +557,12 @@ func activeSidechainSlots(ctx context.Context, enforcer *service.Service[validat
 	if err != nil {
 		return nil, err
 	}
-	resp, err := client.GetSidechains(ctx, connect.NewRequest(&validatorpb.GetSidechainsRequest{}))
+	resp, err := client.GetSidechains(ctx, &validatorpb.GetSidechainsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("get sidechains: %w", err)
 	}
-	slots := make([]uint32, 0, len(resp.Msg.GetSidechains()))
-	for _, sc := range resp.Msg.GetSidechains() {
+	slots := make([]uint32, 0, len(resp.GetSidechains()))
+	for _, sc := range resp.GetSidechains() {
 		slots = append(slots, sc.GetSidechainNumber().GetValue())
 	}
 	return slots, nil
diff --git a/bitwindow/server/api/runtime_test.go b/bitwindow/server/api/runtime_test.go
index 4b3a7c430f..493562118e 100644
--- a/bitwindow/server/api/runtime_test.go
+++ b/bitwindow/server/api/runtime_test.go
@@ -10,7 +10,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/rs/zerolog"
@@ -272,7 +272,7 @@ func TestRecycle(t *testing.T) {
 func TestZmqAddress(t *testing.T) {
 	core := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 	core.EXPECT().GetZmqNotifications(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&corepb.GetZmqNotificationsResponse{
+		Return(connectv1.NewResponse(&corepb.GetZmqNotificationsResponse{
 			Notifications: []*corepb.GetZmqNotificationsResponse_Notification{
 				{Type: "pubrawtx", Address: "tcp://127.0.0.1:29000"},
 			},
diff --git a/bitwindow/server/api/server.go b/bitwindow/server/api/server.go
index 6246b058ed..87711da2f1 100644
--- a/bitwindow/server/api/server.go
+++ b/bitwindow/server/api/server.go
@@ -13,7 +13,8 @@ import (
 	"sync/atomic"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/rs/zerolog"
@@ -371,15 +372,18 @@ func (s *Server) Shutdown(ctx context.Context) {
 	}
 }
 
-func logInterceptor() connect.UnaryInterceptorFunc {
-	return func(next connect.UnaryFunc) connect.UnaryFunc {
-		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
+func logInterceptor() connect.ServerInterceptor {
+	return func(next connect.ServerFunc) connect.ServerFunc {
+		return func(ctx context.Context, spec connect.Spec, stream connect.ServerStream) error {
+			if spec.StreamType != connect.StreamTypeUnary {
+				return next(ctx, spec, stream)
+			}
 			start := time.Now()
 
 			var code connect.Code
 			log := zerolog.Ctx(ctx)
 
-			resp, handlerErr := next(ctx, req)
+			handlerErr := next(ctx, spec, stream)
 
 			if handlerErr != nil {
 				if cCode, ok := getCode(handlerErr); ok {
@@ -393,10 +397,10 @@ func logInterceptor() connect.UnaryInterceptorFunc {
 				}
 			}
 
-			procedure := req.Spec().Procedure
+			procedure := spec.Procedure
 			level := getLogLevel(procedure, code, handlerErr)
 			if level == zerolog.Disabled {
-				return resp, handlerErr
+				return handlerErr
 			}
 
 			message := fmt.Sprintf("%s: %s", procedure, describeCode(code))
@@ -406,36 +410,59 @@ func logInterceptor() connect.UnaryInterceptorFunc {
 				Err(handlerErr).
 				Msg(message)
 
-			return resp, handlerErr
+			return handlerErr
 		}
 	}
 }
 
-type recoverInterceptor struct{}
-
-func (recoverInterceptor) WrapUnary(next connect.UnaryFunc) connect.UnaryFunc {
-	return func(ctx context.Context, req connect.AnyRequest) (resp connect.AnyResponse, err error) {
-		defer func() {
-			if r := recover(); r != nil {
-				err = recoveredPanic(ctx, req.Spec().Procedure, r)
-			}
-		}()
-		return next(ctx, req)
+func recoverInterceptor() connect.ServerInterceptor {
+	return func(next connect.ServerFunc) connect.ServerFunc {
+		return func(ctx context.Context, spec connect.Spec, stream connect.ServerStream) (err error) {
+			defer func() {
+				if r := recover(); r != nil {
+					err = recoveredPanic(ctx, spec.Procedure, r)
+				}
+			}()
+			return next(ctx, spec, stream)
+		}
 	}
 }
 
-func (recoverInterceptor) WrapStreamingClient(next connect.StreamingClientFunc) connect.StreamingClientFunc {
-	return next
-}
-
-func (recoverInterceptor) WrapStreamingHandler(next connect.StreamingHandlerFunc) connect.StreamingHandlerFunc {
-	return func(ctx context.Context, conn connect.StreamingHandlerConn) (err error) {
-		defer func() {
-			if r := recover(); r != nil {
-				err = recoveredPanic(ctx, conn.Spec().Procedure, r)
+func errorInterceptor() connect.ServerInterceptor {
+	return func(next connect.ServerFunc) connect.ServerFunc {
+		return func(ctx context.Context, spec connect.Spec, stream connect.ServerStream) error {
+			err := next(ctx, spec, stream)
+			var remoteError *connect.Error
+			if errors.As(err, &remoteError) {
+				if !remoteError.IsRemote() {
+					return err
+				}
+				publicError := connect.NewError(remoteError.Code(), remoteError.Message()).WithCause(err)
+				for _, detail := range remoteError.Details() {
+					publicError = publicError.WithDetail(detail)
+				}
+				return publicError
 			}
-		}()
-		return next(ctx, conn)
+			var oldError *connectv1.Error
+			if errors.As(err, &oldError) {
+				publicError := connect.NewError(connect.Code(oldError.Code()), oldError.Message()).WithCause(err)
+				for _, detail := range oldError.Details() {
+					publicError = publicError.WithDetail(&connect.ErrorDetail{Type: detail.Type(), Value: detail.Bytes()})
+				}
+				if info, ok := connect.CallInfoForServerContext(ctx); ok {
+					metadata := info.ResponseHeader()
+					if spec.StreamType != connect.StreamTypeUnary {
+						metadata = info.ResponseTrailer()
+					}
+					for key, values := range oldError.Meta() {
+						metadata.SetValues(key, values)
+					}
+				}
+				return publicError
+			}
+
+			return err
+		}
 	}
 }
 
@@ -445,7 +472,7 @@ func recoveredPanic(ctx context.Context, procedure string, r any) error {
 		Interface("panic", r).
 		Str("stack", string(debug.Stack())).
 		Msg("recovered a panic in a handler")
-	return connect.NewError(connect.CodeInternal, fmt.Errorf("panic in %s", procedure))
+	return connect.Errorf(connect.CodeInternal, "panic in %s", procedure)
 }
 
 func getLogLevel(procedure string, code connect.Code, err error) zerolog.Level {
diff --git a/bitwindow/server/api/sidechain/sidechain.go b/bitwindow/server/api/sidechain/sidechain.go
index 9f6d935879..8747a1e5e4 100644
--- a/bitwindow/server/api/sidechain/sidechain.go
+++ b/bitwindow/server/api/sidechain/sidechain.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
 	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/engines"
@@ -23,41 +23,41 @@ func New(monitor *engines.SidechainMonitorEngine) *Server {
 
 func (s *Server) GetDetectedWithdrawals(
 	ctx context.Context,
-	req *connect.Request[pb.GetDetectedWithdrawalsRequest],
-) (*connect.Response[pb.GetDetectedWithdrawalsResponse], error) {
+	req *pb.GetDetectedWithdrawalsRequest,
+) (*pb.GetDetectedWithdrawalsResponse, error) {
 	withdrawals, err := s.monitor.GetDetectedWithdrawals(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	// Convert to protobuf
 	pbWithdrawals := make([]*pb.DetectedWithdrawal, 0, len(withdrawals))
 	for _, w := range withdrawals {
 		// Filter by sidechain if requested
-		if req.Msg.Sidechain != nil && *req.Msg.Sidechain != w.Sidechain {
+		if req.Sidechain != nil && *req.Sidechain != w.Sidechain {
 			continue
 		}
 
 		pbWithdrawals = append(pbWithdrawals, withdrawalToProto(w))
 
 		// Apply limit if specified
-		if req.Msg.Limit != nil && len(pbWithdrawals) >= int(*req.Msg.Limit) {
+		if req.Limit != nil && len(pbWithdrawals) >= int(*req.Limit) {
 			break
 		}
 	}
 
-	return connect.NewResponse(&pb.GetDetectedWithdrawalsResponse{
+	return &pb.GetDetectedWithdrawalsResponse{
 		Withdrawals: pbWithdrawals,
-	}), nil
+	}, nil
 }
 
 func (s *Server) GetWithdrawalByTxid(
 	ctx context.Context,
-	req *connect.Request[pb.GetWithdrawalByTxidRequest],
-) (*connect.Response[pb.GetWithdrawalByTxidResponse], error) {
-	withdrawal, err := s.monitor.GetWithdrawalByTxid(ctx, req.Msg.Txid)
+	req *pb.GetWithdrawalByTxidRequest,
+) (*pb.GetWithdrawalByTxidResponse, error) {
+	withdrawal, err := s.monitor.GetWithdrawalByTxid(ctx, req.Txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get withdrawal %s: %w", req.Msg.Txid, err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get withdrawal %s: %s", req.Txid, err)).WithCause(err)
 	}
 
 	resp := &pb.GetWithdrawalByTxidResponse{}
@@ -66,7 +66,7 @@ func (s *Server) GetWithdrawalByTxid(
 		resp.Withdrawal = withdrawalToProto(*withdrawal)
 	}
 
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 func withdrawalToProto(w engines.DetectedWithdrawal) *pb.DetectedWithdrawal {
diff --git a/bitwindow/server/api/utils/utils.go b/bitwindow/server/api/utils/utils.go
index 366a4409f0..120fac0d21 100644
--- a/bitwindow/server/api/utils/utils.go
+++ b/bitwindow/server/api/utils/utils.go
@@ -2,10 +2,9 @@ package utils
 
 import (
 	"context"
-	"fmt"
 	"math"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"google.golang.org/protobuf/types/known/emptypb"
 
@@ -27,75 +26,75 @@ func New(chainParams *chaincfg.Params) *Server {
 }
 
 // ParseBitcoinURI implements utilsv1connect.UtilsServiceHandler
-func (s *Server) ParseBitcoinURI(_ context.Context, req *connect.Request[utilspb.ParseBitcoinURIRequest]) (*connect.Response[utilspb.ParseBitcoinURIResponse], error) {
-	result, err := engines.ParseBitcoinURI(req.Msg.Uri)
+func (s *Server) ParseBitcoinURI(_ context.Context, req *utilspb.ParseBitcoinURIRequest) (*utilspb.ParseBitcoinURIResponse, error) {
+	result, err := engines.ParseBitcoinURI(req.Uri)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&utilspb.ParseBitcoinURIResponse{
+	return &utilspb.ParseBitcoinURIResponse{
 		Address:     result.Address,
 		Amount:      result.Amount,
 		Label:       result.Label,
 		Message:     result.Message,
 		ExtraParams: result.ExtraParams,
-	}), nil
+	}, nil
 }
 
 // ValidateBitcoinURI implements utilsv1connect.UtilsServiceHandler
-func (s *Server) ValidateBitcoinURI(_ context.Context, req *connect.Request[utilspb.ValidateBitcoinURIRequest]) (*connect.Response[utilspb.ValidateBitcoinURIResponse], error) {
-	_, err := engines.ParseBitcoinURI(req.Msg.Uri)
+func (s *Server) ValidateBitcoinURI(_ context.Context, req *utilspb.ValidateBitcoinURIRequest) (*utilspb.ValidateBitcoinURIResponse, error) {
+	_, err := engines.ParseBitcoinURI(req.Uri)
 	valid := err == nil
 	errorMsg := ""
 	if err != nil {
 		errorMsg = err.Error()
 	}
 
-	return connect.NewResponse(&utilspb.ValidateBitcoinURIResponse{
+	return &utilspb.ValidateBitcoinURIResponse{
 		Valid: valid,
 		Error: errorMsg,
-	}), nil
+	}, nil
 }
 
 // DecodeBase58Check implements utilsv1connect.UtilsServiceHandler
-func (s *Server) DecodeBase58Check(_ context.Context, req *connect.Request[utilspb.DecodeBase58CheckRequest]) (*connect.Response[utilspb.DecodeBase58CheckResponse], error) {
-	result, err := engines.DecodeBase58Check(req.Msg.Input)
+func (s *Server) DecodeBase58Check(_ context.Context, req *utilspb.DecodeBase58CheckRequest) (*utilspb.DecodeBase58CheckResponse, error) {
+	result, err := engines.DecodeBase58Check(req.Input)
 	if err != nil {
-		return connect.NewResponse(&utilspb.DecodeBase58CheckResponse{
+		return &utilspb.DecodeBase58CheckResponse{
 			Valid: false,
 			Error: err.Error(),
-		}), nil
+		}, nil
 	}
 
-	return connect.NewResponse(&utilspb.DecodeBase58CheckResponse{
+	return &utilspb.DecodeBase58CheckResponse{
 		Valid:         true,
 		VersionByte:   int32(result.VersionByte),
 		Payload:       result.Payload,
 		Checksum:      result.Checksum,
 		ChecksumValid: result.ChecksumValid,
 		AddressType:   result.AddressType,
-	}), nil
+	}, nil
 }
 
 // EncodeBase58Check implements utilsv1connect.UtilsServiceHandler
-func (s *Server) EncodeBase58Check(_ context.Context, req *connect.Request[utilspb.EncodeBase58CheckRequest]) (*connect.Response[utilspb.EncodeBase58CheckResponse], error) {
-	if req.Msg.VersionByte < 0 || req.Msg.VersionByte > math.MaxUint8 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("version byte %d is not in the range 0 to 255", req.Msg.VersionByte))
+func (s *Server) EncodeBase58Check(_ context.Context, req *utilspb.EncodeBase58CheckRequest) (*utilspb.EncodeBase58CheckResponse, error) {
+	if req.VersionByte < 0 || req.VersionByte > math.MaxUint8 {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "version byte %d is not in the range 0 to 255", req.VersionByte)
 	}
-	return connect.NewResponse(&utilspb.EncodeBase58CheckResponse{
-		Encoded: engines.EncodeBase58Check(int(req.Msg.VersionByte), req.Msg.Data),
-	}), nil
+	return &utilspb.EncodeBase58CheckResponse{
+		Encoded: engines.EncodeBase58Check(int(req.VersionByte), req.Data),
+	}, nil
 }
 
 // CalculateMerkleTree implements utilsv1connect.UtilsServiceHandler
-func (s *Server) CalculateMerkleTree(_ context.Context, req *connect.Request[utilspb.CalculateMerkleTreeRequest]) (*connect.Response[utilspb.CalculateMerkleTreeResponse], error) {
-	result, err := engines.CalculateMerkleTree(req.Msg.Txids)
+func (s *Server) CalculateMerkleTree(_ context.Context, req *utilspb.CalculateMerkleTreeRequest) (*utilspb.CalculateMerkleTreeResponse, error) {
+	result, err := engines.CalculateMerkleTree(req.Txids)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	formatted := result.FormattedText
-	if !req.Msg.ShowRcb {
+	if !req.ShowRcb {
 		formatted = engines.FormatMerkleTree(result.Levels, nil)
 	}
 
@@ -112,46 +111,46 @@ func (s *Server) CalculateMerkleTree(_ context.Context, req *connect.Request[uti
 		}
 	}
 
-	return connect.NewResponse(&utilspb.CalculateMerkleTreeResponse{
+	return &utilspb.CalculateMerkleTreeResponse{
 		MerkleRoot:    result.MerkleRoot,
 		Levels:        levels,
 		FormattedText: formatted,
-	}), nil
+	}, nil
 }
 
 // GeneratePaperWallet implements utilsv1connect.UtilsServiceHandler
-func (s *Server) GeneratePaperWallet(_ context.Context, _ *connect.Request[emptypb.Empty]) (*connect.Response[utilspb.GeneratePaperWalletResponse], error) {
+func (s *Server) GeneratePaperWallet(_ context.Context, _ *emptypb.Empty) (*utilspb.GeneratePaperWalletResponse, error) {
 	keypair, err := engines.GeneratePaperWallet(s.chainParams)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&utilspb.GeneratePaperWalletResponse{
+	return &utilspb.GeneratePaperWalletResponse{
 		PrivateKeyWif: keypair.PrivateKeyWIF,
 		PublicAddress: keypair.PublicAddress,
 		PrivateKeyHex: keypair.PrivateKeyHex,
-	}), nil
+	}, nil
 }
 
 // ValidateWIF implements utilsv1connect.UtilsServiceHandler
-func (s *Server) ValidateWIF(_ context.Context, req *connect.Request[utilspb.ValidateWIFRequest]) (*connect.Response[utilspb.ValidateWIFResponse], error) {
-	valid := engines.ValidateWIF(req.Msg.Wif, s.chainParams)
+func (s *Server) ValidateWIF(_ context.Context, req *utilspb.ValidateWIFRequest) (*utilspb.ValidateWIFResponse, error) {
+	valid := engines.ValidateWIF(req.Wif, s.chainParams)
 
-	return connect.NewResponse(&utilspb.ValidateWIFResponse{
+	return &utilspb.ValidateWIFResponse{
 		Valid: valid,
-	}), nil
+	}, nil
 }
 
 // WIFToAddress implements utilsv1connect.UtilsServiceHandler
-func (s *Server) WIFToAddress(_ context.Context, req *connect.Request[utilspb.WIFToAddressRequest]) (*connect.Response[utilspb.WIFToAddressResponse], error) {
-	address, err := engines.WIFToAddress(req.Msg.Wif, s.chainParams)
+func (s *Server) WIFToAddress(_ context.Context, req *utilspb.WIFToAddressRequest) (*utilspb.WIFToAddressResponse, error) {
+	address, err := engines.WIFToAddress(req.Wif, s.chainParams)
 	if err != nil {
-		return connect.NewResponse(&utilspb.WIFToAddressResponse{
+		return &utilspb.WIFToAddressResponse{
 			Error: err.Error(),
-		}), nil
+		}, nil
 	}
 
-	return connect.NewResponse(&utilspb.WIFToAddressResponse{
+	return &utilspb.WIFToAddressResponse{
 		Address: address,
-	}), nil
+	}, nil
 }
diff --git a/bitwindow/server/api/utils/utils_test.go b/bitwindow/server/api/utils/utils_test.go
index 7429972000..aa5b478cd6 100644
--- a/bitwindow/server/api/utils/utils_test.go
+++ b/bitwindow/server/api/utils/utils_test.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -16,18 +16,18 @@ import (
 func TestEncodeBase58Check(t *testing.T) {
 	t.Parallel()
 
-	encode := func(t *testing.T, version int32) (*connect.Response[utilspb.EncodeBase58CheckResponse], error) {
-		return utils.New(&chaincfg.RegressionNetParams).EncodeBase58Check(t.Context(), connect.NewRequest(&utilspb.EncodeBase58CheckRequest{
+	encode := func(t *testing.T, version int32) (*utilspb.EncodeBase58CheckResponse, error) {
+		return utils.New(&chaincfg.RegressionNetParams).EncodeBase58Check(t.Context(), &utilspb.EncodeBase58CheckRequest{
 			VersionByte: version,
 			Data:        make([]byte, 20),
-		}))
+		})
 	}
 
 	t.Run("version 0 encodes", func(t *testing.T) {
 		t.Parallel()
 		resp, err := encode(t, 0)
 		require.NoError(t, err)
-		assert.Equal(t, "1111111111111111111114oLvT2", resp.Msg.Encoded)
+		assert.Equal(t, "1111111111111111111114oLvT2", resp.Encoded)
 	})
 
 	t.Run("version 255 encodes", func(t *testing.T) {
diff --git a/bitwindow/server/api/wallet/cheque_funding_height_test.go b/bitwindow/server/api/wallet/cheque_funding_height_test.go
index ef3296d078..0612249a45 100644
--- a/bitwindow/server/api/wallet/cheque_funding_height_test.go
+++ b/bitwindow/server/api/wallet/cheque_funding_height_test.go
@@ -3,7 +3,6 @@ package wallet_test
 import (
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/require"
 
 	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/database"
@@ -22,7 +21,7 @@ func TestCheckChequeFunding_RecordsTheFundingBlock(t *testing.T) {
 	fundingTxid := "feed0000feed0000feed0000feed0000feed0000feed0000feed0000feed0000"
 
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: chequeAddr,
 			utxos: []*orchpb.AddressUnspentOutput{
 				{Txid: fundingTxid, Vout: 0, ValueSats: 100_000_000, Confirmations: 3},
@@ -33,10 +32,10 @@ func TestCheckChequeFunding_RecordsTheFundingBlock(t *testing.T) {
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	_, err = cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	_, err = cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
 
 	var height int64
diff --git a/bitwindow/server/api/wallet/cheque_funding_test.go b/bitwindow/server/api/wallet/cheque_funding_test.go
index 0e9c87ca50..9879cc11c6 100644
--- a/bitwindow/server/api/wallet/cheque_funding_test.go
+++ b/bitwindow/server/api/wallet/cheque_funding_test.go
@@ -2,11 +2,10 @@ package wallet_test
 
 import (
 	"context"
-	"errors"
 	"sync/atomic"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/emptypb"
 
@@ -36,64 +35,64 @@ type fakeOrchestrator struct {
 }
 
 func (f *fakeOrchestrator) GetWalletStatus(
-	context.Context, *connect.Request[orchpb.GetWalletStatusRequest],
-) (*connect.Response[orchpb.GetWalletStatusResponse], error) {
+	context.Context, *orchpb.GetWalletStatusRequest,
+) (*orchpb.GetWalletStatusResponse, error) {
 	state := orchpb.WalletState_WALLET_STATE_UNLOCKED
 	if f.locked {
 		state = orchpb.WalletState_WALLET_STATE_LOCKED
 	}
-	return connect.NewResponse(&orchpb.GetWalletStatusResponse{State: state}), nil
+	return &orchpb.GetWalletStatusResponse{State: state}, nil
 }
 
 func (f *fakeOrchestrator) ListWallets(
-	context.Context, *connect.Request[orchpb.ListWalletsRequest],
-) (*connect.Response[orchpb.ListWalletsResponse], error) {
+	context.Context, *orchpb.ListWalletsRequest,
+) (*orchpb.ListWalletsResponse, error) {
 	resp := &orchpb.ListWalletsResponse{ActiveWalletId: testWalletID}
 	if !f.locked {
 		resp.Wallets = []*orchpb.WalletMetadata{{Id: testWalletID, WalletType: orchpb.WalletType_WALLET_TYPE_ELECTRUM}}
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 // The runtime hands over the frozen coins on a timer, whatever else runs.
 func (f *fakeOrchestrator) SetFrozenCoins(
-	context.Context, *connect.Request[orchpb.SetFrozenCoinsRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	context.Context, *orchpb.SetFrozenCoinsRequest,
+) (*emptypb.Empty, error) {
+	return &emptypb.Empty{}, nil
 }
 
 // The pollers ask before each tick. A full-mode answer keeps them running,
 // which is what these tests exercise.
 func (f *fakeOrchestrator) GetNodeMode(
-	_ context.Context, _ *connect.Request[orchpb.GetNodeModeRequest],
-) (*connect.Response[orchpb.GetNodeModeResponse], error) {
-	return connect.NewResponse(&orchpb.GetNodeModeResponse{
+	_ context.Context, _ *orchpb.GetNodeModeRequest,
+) (*orchpb.GetNodeModeResponse, error) {
+	return &orchpb.GetNodeModeResponse{
 		Mode: orchpb.NodeMode_NODE_MODE_FULL,
-	}), nil
+	}, nil
 }
 
 // Seeds come from the local wallet file in tests, so refuse here and let the
 // engine fall through.
 func (f *fakeOrchestrator) GetWalletSeed(
-	_ context.Context, _ *connect.Request[orchpb.GetWalletSeedRequest],
-) (*connect.Response[orchpb.GetWalletSeedResponse], error) {
+	_ context.Context, _ *orchpb.GetWalletSeedRequest,
+) (*orchpb.GetWalletSeedResponse, error) {
 	if f.seedHex != "" {
-		return connect.NewResponse(&orchpb.GetWalletSeedResponse{SeedHex: f.seedHex}), nil
+		return &orchpb.GetWalletSeedResponse{SeedHex: f.seedHex}, nil
 	}
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("no orchestrator seed in tests"))
+	return nil, connect.NewError(connect.CodeUnimplemented, "no orchestrator seed in tests")
 }
 
 func (f *fakeOrchestrator) GetAddressUnspent(
-	_ context.Context, req *connect.Request[orchpb.GetAddressUnspentRequest],
-) (*connect.Response[orchpb.GetAddressUnspentResponse], error) {
-	if req.Msg.Address != f.address {
-		return connect.NewResponse(&orchpb.GetAddressUnspentResponse{}), nil
+	_ context.Context, req *orchpb.GetAddressUnspentRequest,
+) (*orchpb.GetAddressUnspentResponse, error) {
+	if req.Address != f.address {
+		return &orchpb.GetAddressUnspentResponse{}, nil
 	}
 	utxos := f.utxos
 	if f.perCall != nil {
 		utxos = f.perCall(f.calls.Add(1))
 	}
-	return connect.NewResponse(&orchpb.GetAddressUnspentResponse{Utxos: utxos, TipHeight: 100}), nil
+	return &orchpb.GetAddressUnspentResponse{Utxos: utxos, TipHeight: 100}, nil
 }
 
 func TestCheckChequeFunding_UnfundedCheck(t *testing.T) {
@@ -102,18 +101,18 @@ func TestCheckChequeFunding_UnfundedCheck(t *testing.T) {
 
 	chequeAddr := "tb1qtestaddress000000000000000000000000000"
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{address: chequeAddr})),
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{address: chequeAddr})),
 	)
 
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	resp, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	resp, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.False(t, resp.Msg.Funded)
+	require.False(t, resp.Funded)
 }
 
 func TestCheckChequeFunding_DetectsUnconfirmedTx(t *testing.T) {
@@ -124,7 +123,7 @@ func TestCheckChequeFunding_DetectsUnconfirmedTx(t *testing.T) {
 	fundingTxid := "abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234"
 
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: chequeAddr,
 			utxos: []*orchpb.AddressUnspentOutput{
 				{Txid: fundingTxid, Vout: 0, ValueSats: 100_000_000, Confirmations: 0},
@@ -135,14 +134,14 @@ func TestCheckChequeFunding_DetectsUnconfirmedTx(t *testing.T) {
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	resp, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	resp, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.True(t, resp.Msg.Funded)
-	require.Equal(t, []string{fundingTxid}, resp.Msg.FundedTxids)
-	require.EqualValues(t, 0, resp.Msg.MinConfirmations)
+	require.True(t, resp.Funded)
+	require.Equal(t, []string{fundingTxid}, resp.FundedTxids)
+	require.EqualValues(t, 0, resp.MinConfirmations)
 }
 
 func TestCheckChequeFunding_DetectsConfirmedTx(t *testing.T) {
@@ -152,7 +151,7 @@ func TestCheckChequeFunding_DetectsConfirmedTx(t *testing.T) {
 	chequeAddr := "tb1qconfirmedtestaddr0000000000000000000000"
 
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: chequeAddr,
 			utxos: []*orchpb.AddressUnspentOutput{
 				{
@@ -168,14 +167,14 @@ func TestCheckChequeFunding_DetectsConfirmedTx(t *testing.T) {
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 50_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	resp, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	resp, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.True(t, resp.Msg.Funded)
-	require.Equal(t, uint64(50_000_000), resp.Msg.ActualAmountSats)
-	require.EqualValues(t, 3, resp.Msg.MinConfirmations)
+	require.True(t, resp.Funded)
+	require.Equal(t, uint64(50_000_000), resp.ActualAmountSats)
+	require.EqualValues(t, 3, resp.MinConfirmations)
 }
 
 func TestCheckChequeFunding_PersistsFundingToDatabase(t *testing.T) {
@@ -186,7 +185,7 @@ func TestCheckChequeFunding_PersistsFundingToDatabase(t *testing.T) {
 	fundingTxid := "dead0000dead0000dead0000dead0000dead0000dead0000dead0000dead0000"
 
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: chequeAddr,
 			utxos: []*orchpb.AddressUnspentOutput{
 				{Txid: fundingTxid, Vout: 0, ValueSats: 100_000_000},
@@ -197,12 +196,12 @@ func TestCheckChequeFunding_PersistsFundingToDatabase(t *testing.T) {
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	resp, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	resp, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.True(t, resp.Msg.Funded)
+	require.True(t, resp.Funded)
 
 	cheque, err := cheques.Get(t.Context(), db, testWalletID, chequeID)
 	require.NoError(t, err)
@@ -221,7 +220,7 @@ func TestCheckChequeFunding_MultipleUTXOs(t *testing.T) {
 	second := "bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000"
 
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: chequeAddr,
 			utxos: []*orchpb.AddressUnspentOutput{
 				{Txid: first, Vout: 0, ValueSats: 100_000_000, Confirmations: 0},
@@ -233,17 +232,17 @@ func TestCheckChequeFunding_MultipleUTXOs(t *testing.T) {
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 200_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	resp, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	resp, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.True(t, resp.Msg.Funded)
-	require.Equal(t, uint64(200_000_000), resp.Msg.ActualAmountSats)
-	require.Len(t, resp.Msg.FundedTxids, 2)
-	require.Contains(t, resp.Msg.FundedTxids, first)
-	require.Contains(t, resp.Msg.FundedTxids, second)
-	require.EqualValues(t, 0, resp.Msg.MinConfirmations, "the least-confirmed output sets the floor")
+	require.True(t, resp.Funded)
+	require.Equal(t, uint64(200_000_000), resp.ActualAmountSats)
+	require.Len(t, resp.FundedTxids, 2)
+	require.Contains(t, resp.FundedTxids, first)
+	require.Contains(t, resp.FundedTxids, second)
+	require.EqualValues(t, 0, resp.MinConfirmations, "the least-confirmed output sets the floor")
 }
 
 func TestCheckChequeFunding_TwoOutputsFromOneTransaction(t *testing.T) {
@@ -253,7 +252,7 @@ func TestCheckChequeFunding_TwoOutputsFromOneTransaction(t *testing.T) {
 	address := "tb1qtestaddress000000000000000000000000000"
 	txid := "aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000"
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: address,
 			utxos: []*orchpb.AddressUnspentOutput{
 				{Txid: txid, Vout: 1, ValueSats: 600, Confirmations: 3},
@@ -265,14 +264,14 @@ func TestCheckChequeFunding_TwoOutputsFromOneTransaction(t *testing.T) {
 	require.NoError(t, err)
 
 	for range 2 {
-		resp, err := cli.CheckChequeFunding(ctx, connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+		resp, err := cli.CheckChequeFunding(ctx, &walletv1.CheckChequeFundingRequest{
 			WalletId: testWalletID,
 			Id:       id,
-		}))
+		})
 		require.NoError(t, err)
-		require.True(t, resp.Msg.Funded)
-		require.Equal(t, uint64(1000), resp.Msg.ActualAmountSats)
-		require.Equal(t, []string{txid}, resp.Msg.FundedTxids)
+		require.True(t, resp.Funded)
+		require.Equal(t, uint64(1000), resp.ActualAmountSats)
+		require.Equal(t, []string{txid}, resp.FundedTxids)
 	}
 
 	type outputRow struct {
@@ -309,7 +308,7 @@ func TestCheckChequeFunding_RefusesDeleteAfterAnotherPayment(t *testing.T) {
 			first := "aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000aaaa0000"
 			second := "bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000bbbb0000"
 			cli := walletv1connect.NewWalletServiceClient(
-				apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+				apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 					address: address,
 					perCall: func(n int32) []*orchpb.AddressUnspentOutput {
 						if n == 1 {
@@ -321,18 +320,18 @@ func TestCheckChequeFunding_RefusesDeleteAfterAnotherPayment(t *testing.T) {
 			)
 			id, err := cheques.Create(ctx, db, testWalletID, 0, 1000, address)
 			require.NoError(t, err)
-			request := connect.NewRequest(&walletv1.CheckChequeFundingRequest{WalletId: testWalletID, Id: id})
+			request := &walletv1.CheckChequeFundingRequest{WalletId: testWalletID, Id: id}
 			_, err = cli.CheckChequeFunding(ctx, request)
 			require.NoError(t, err)
 			require.NoError(t, cheques.UpdateSwept(ctx, db, testWalletID, id, "sweep"))
 
 			resp, err := cli.CheckChequeFunding(ctx, request)
 			require.NoError(t, err)
-			require.Equal(t, uint64(tt.amount), resp.Msg.ActualAmountSats)
-			_, err = cli.DeleteCheque(ctx, connect.NewRequest(&walletv1.DeleteChequeRequest{
+			require.Equal(t, uint64(tt.amount), resp.ActualAmountSats)
+			_, err = cli.DeleteCheque(ctx, &walletv1.DeleteChequeRequest{
 				WalletId: testWalletID,
 				Id:       id,
-			}))
+			})
 			require.ErrorContains(t, err, "cannot delete funded cheque")
 			require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 
@@ -352,7 +351,7 @@ func TestCheckChequeFunding_PartialFunding(t *testing.T) {
 	chequeAddr := "tb1qpartialtestaddr0000000000000000000000000"
 
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: chequeAddr,
 			utxos: []*orchpb.AddressUnspentOutput{
 				{
@@ -368,14 +367,14 @@ func TestCheckChequeFunding_PartialFunding(t *testing.T) {
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	resp, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	resp, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.False(t, resp.Msg.Funded, "should NOT be fully funded with only half the amount")
-	require.Equal(t, uint64(50_000_000), resp.Msg.ActualAmountSats)
-	require.Len(t, resp.Msg.FundedTxids, 1, "should still track the partial txid")
+	require.False(t, resp.Funded, "should NOT be fully funded with only half the amount")
+	require.Equal(t, uint64(50_000_000), resp.ActualAmountSats)
+	require.Len(t, resp.FundedTxids, 1, "should still track the partial txid")
 }
 
 // Mirrors the Flutter polling loop: the first poll can race the broadcast and
@@ -388,7 +387,7 @@ func TestCheckChequeFunding_PollAfterSend(t *testing.T) {
 	fundingTxid := "feed0000feed0000feed0000feed0000feed0000feed0000feed0000feed0000"
 
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{
 			address: chequeAddr,
 			perCall: func(n int32) []*orchpb.AddressUnspentOutput {
 				if n == 1 {
@@ -404,22 +403,22 @@ func TestCheckChequeFunding_PollAfterSend(t *testing.T) {
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 210_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	respFirst, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	respFirst, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.False(t, respFirst.Msg.Funded)
-	require.Empty(t, respFirst.Msg.FundedTxids)
+	require.False(t, respFirst.Funded)
+	require.Empty(t, respFirst.FundedTxids)
 
-	respSecond, err := cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	respSecond, err := cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.NoError(t, err)
-	require.True(t, respSecond.Msg.Funded, "second poll should detect the broadcast")
-	require.Equal(t, []string{fundingTxid}, respSecond.Msg.FundedTxids)
-	require.Equal(t, uint64(210_000_000), respSecond.Msg.ActualAmountSats)
+	require.True(t, respSecond.Funded, "second poll should detect the broadcast")
+	require.Equal(t, []string{fundingTxid}, respSecond.FundedTxids)
+	require.Equal(t, uint64(210_000_000), respSecond.ActualAmountSats)
 
 	persisted, err := cheques.Get(t.Context(), db, testWalletID, chequeID)
 	require.NoError(t, err)
@@ -437,15 +436,15 @@ func TestCheckChequeFunding_NeedsElectrum(t *testing.T) {
 	chequeAddr := "tb1qnoelectrumtestaddr0000000000000000000"
 
 	// No WithOrchestrator: cheques have no other chain source.
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db))
 
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	_, err = cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	_, err = cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 }
 
@@ -455,7 +454,7 @@ func TestCheckChequeFunding_ReportsAFailedSweptMark(t *testing.T) {
 
 	chequeAddr := "tb1qsweptmarktestaddr00000000000000000000000"
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{address: chequeAddr})),
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{address: chequeAddr})),
 	)
 
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
@@ -467,10 +466,10 @@ func TestCheckChequeFunding_ReportsAFailedSweptMark(t *testing.T) {
 		BEGIN SELECT RAISE(ABORT, 'sweep refused'); END`)
 	require.NoError(t, err)
 
-	_, err = cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	_, err = cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 	require.ErrorContains(t, err, "mark cheque swept")
 }
@@ -481,7 +480,7 @@ func TestChequeReads_ReportAFailedKeyDerivation(t *testing.T) {
 
 	chequeAddr := "tb1qkeyfailtestaddr000000000000000000000000"
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{address: chequeAddr, seedHex: "not-hex"})),
+		apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{address: chequeAddr, seedHex: "not-hex"})),
 	)
 
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
@@ -490,18 +489,18 @@ func TestChequeReads_ReportAFailedKeyDerivation(t *testing.T) {
 		[]cheques.FundingOutput{{Txid: "f00d0000f00d0000f00d0000f00d0000f00d0000f00d0000f00d0000f00d0000"}}, 100_000_000))
 
 	t.Run("GetCheque", func(t *testing.T) {
-		_, err := cli.GetCheque(t.Context(), connect.NewRequest(&walletv1.GetChequeRequest{
+		_, err := cli.GetCheque(t.Context(), &walletv1.GetChequeRequest{
 			WalletId: testWalletID,
 			Id:       chequeID,
-		}))
+		})
 		require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 		require.ErrorContains(t, err, "private key")
 	})
 
 	t.Run("ListCheques", func(t *testing.T) {
-		_, err := cli.ListCheques(t.Context(), connect.NewRequest(&walletv1.ListChequesRequest{
+		_, err := cli.ListCheques(t.Context(), &walletv1.ListChequesRequest{
 			WalletId: testWalletID,
-		}))
+		})
 		require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 		require.ErrorContains(t, err, "private key")
 	})
@@ -512,9 +511,9 @@ type downOrchestrator struct {
 }
 
 func (d *downOrchestrator) GetAddressUnspent(
-	context.Context, *connect.Request[orchpb.GetAddressUnspentRequest],
-) (*connect.Response[orchpb.GetAddressUnspentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnavailable, errors.New("esplora down"))
+	context.Context, *orchpb.GetAddressUnspentRequest,
+) (*orchpb.GetAddressUnspentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnavailable, "esplora down")
 }
 
 func TestCheckChequeFunding_FailedQueryNamesTheAddress(t *testing.T) {
@@ -523,16 +522,16 @@ func TestCheckChequeFunding_FailedQueryNamesTheAddress(t *testing.T) {
 
 	chequeAddr := "tb1qtestaddress000000000000000000000000000"
 	cli := walletv1connect.NewWalletServiceClient(
-		apitests.API(t, db, apitests.WithOrchestrator(&downOrchestrator{&fakeOrchestrator{address: chequeAddr}})),
+		apitests.RPC(t, db, apitests.WithOrchestrator(&downOrchestrator{&fakeOrchestrator{address: chequeAddr}})),
 	)
 
 	chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 100_000_000, chequeAddr)
 	require.NoError(t, err)
 
-	_, err = cli.CheckChequeFunding(t.Context(), connect.NewRequest(&walletv1.CheckChequeFundingRequest{
+	_, err = cli.CheckChequeFunding(t.Context(), &walletv1.CheckChequeFundingRequest{
 		WalletId: testWalletID,
 		Id:       chequeID,
-	}))
+	})
 	require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	require.ErrorContains(t, err, "query UTXOs of "+chequeAddr)
 	require.ErrorContains(t, err, "esplora down")
diff --git a/bitwindow/server/api/wallet/frozen_send_test.go b/bitwindow/server/api/wallet/frozen_send_test.go
index 13a1e2b8fa..1cccc00c6f 100644
--- a/bitwindow/server/api/wallet/frozen_send_test.go
+++ b/bitwindow/server/api/wallet/frozen_send_test.go
@@ -3,7 +3,8 @@ package wallet_test
 import (
 	"testing"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -26,21 +27,21 @@ func TestSendRefusesAFrozenRequiredInput(t *testing.T) {
 	db := database.Test(t)
 	mockOrch := mocks.NewMockWalletManagerServiceClient(ctrl)
 	apitests.ExpectOrchestratorReads(mockOrch)
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(mockOrch)))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(mockOrch)))
 
 	ctx := t.Context()
 	frozen := true
-	_, err := cli.SetUTXOMetadata(ctx, connect.NewRequest(&walletv1.SetUTXOMetadataRequest{
+	_, err := cli.SetUTXOMetadata(ctx, &walletv1.SetUTXOMetadataRequest{
 		Outpoint: "frozen:0",
 		IsFrozen: &frozen,
-	}))
+	})
 	require.NoError(t, err)
 
-	_, err = cli.SendTransaction(ctx, connect.NewRequest(&walletv1.SendTransactionRequest{
+	_, err = cli.SendTransaction(ctx, &walletv1.SendTransactionRequest{
 		WalletId:       "test-wallet-id-1234",
 		Destinations:   map[string]uint64{"bcrt1qdest": 50_000},
 		RequiredInputs: []*walletv1.UnspentOutput{{Output: "frozen:0"}},
-	}))
+	})
 	require.ErrorContains(t, err, engines.ErrFrozenInput.Error())
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 }
@@ -55,14 +56,14 @@ func TestSetUTXOMetadataReportsAFailedPush(t *testing.T) {
 	mockOrch.EXPECT().
 		SetFrozenCoins(gomock.Any(), gomock.Any()).
 		AnyTimes().
-		Return((*connect.Response[emptypb.Empty])(nil), connect.NewError(connect.CodeUnavailable, assert.AnError))
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(mockOrch)))
+		Return((*emptypb.Empty)(nil), connect.NewError(connect.CodeUnavailable, assert.AnError.Error()).WithCause(assert.AnError))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(mockOrch)))
 
 	frozen := true
-	_, err := cli.SetUTXOMetadata(t.Context(), connect.NewRequest(&walletv1.SetUTXOMetadataRequest{
+	_, err := cli.SetUTXOMetadata(t.Context(), &walletv1.SetUTXOMetadataRequest{
 		Outpoint: "aa:0",
 		IsFrozen: &frozen,
-	}))
+	})
 	require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 }
 
@@ -72,23 +73,23 @@ func TestSendRefusesAFrozenInputInAnySpelling(t *testing.T) {
 	db := database.Test(t)
 	mockOrch := mocks.NewMockWalletManagerServiceClient(ctrl)
 	apitests.ExpectOrchestratorReads(mockOrch)
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(mockOrch)))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(mockOrch)))
 
 	ctx := t.Context()
 	frozen := true
-	_, err := cli.SetUTXOMetadata(ctx, connect.NewRequest(&walletv1.SetUTXOMetadataRequest{
+	_, err := cli.SetUTXOMetadata(ctx, &walletv1.SetUTXOMetadataRequest{
 		Outpoint: "abcdef:1",
 		IsFrozen: &frozen,
-	}))
+	})
 	require.NoError(t, err)
 
 	for _, spelling := range []string{"ABCDEF:1", "abcdef:01", "ABCDEF:01"} {
 		t.Run(spelling, func(t *testing.T) {
-			_, err := cli.SendTransaction(t.Context(), connect.NewRequest(&walletv1.SendTransactionRequest{
+			_, err := cli.SendTransaction(t.Context(), &walletv1.SendTransactionRequest{
 				WalletId:       "test-wallet-id-1234",
 				Destinations:   map[string]uint64{"bcrt1qdest": 50_000},
 				RequiredInputs: []*walletv1.UnspentOutput{{Output: spelling}},
-			}))
+			})
 			require.ErrorContains(t, err, "is frozen")
 		})
 	}
@@ -107,31 +108,31 @@ func TestSendTransactionWithRequiredInputs(t *testing.T) {
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
 			DoAndReturn(func(
-				_ any, req *connect.Request[orchpb.SendTransactionRequest],
-			) (*connect.Response[orchpb.SendTransactionResponse], error) {
-				sent = append(sent, req.Msg)
-				return connect.NewResponse(&orchpb.SendTransactionResponse{Txid: "sent"}), nil
+				_ any, req *orchpb.SendTransactionRequest,
+			) (*orchpb.SendTransactionResponse, error) {
+				sent = append(sent, req)
+				return &orchpb.SendTransactionResponse{Txid: "sent"}, nil
 			}).
 			Times(1)
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
 		mockBitcoind.EXPECT().GetRawMempool(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&corepb.GetRawMempoolResponse{}), nil).AnyTimes()
+			Return(connectv1.NewResponse(&corepb.GetRawMempoolResponse{}), nil).AnyTimes()
 		mockBitcoind.EXPECT().ListUnspent(gomock.Any(), gomock.Any()).Times(0)
 		mockBitcoind.EXPECT().CreateRawTransaction(gomock.Any(), gomock.Any()).Times(0)
 		mockBitcoind.EXPECT().SignRawTransactionWithWallet(gomock.Any(), gomock.Any()).Times(0)
 		mockBitcoind.EXPECT().SendRawTransaction(gomock.Any(), gomock.Any()).Times(0)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db,
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db,
 			apitests.WithOrchestrator(mockOrch), apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.SendTransaction(t.Context(), connect.NewRequest(&walletv1.SendTransactionRequest{
+		resp, err := cli.SendTransaction(t.Context(), &walletv1.SendTransactionRequest{
 			WalletId:       testWalletID,
 			Destinations:   map[string]uint64{"bcrt1qdest": 50_000},
 			FixedFeeSats:   500,
 			RequiredInputs: []*walletv1.UnspentOutput{{Output: txid + ":1", ValueSats: 80_000}},
-		}))
+		})
 		require.NoError(t, err)
-		require.Equal(t, "sent", resp.Msg.Txid)
+		require.Equal(t, "sent", resp.Txid)
 
 		require.Len(t, sent, 1)
 		require.Equal(t, testWalletID, sent[0].WalletId)
@@ -154,13 +155,13 @@ func TestSendTransactionWithRequiredInputs(t *testing.T) {
 			mockOrch := mocks.NewMockWalletManagerServiceClient(ctrl)
 			apitests.ExpectOrchestratorReads(mockOrch)
 			mockOrch.EXPECT().SendTransaction(gomock.Any(), gomock.Any()).Times(0)
-			cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(mockOrch)))
+			cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(mockOrch)))
 
-			_, err := cli.SendTransaction(t.Context(), connect.NewRequest(&walletv1.SendTransactionRequest{
+			_, err := cli.SendTransaction(t.Context(), &walletv1.SendTransactionRequest{
 				WalletId:       testWalletID,
 				Destinations:   map[string]uint64{"bcrt1qdest": 50_000},
 				RequiredInputs: []*walletv1.UnspentOutput{{Output: outpoint}},
-			}))
+			})
 			require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		})
 	}
diff --git a/bitwindow/server/api/wallet/immature_test.go b/bitwindow/server/api/wallet/immature_test.go
index caceeff8a2..29be861b74 100644
--- a/bitwindow/server/api/wallet/immature_test.go
+++ b/bitwindow/server/api/wallet/immature_test.go
@@ -3,7 +3,7 @@ package wallet_test
 import (
 	"testing"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
@@ -34,19 +34,19 @@ func TestImmatureCoinbase(t *testing.T) {
 		mockOrch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 		mockOrch.EXPECT().
 			GetBalance(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.GetBalanceResponse{
+			Return(&orchpb.GetBalanceResponse{
 				ConfirmedSats:   100_000,
 				UnconfirmedSats: 50_000,
 				ImmatureSats:    625_000_000,
-			}), nil)
+			}, nil)
 		apitests.ExpectOrchestratorReads(mockOrch)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(mockOrch)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(mockOrch)))
 
-		resp, err := cli.GetBalance(t.Context(), connect.NewRequest(&walletv1.GetBalanceRequest{WalletId: testWalletID}))
+		resp, err := cli.GetBalance(t.Context(), &walletv1.GetBalanceRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Equal(t, uint64(100_000), resp.Msg.ConfirmedSatoshi)
-		require.Equal(t, uint64(50_000), resp.Msg.PendingSatoshi)
-		require.Equal(t, uint64(625_000_000), resp.Msg.ImmatureSatoshi)
+		require.Equal(t, uint64(100_000), resp.ConfirmedSatoshi)
+		require.Equal(t, uint64(50_000), resp.PendingSatoshi)
+		require.Equal(t, uint64(625_000_000), resp.ImmatureSatoshi)
 	})
 
 	t.Run("electrum transactions mark an immature coinbase", func(t *testing.T) {
@@ -56,19 +56,19 @@ func TestImmatureCoinbase(t *testing.T) {
 		mockOrch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 		mockOrch.EXPECT().
 			ListTransactions(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.ListTransactionsResponse{
+			Return(&orchpb.ListTransactionsResponse{
 				Transactions: []*orchpb.TransactionEntry{
 					{Txid: "maturing", Category: "immature", AmountSats: 312_500_000, Confirmations: 10},
 					{Txid: "mature", Category: "generate", AmountSats: 312_500_000, Confirmations: 150},
 					{Txid: "payment", Category: "receive", AmountSats: 15_000_000, Confirmations: 3},
 				},
-			}), nil)
+			}, nil)
 		apitests.ExpectOrchestratorReads(mockOrch)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(mockOrch), apitests.WithValidator(chainTipValidator(t, 200))))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(mockOrch), apitests.WithValidator(chainTipValidator(t, 200))))
 
-		resp, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		resp, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Equal(t, map[string]bool{"maturing": true, "mature": false, "payment": false}, immatureByTxid(resp.Msg.Transactions))
+		require.Equal(t, map[string]bool{"maturing": true, "mature": false, "payment": false}, immatureByTxid(resp.Transactions))
 	})
 
 	t.Run("core balance reports immature coins apart", func(t *testing.T) {
@@ -78,17 +78,17 @@ func TestImmatureCoinbase(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 		mockBitcoind.EXPECT().
 			GetBalances(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&corepb.GetBalancesResponse{
+			Return(connectv1.NewResponse(&corepb.GetBalancesResponse{
 				Mine: &corepb.GetBalancesResponse_Mine{Trusted: 1.5, UntrustedPending: 0.25, Immature: 6.25},
 			}), nil)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.GetBalance(t.Context(), connect.NewRequest(&walletv1.GetBalanceRequest{WalletId: testWalletID}))
+		resp, err := cli.GetBalance(t.Context(), &walletv1.GetBalanceRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Equal(t, uint64(150_000_000), resp.Msg.ConfirmedSatoshi)
-		require.Equal(t, uint64(25_000_000), resp.Msg.PendingSatoshi)
-		require.Equal(t, uint64(625_000_000), resp.Msg.ImmatureSatoshi)
+		require.Equal(t, uint64(150_000_000), resp.ConfirmedSatoshi)
+		require.Equal(t, uint64(25_000_000), resp.PendingSatoshi)
+		require.Equal(t, uint64(625_000_000), resp.ImmatureSatoshi)
 	})
 
 	t.Run("core transactions mark an immature coinbase", func(t *testing.T) {
@@ -101,7 +101,7 @@ func TestImmatureCoinbase(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 		mockBitcoind.EXPECT().
 			ListTransactions(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&corepb.ListTransactionsResponse{
+			Return(connectv1.NewResponse(&corepb.ListTransactionsResponse{
 				Transactions: []*corepb.GetTransactionResponse{
 					{Txid: "maturing", Amount: 3.125, Confirmations: 10, Details: detail(corepb.GetTransactionResponse_CATEGORY_IMMATURE)},
 					{Txid: "mature", Amount: 3.125, Confirmations: 150, Details: detail(corepb.GetTransactionResponse_CATEGORY_GENERATE)},
@@ -111,10 +111,10 @@ func TestImmatureCoinbase(t *testing.T) {
 			AnyTimes()
 		expectCoreTip(mockBitcoind, 200)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		resp, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Equal(t, map[string]bool{"maturing": true, "mature": false, "payment": false}, immatureByTxid(resp.Msg.Transactions))
+		require.Equal(t, map[string]bool{"maturing": true, "mature": false, "payment": false}, immatureByTxid(resp.Transactions))
 	})
 }
diff --git a/bitwindow/server/api/wallet/sweep_cheque_test.go b/bitwindow/server/api/wallet/sweep_cheque_test.go
index 8eac5f4aad..b3826706a3 100644
--- a/bitwindow/server/api/wallet/sweep_cheque_test.go
+++ b/bitwindow/server/api/wallet/sweep_cheque_test.go
@@ -5,7 +5,7 @@ import (
 	"database/sql"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -29,10 +29,10 @@ type broadcastOrchestrator struct {
 }
 
 func (b *broadcastOrchestrator) BroadcastElectrumTransaction(
-	_ context.Context, req *connect.Request[orchpb.BroadcastElectrumTransactionRequest],
-) (*connect.Response[orchpb.BroadcastElectrumTransactionResponse], error) {
-	b.broadcasts = append(b.broadcasts, req.Msg.TxHex)
-	return connect.NewResponse(&orchpb.BroadcastElectrumTransactionResponse{Txid: "swept-txid"}), nil
+	_ context.Context, req *orchpb.BroadcastElectrumTransactionRequest,
+) (*orchpb.BroadcastElectrumTransactionResponse, error) {
+	b.broadcasts = append(b.broadcasts, req.TxHex)
+	return &orchpb.BroadcastElectrumTransactionResponse{Txid: "swept-txid"}, nil
 }
 
 func TestSweepChequeOnALockedWallet(t *testing.T) {
@@ -59,18 +59,18 @@ func TestSweepChequeOnALockedWallet(t *testing.T) {
 
 	t.Run("the claim needs no unlock", func(t *testing.T) {
 		cli := walletv1connect.NewWalletServiceClient(
-			apitests.API(t, db, apitests.WithOrchestrator(orchestrator)),
+			apitests.RPC(t, db, apitests.WithOrchestrator(orchestrator)),
 		)
 
-		resp, err := cli.SweepCheque(t.Context(), connect.NewRequest(&walletv1.SweepChequeRequest{
+		resp, err := cli.SweepCheque(t.Context(), &walletv1.SweepChequeRequest{
 			WalletId:           testWalletID,
 			PrivateKeyWif:      wif.String(),
 			DestinationAddress: candidates[0].Address,
 			FeeSatPerVbyte:     1,
-		}))
+		})
 		require.NoError(t, err)
-		require.Equal(t, "swept-txid", resp.Msg.Txid)
-		require.Equal(t, uint64(100_000), resp.Msg.AmountSats)
+		require.Equal(t, "swept-txid", resp.Txid)
+		require.Equal(t, uint64(100_000), resp.AmountSats)
 		require.Len(t, orchestrator.broadcasts, 1)
 	})
 }
@@ -94,13 +94,13 @@ func TestSweepChequeMarksTheCheque(t *testing.T) {
 				Confirmations: 3,
 			}},
 		}}
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(orchestrator)))
-		_, err := cli.SweepCheque(t.Context(), connect.NewRequest(&walletv1.SweepChequeRequest{
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(orchestrator)))
+		_, err := cli.SweepCheque(t.Context(), &walletv1.SweepChequeRequest{
 			WalletId:           testWalletID,
 			PrivateKeyWif:      wif.String(),
 			DestinationAddress: candidates[0].Address,
 			FeeSatPerVbyte:     1,
-		}))
+		})
 		return orchestrator, err
 	}
 
@@ -144,14 +144,14 @@ func TestSweepChequeRefusesAWIFOfAnotherNetwork(t *testing.T) {
 	mainnetWIF, err := btcutil.NewWIF(privKey, &chaincfg.MainNetParams, true)
 	require.NoError(t, err)
 	orchestrator := &broadcastOrchestrator{fakeOrchestrator: &fakeOrchestrator{}}
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(orchestrator)))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(orchestrator)))
 
-	_, err = cli.SweepCheque(t.Context(), connect.NewRequest(&walletv1.SweepChequeRequest{
+	_, err = cli.SweepCheque(t.Context(), &walletv1.SweepChequeRequest{
 		WalletId:           testWalletID,
 		PrivateKeyWif:      mainnetWIF.String(),
 		DestinationAddress: "tb1q6rz28mcfaxtmd6v789l9rrlrusdprr9pqcpvkl",
 		FeeSatPerVbyte:     1,
-	}))
+	})
 	require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	require.ErrorContains(t, err, "WIF is not for network")
 	assert.Empty(t, orchestrator.broadcasts)
@@ -212,22 +212,22 @@ func TestPreviewSweep(t *testing.T) {
 			db := database.Test(t)
 			wif, candidates := newKey(t, &chaincfg.SigNetParams, tt.compressed)
 			source := candidates[tt.fundedIndex]
-			cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(
+			cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(
 				&fakeOrchestrator{address: source.Address, utxos: tt.utxos},
 			)))
 
-			resp, err := cli.PreviewSweep(t.Context(), connect.NewRequest(&walletv1.PreviewSweepRequest{
+			resp, err := cli.PreviewSweep(t.Context(), &walletv1.PreviewSweepRequest{
 				PrivateKeyWif:  wif.String(),
 				FeeSatPerVbyte: tt.feeRate,
-			}))
+			})
 			require.NoError(t, err)
-			assert.Equal(t, source.Address, resp.Msg.Address)
-			assert.Equal(t, tt.wantKind, resp.Msg.AddressKind)
-			assert.Equal(t, uint32(len(tt.utxos)), resp.Msg.OutputCount)
-			assert.Equal(t, uint64(lo.SumBy(tt.utxos, func(u *orchpb.AddressUnspentOutput) int64 { return u.ValueSats })), resp.Msg.AmountSats)
-			assert.Equal(t, tt.feeRate, resp.Msg.FeeSatPerVbyte)
-			assert.Equal(t, tt.wantFee, resp.Msg.FeeSats)
-			assert.Equal(t, tt.wantReceive, resp.Msg.ReceiveSats)
+			assert.Equal(t, source.Address, resp.Address)
+			assert.Equal(t, tt.wantKind, resp.AddressKind)
+			assert.Equal(t, uint32(len(tt.utxos)), resp.OutputCount)
+			assert.Equal(t, uint64(lo.SumBy(tt.utxos, func(u *orchpb.AddressUnspentOutput) int64 { return u.ValueSats })), resp.AmountSats)
+			assert.Equal(t, tt.feeRate, resp.FeeSatPerVbyte)
+			assert.Equal(t, tt.wantFee, resp.FeeSats)
+			assert.Equal(t, tt.wantReceive, resp.ReceiveSats)
 		})
 	}
 
@@ -235,12 +235,12 @@ func TestPreviewSweep(t *testing.T) {
 		t.Parallel()
 		db := database.Test(t)
 		mainnetWIF, _ := newKey(t, &chaincfg.MainNetParams, true)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(&fakeOrchestrator{})))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(&fakeOrchestrator{})))
 
-		_, err := cli.PreviewSweep(t.Context(), connect.NewRequest(&walletv1.PreviewSweepRequest{
+		_, err := cli.PreviewSweep(t.Context(), &walletv1.PreviewSweepRequest{
 			PrivateKeyWif:  mainnetWIF.String(),
 			FeeSatPerVbyte: 1,
-		}))
+		})
 		require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		require.ErrorContains(t, err, "WIF is not for network")
 	})
diff --git a/bitwindow/server/api/wallet/wallet.go b/bitwindow/server/api/wallet/wallet.go
index 7b2beba3b9..1da9ba39c2 100644
--- a/bitwindow/server/api/wallet/wallet.go
+++ b/bitwindow/server/api/wallet/wallet.go
@@ -12,7 +12,8 @@ import (
 	"time"
 
 	"buf.build/go/protovalidate"
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/btcec/v2"
@@ -80,33 +81,33 @@ type Server struct {
 }
 
 // SendTransaction implements walletv1connect.WalletServiceHandler.
-func (s *Server) SendTransaction(ctx context.Context, c *connect.Request[pb.SendTransactionRequest]) (*connect.Response[pb.SendTransactionResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) SendTransaction(ctx context.Context, c *pb.SendTransactionRequest) (*pb.SendTransactionResponse, error) {
+	walletID := c.WalletId
 
-	if err := protovalidate.Validate(c.Msg); err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	if err := protovalidate.Validate(c); err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	const dustLimit = 546
-	for destination, amount := range c.Msg.Destinations {
+	for destination, amount := range c.Destinations {
 		if amount < dustLimit {
 			err := fmt.Errorf(
 				"amount to %s is below dust limit (%s): %s",
 				destination, btcutil.Amount(dustLimit), btcutil.Amount(amount),
 			)
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 	}
 
-	requiredInputs := make([]*orchpb.UnspentOutput, 0, len(c.Msg.RequiredInputs))
-	for _, input := range c.Msg.RequiredInputs {
+	requiredInputs := make([]*orchpb.UnspentOutput, 0, len(c.RequiredInputs))
+	for _, input := range c.RequiredInputs {
 		txid, voutText, found := strings.Cut(input.Output, ":")
 		if !found {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid UTXO format: %s", input.Output))
+			return nil, connect.Errorf(connect.CodeInvalidArgument, "invalid UTXO format: %s", input.Output)
 		}
 		vout, err := strconv.ParseUint(voutText, 10, 31)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid vout in UTXO %s: %w", input.Output, err))
+			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("invalid vout in UTXO %s: %s", input.Output, err)).WithCause(err)
 		}
 		requiredInputs = append(requiredInputs, &orchpb.UnspentOutput{
 			Txid:       txid,
@@ -119,15 +120,15 @@ func (s *Server) SendTransaction(ctx context.Context, c *connect.Request[pb.Send
 	// the length of a send. A second selector here would spend them.
 	txid, err := s.walletEngine.SendTransaction(ctx, &orchpb.SendTransactionRequest{
 		WalletId: walletID,
-		Destinations: lo.MapValues(c.Msg.Destinations, func(sats uint64, _ string) int64 {
+		Destinations: lo.MapValues(c.Destinations, func(sats uint64, _ string) int64 {
 			return int64(sats)
 		}),
-		FeeRateSatPerVbyte: int64(c.Msg.FeeSatPerVbyte),
-		FixedFeeSats:       int64(c.Msg.FixedFeeSats),
+		FeeRateSatPerVbyte: int64(c.FeeSatPerVbyte),
+		FixedFeeSats:       int64(c.FixedFeeSats),
 		RequiredInputs:     requiredInputs,
 	})
 	if errors.Is(err, engines.ErrFrozenInput) {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 	if err != nil {
 		return nil, err
@@ -135,9 +136,9 @@ func (s *Server) SendTransaction(ctx context.Context, c *connect.Request[pb.Send
 
 	zerolog.Ctx(ctx).Info().Msgf("send tx: broadcast transaction: %s", txid)
 
-	return connect.NewResponse(&pb.SendTransactionResponse{
+	return &pb.SendTransactionResponse{
 		Txid: txid,
-	}), nil
+	}, nil
 }
 
 // keepConnectCode returns err as it is when it holds a connect error, so the
@@ -146,7 +147,7 @@ func keepConnectCode(err error) error {
 	if connectErr := new(connect.Error); errors.As(err, &connectErr) {
 		return err
 	}
-	return connect.NewError(connect.CodeInternal, err)
+	return connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 }
 
 func btcToSats(btc float64) (uint64, error) {
@@ -173,10 +174,10 @@ func sumBTCToSats(a, b float64) (uint64, error) {
 }
 
 // GetNewAddress implements walletv1connect.WalletServiceHandler.
-func (s *Server) GetNewAddress(ctx context.Context, c *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) GetNewAddress(ctx context.Context, c *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
+	walletID := c.WalletId
 	var addressType orchpb.AddressType
-	switch c.Msg.AddressType {
+	switch c.AddressType {
 	case pb.AddressType_ADDRESS_TYPE_UNSPECIFIED:
 		addressType = orchpb.AddressType_ADDRESS_TYPE_UNSPECIFIED
 	case pb.AddressType_ADDRESS_TYPE_SEGWIT:
@@ -194,10 +195,10 @@ func (s *Server) GetNewAddress(ctx context.Context, c *connect.Request[pb.GetNew
 		return nil, fmt.Errorf("save address %s to addressbook: %w", address, err)
 	}
 
-	return connect.NewResponse(&pb.GetNewAddressResponse{
+	return &pb.GetNewAddressResponse{
 		Address: address,
 		Index:   0,
-	}), nil
+	}, nil
 }
 
 // syncCoreAddresses adds the receive addresses of each Bitcoin Core wallet to
@@ -255,8 +256,8 @@ func (s *Server) Run(ctx context.Context) error {
 }
 
 // GetBalance implements walletv1connect.WalletServiceHandler.
-func (s *Server) GetBalance(ctx context.Context, c *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) GetBalance(ctx context.Context, c *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
+	walletID := c.WalletId
 	walletType, err := s.walletEngine.GetWalletBackendType(ctx, walletID)
 	if err != nil {
 		return nil, fmt.Errorf("get wallet type: %w", err)
@@ -274,7 +275,7 @@ func (s *Server) GetBalance(ctx context.Context, c *connect.Request[pb.GetBalanc
 			return nil, fmt.Errorf("get bitcoind client: %w", err)
 		}
 
-		balancesResp, err := bitcoindClient.GetBalances(ctx, connect.NewRequest(&corepb.GetBalancesRequest{
+		balancesResp, err := bitcoindClient.GetBalances(ctx, connectv1.NewRequest(&corepb.GetBalancesRequest{
 			Wallet: coreWalletName,
 		}))
 		if err != nil {
@@ -296,22 +297,22 @@ func (s *Server) GetBalance(ctx context.Context, c *connect.Request[pb.GetBalanc
 			return nil, fmt.Errorf("immature balance: %w", err)
 		}
 
-		return connect.NewResponse(&pb.GetBalanceResponse{
+		return &pb.GetBalanceResponse{
 			ConfirmedSatoshi: confirmedSats,
 			PendingSatoshi:   pendingSats,
 			ImmatureSatoshi:  immatureSats,
-		}), nil
+		}, nil
 
 	case engines.WalletTypeElectrum:
 		confirmedSats, pendingSats, immatureSats, err := s.walletEngine.GetElectrumBalance(ctx, walletID)
 		if err != nil {
 			return nil, err
 		}
-		return connect.NewResponse(&pb.GetBalanceResponse{
+		return &pb.GetBalanceResponse{
 			ConfirmedSatoshi: confirmedSats,
 			PendingSatoshi:   pendingSats,
 			ImmatureSatoshi:  immatureSats,
-		}), nil
+		}, nil
 
 	default:
 		return nil, fmt.Errorf("unknown wallet type: %s", walletType)
@@ -319,8 +320,8 @@ func (s *Server) GetBalance(ctx context.Context, c *connect.Request[pb.GetBalanc
 }
 
 // ListTransactions implements walletv1connect.WalletServiceHandler.
-func (s *Server) ListTransactions(ctx context.Context, c *connect.Request[pb.ListTransactionsRequest]) (*connect.Response[pb.ListTransactionsResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) ListTransactions(ctx context.Context, c *pb.ListTransactionsRequest) (*pb.ListTransactionsResponse, error) {
+	walletID := c.WalletId
 	txs, err := s.listTransactions(ctx, walletID)
 	if err != nil {
 		return nil, err
@@ -345,7 +346,7 @@ func (s *Server) ListTransactions(ctx context.Context, c *connect.Request[pb.Lis
 		}
 		tx.Note = noteMap[tx.Txid]
 	}
-	return connect.NewResponse(&pb.ListTransactionsResponse{Transactions: txs}), nil
+	return &pb.ListTransactionsResponse{Transactions: txs}, nil
 }
 
 func (s *Server) listTransactions(ctx context.Context, walletID string) ([]*pb.WalletTransaction, error) {
@@ -399,7 +400,7 @@ func (s *Server) listTransactions(ctx context.Context, walletID string) ([]*pb.W
 
 	var coreTxs []*corepb.GetTransactionResponse
 	for skip := uint32(0); ; skip += coreTxPageSize {
-		page, err := bitcoind.ListTransactions(ctx, connect.NewRequest(&corepb.ListTransactionsRequest{
+		page, err := bitcoind.ListTransactions(ctx, connectv1.NewRequest(&corepb.ListTransactionsRequest{
 			Wallet: coreWalletName,
 			Count:  coreTxPageSize,
 			Skip:   skip,
@@ -505,7 +506,7 @@ func coreTipHeight(ctx context.Context, bitcoind corerpc.BitcoinServiceClient, a
 	if !anyConfirmed {
 		return 0
 	}
-	info, err := bitcoind.GetBlockchainInfo(ctx, connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	info, err := bitcoind.GetBlockchainInfo(ctx, connectv1.NewRequest(&corepb.GetBlockchainInfoRequest{}))
 	if err != nil {
 		zerolog.Ctx(ctx).Warn().Err(err).Msg("list transactions: no block heights, get blockchain info")
 		return 0
@@ -523,27 +524,27 @@ func (s *Server) enforcerTipHeight(ctx context.Context, anyConfirmed bool) int32
 		zerolog.Ctx(ctx).Warn().Err(err).Msg("list transactions: no block heights, enforcer is down")
 		return 0
 	}
-	resp, err := enforcer.GetChainTip(ctx, connect.NewRequest(&validatorpb.GetChainTipRequest{}))
+	resp, err := enforcer.GetChainTip(ctx, &validatorpb.GetChainTipRequest{})
 	if err != nil {
 		zerolog.Ctx(ctx).Warn().Err(err).Msg("list transactions: no block heights, get chain tip")
 		return 0
 	}
-	return int32(resp.Msg.BlockHeaderInfo.GetHeight())
+	return int32(resp.BlockHeaderInfo.GetHeight())
 }
 
 // ListSidechainDeposits implements walletv1connect.WalletServiceHandler.
 //
 // Only this install's own deposits are knowable. An M5 is an ordinary
 // transaction on the wire, so nothing on chain marks one after the fact.
-func (s *Server) ListSidechainDeposits(ctx context.Context, c *connect.Request[pb.ListSidechainDepositsRequest]) (*connect.Response[pb.ListSidechainDepositsResponse], error) {
-	if c.Msg.Slot < 0 || c.Msg.Slot > 255 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("slot must be 0-255"))
+func (s *Server) ListSidechainDeposits(ctx context.Context, c *pb.ListSidechainDepositsRequest) (*pb.ListSidechainDepositsResponse, error) {
+	if c.Slot < 0 || c.Slot > 255 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "slot must be 0-255")
 	}
-	deposits, err := s.walletEngine.ListSidechainDeposits(ctx, uint32(c.Msg.Slot), c.Msg.WalletId)
+	deposits, err := s.walletEngine.ListSidechainDeposits(ctx, uint32(c.Slot), c.WalletId)
 	if err != nil {
 		return nil, fmt.Errorf("list sidechain deposits: %w", err)
 	}
-	return connect.NewResponse(&pb.ListSidechainDepositsResponse{
+	return &pb.ListSidechainDepositsResponse{
 		Deposits: lo.Map(deposits, func(d *orchpb.SidechainDeposit, _ int) *pb.ListSidechainDepositsResponse_SidechainDeposit {
 			return &pb.ListSidechainDepositsResponse_SidechainDeposit{
 				Txid:          d.Txid,
@@ -553,48 +554,48 @@ func (s *Server) ListSidechainDeposits(ctx context.Context, c *connect.Request[p
 				Dropped:       d.DroppedAt != "",
 			}
 		}),
-	}), nil
+	}, nil
 }
 
 // CreateSidechainDeposit implements walletv1connect.WalletServiceHandler.
-func (s *Server) CreateSidechainDeposit(ctx context.Context, c *connect.Request[pb.CreateSidechainDepositRequest]) (*connect.Response[pb.CreateSidechainDepositResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) CreateSidechainDeposit(ctx context.Context, c *pb.CreateSidechainDepositRequest) (*pb.CreateSidechainDepositResponse, error) {
+	walletID := c.WalletId
 	if _, err := s.walletEngine.GetWalletBackendType(ctx, walletID); err != nil {
 		return nil, fmt.Errorf("get wallet type: %w", err)
 	}
 
-	slot, depositAddress, _, err := drivechain.DecodeDepositAddress(c.Msg.Destination)
+	slot, depositAddress, _, err := drivechain.DecodeDepositAddress(c.Destination)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid deposit address: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("invalid deposit address: %s", err)).WithCause(err)
 	}
-	if slot != nil && c.Msg.Slot != 0 && *slot != c.Msg.Slot {
-		return nil, connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("the deposit address is for slot %d, this deposit is for slot %d", *slot, c.Msg.Slot))
+	if slot != nil && c.Slot != 0 && *slot != c.Slot {
+		return nil, connect.Errorf(connect.CodeInvalidArgument,
+			"the deposit address is for slot %d, this deposit is for slot %d", *slot, c.Slot)
 	}
-	if slot == nil && c.Msg.Slot == 0 {
+	if slot == nil && c.Slot == 0 {
 		return nil, connect.NewError(connect.CodeInvalidArgument,
-			errors.New("address is not a sidechain deposit address, expected slot or format: s<slot>_<address> or s9_<address>_<checksum>"))
+			"address is not a sidechain deposit address, expected slot or format: s<slot>_<address> or s9_<address>_<checksum>")
 	} else if slot == nil {
-		slot = &c.Msg.Slot
+		slot = &c.Slot
 	}
 	if *slot < 0 || *slot > 255 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid sidechain slot %d: must be 0-255", *slot))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "invalid sidechain slot %d: must be 0-255", *slot)
 	}
 
-	amount, err := btcutil.NewAmount(c.Msg.Amount)
+	amount, err := btcutil.NewAmount(c.Amount)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("parse amount: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("parse amount: %s", err)).WithCause(err)
 	}
 	if amount <= 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("invalid amount, must be a BTC-amount greater than zero"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "invalid amount, must be a BTC-amount greater than zero")
 	}
 
-	fee, err := btcutil.NewAmount(c.Msg.Fee)
+	fee, err := btcutil.NewAmount(c.Fee)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("parse fee: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("parse fee: %s", err)).WithCause(err)
 	}
 	if fee <= 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("invalid fee, must be a BTC-amount greater than zero"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "invalid fee, must be a BTC-amount greater than zero")
 	}
 
 	txid, err := s.walletEngine.CreateDeposit(ctx, &orchpb.CreateDepositRequest{
@@ -610,7 +611,7 @@ func (s *Server) CreateSidechainDeposit(ctx context.Context, c *connect.Request[
 
 	zerolog.Ctx(ctx).Info().Str("txid", txid).Int64("slot", *slot).Msg("create sidechain deposit")
 
-	return connect.NewResponse(&pb.CreateSidechainDepositResponse{Txid: txid}), nil
+	return &pb.CreateSidechainDepositResponse{Txid: txid}, nil
 }
 
 // addressScanDepth bounds how far along a receive chain a signable address can
@@ -629,26 +630,26 @@ func deriveMessageSigningPrivateKey(seedHex string, wallet *engines.WalletInfo,
 }
 
 // SignMessage implements walletv1connect.WalletServiceHandler.
-func (s *Server) SignMessage(ctx context.Context, c *connect.Request[pb.SignMessageRequest]) (*connect.Response[pb.SignMessageResponse], error) {
+func (s *Server) SignMessage(ctx context.Context, c *pb.SignMessageRequest) (*pb.SignMessageResponse, error) {
 	if err := s.requireUnlocked(ctx); err != nil {
 		return nil, err
 	}
 
-	if _, err := s.walletEngine.GetWalletBackendType(ctx, c.Msg.WalletId); err != nil {
+	if _, err := s.walletEngine.GetWalletBackendType(ctx, c.WalletId); err != nil {
 		return nil, fmt.Errorf("get wallet type: %w", err)
 	}
 
-	if c.Msg.Address == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("address is required"))
+	if c.Address == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "address is required")
 	}
 
 	chainParams := s.walletEngine.GetChainParams()
-	address, err := btcutil.DecodeAddress(c.Msg.Address, chainParams)
+	address, err := btcutil.DecodeAddress(c.Address, chainParams)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("decode address: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("decode address: %s", err)).WithCause(err)
 	}
 
-	walletInfo, err := s.walletEngine.GetWalletInfo(ctx, c.Msg.WalletId)
+	walletInfo, err := s.walletEngine.GetWalletInfo(ctx, c.WalletId)
 	if err != nil {
 		return nil, fmt.Errorf("get wallet info: %w", err)
 	}
@@ -658,42 +659,42 @@ func (s *Server) SignMessage(ctx context.Context, c *connect.Request[pb.SignMess
 		return nil, err
 	}
 
-	privKey, err := deriveMessageSigningPrivateKey(seedHex, walletInfo, chainParams, c.Msg.Address)
+	privKey, err := deriveMessageSigningPrivateKey(seedHex, walletInfo, chainParams, c.Address)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("derive signing key: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("derive signing key: %s", err)).WithCause(err)
 	}
 
-	signature, err := signmessage.Sign(privKey, address, c.Msg.Message, chainParams)
+	signature, err := signmessage.Sign(privKey, address, c.Message, chainParams)
 	if err != nil {
 		return nil, fmt.Errorf("sign message: %w", err)
 	}
 
-	return connect.NewResponse(&pb.SignMessageResponse{Signature: signature}), nil
+	return &pb.SignMessageResponse{Signature: signature}, nil
 }
 
 // VerifyMessage implements walletv1connect.WalletServiceHandler.
-func (s *Server) VerifyMessage(ctx context.Context, c *connect.Request[pb.VerifyMessageRequest]) (*connect.Response[pb.VerifyMessageResponse], error) {
-	valid, err := signmessage.Verify(c.Msg.PublicKey, c.Msg.Message, c.Msg.Signature, s.walletEngine.GetChainParams())
+func (s *Server) VerifyMessage(ctx context.Context, c *pb.VerifyMessageRequest) (*pb.VerifyMessageResponse, error) {
+	valid, err := signmessage.Verify(c.PublicKey, c.Message, c.Signature, s.walletEngine.GetChainParams())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.VerifyMessageResponse{Valid: valid}), nil
+	return &pb.VerifyMessageResponse{Valid: valid}, nil
 }
 
 // ListUnspent implements walletv1connect.WalletServiceHandler.
-func (s *Server) ListUnspent(ctx context.Context, c *connect.Request[pb.ListUnspentRequest]) (*connect.Response[pb.ListUnspentResponse], error) {
+func (s *Server) ListUnspent(ctx context.Context, c *pb.ListUnspentRequest) (*pb.ListUnspentResponse, error) {
 	labels, err := addressbook.LabelsByAddress(ctx, s.database)
 	if err != nil {
 		return nil, fmt.Errorf("list addressbook: %w", err)
 	}
 
-	utxos, err := s.listUnspent(ctx, c.Msg.WalletId, labels)
+	utxos, err := s.listUnspent(ctx, c.WalletId, labels)
 	if err != nil {
 		return nil, err
 	}
 
-	return connect.NewResponse(&pb.ListUnspentResponse{Utxos: utxos}), nil
+	return &pb.ListUnspentResponse{Utxos: utxos}, nil
 }
 
 func (s *Server) listUnspent(ctx context.Context, walletID string, labels map[string]string) ([]*pb.UnspentOutput, error) {
@@ -740,7 +741,7 @@ func (s *Server) listUnspentBitcoinCore(ctx context.Context, walletID string, la
 		return nil, err
 	}
 
-	resp, err := bitcoind.ListUnspent(ctx, connect.NewRequest(&corepb.ListUnspentRequest{
+	resp, err := bitcoind.ListUnspent(ctx, connectv1.NewRequest(&corepb.ListUnspentRequest{
 		Wallet: coreWalletName,
 	}))
 	if err != nil {
@@ -854,13 +855,13 @@ func (s *Server) denialToProtoCore(txid string, vout int32, d deniability.Denial
 }
 
 // ListReceiveAddresses implements walletv1connect.WalletServiceHandler.
-func (s *Server) ListReceiveAddresses(ctx context.Context, c *connect.Request[pb.ListReceiveAddressesRequest]) (*connect.Response[pb.ListReceiveAddressesResponse], error) {
+func (s *Server) ListReceiveAddresses(ctx context.Context, c *pb.ListReceiveAddressesRequest) (*pb.ListReceiveAddressesResponse, error) {
 	labels, err := addressbook.LabelsByAddress(ctx, s.database)
 	if err != nil {
 		return nil, fmt.Errorf("list addressbook: %w", err)
 	}
 
-	utxos, err := s.listUnspent(ctx, c.Msg.WalletId, labels)
+	utxos, err := s.listUnspent(ctx, c.WalletId, labels)
 	if err != nil {
 		return nil, err
 	}
@@ -886,14 +887,14 @@ func (s *Server) ListReceiveAddresses(ctx context.Context, c *connect.Request[pb
 		addresses = append(addresses, addr)
 	}
 
-	return connect.NewResponse(&pb.ListReceiveAddressesResponse{
+	return &pb.ListReceiveAddressesResponse{
 		Addresses: addresses,
-	}), nil
+	}, nil
 }
 
 // GetStats implements walletv1connect.WalletServiceHandler.
-func (s *Server) GetStats(ctx context.Context, c *connect.Request[pb.GetStatsRequest]) (*connect.Response[pb.GetStatsResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) GetStats(ctx context.Context, c *pb.GetStatsRequest) (*pb.GetStatsResponse, error) {
+	walletID := c.WalletId
 
 	utxos, err := s.listUnspent(ctx, walletID, nil)
 	if err != nil {
@@ -942,7 +943,7 @@ func (s *Server) GetStats(ctx context.Context, c *connect.Request[pb.GetStatsReq
 		return nil, fmt.Errorf("sum sidechain deposits: %w", err)
 	}
 
-	return connect.NewResponse(&pb.GetStatsResponse{
+	return &pb.GetStatsResponse{
 		UtxosCurrent:                      utxoCount,
 		UtxosUniqueAddresses:              uniqueAddressCount,
 		SidechainDepositVolume:            depositVolume,
@@ -952,12 +953,12 @@ func (s *Server) GetStats(ctx context.Context, c *connect.Request[pb.GetStatsReq
 		TotalFeesSats:                     totalFees,
 		LastTxAt:                          lastTxAt,
 		LastTxBlockHeight:                 lastTxBlockHeight,
-	}), nil
+	}, nil
 }
 
 // UnlockWallet implements walletv1connect.WalletServiceHandler.
-func (s *Server) UnlockWallet(ctx context.Context, c *connect.Request[pb.UnlockWalletRequest]) (*connect.Response[emptypb.Empty], error) {
-	if err := s.walletEngine.Unlock(ctx, c.Msg.Password); err != nil {
+func (s *Server) UnlockWallet(ctx context.Context, c *pb.UnlockWalletRequest) (*emptypb.Empty, error) {
+	if err := s.walletEngine.Unlock(ctx, c.Password); err != nil {
 		return nil, err
 	}
 
@@ -971,32 +972,32 @@ func (s *Server) UnlockWallet(ctx context.Context, c *connect.Request[pb.UnlockW
 	}()
 
 	zerolog.Ctx(ctx).Info().Msg("unlock wallet")
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // LockWallet implements walletv1connect.WalletServiceHandler.
-func (s *Server) LockWallet(ctx context.Context, c *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
+func (s *Server) LockWallet(ctx context.Context, c *emptypb.Empty) (*emptypb.Empty, error) {
 	// Only a password unlocks a wallet again, so a wallet with no password cannot lock.
 	encrypted, err := s.walletEngine.IsEncrypted(ctx)
 	if err != nil {
 		return nil, err
 	}
 	if !encrypted {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet is not encrypted"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "wallet is not encrypted")
 	}
 	if err := s.walletEngine.Lock(ctx); err != nil {
 		return nil, err
 	}
 	zerolog.Ctx(ctx).Info().Msg("wallet locked")
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // IsWalletUnlocked implements walletv1connect.WalletServiceHandler.
-func (s *Server) IsWalletUnlocked(ctx context.Context, c *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
+func (s *Server) IsWalletUnlocked(ctx context.Context, c *emptypb.Empty) (*emptypb.Empty, error) {
 	if err := s.requireUnlocked(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 func (s *Server) requireUnlocked(ctx context.Context) error {
@@ -1005,18 +1006,18 @@ func (s *Server) requireUnlocked(ctx context.Context) error {
 		return err
 	}
 	if !unlocked {
-		return connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet is locked"))
+		return connect.NewError(connect.CodeFailedPrecondition, "wallet is locked")
 	}
 	return nil
 }
 
 // CreateCheque implements walletv1connect.WalletServiceHandler.
-func (s *Server) CreateCheque(ctx context.Context, c *connect.Request[pb.CreateChequeRequest]) (*connect.Response[pb.CreateChequeResponse], error) {
+func (s *Server) CreateCheque(ctx context.Context, c *pb.CreateChequeRequest) (*pb.CreateChequeResponse, error) {
 	log := zerolog.Ctx(ctx)
 
-	walletID := c.Msg.WalletId
+	walletID := c.WalletId
 	if walletID == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("wallet_id is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "wallet_id is required")
 	}
 
 	if err := s.requireUnlocked(ctx); err != nil {
@@ -1030,7 +1031,7 @@ func (s *Server) CreateCheque(ctx context.Context, c *connect.Request[pb.CreateC
 
 	nextIndex, err := cheques.GetNextIndex(ctx, s.database, walletID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get next index: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get next index: %s", err)).WithCause(err)
 	}
 
 	address, err := s.chequeEngine.DeriveChequeAddress(ctx, walletID, nextIndex)
@@ -1038,30 +1039,30 @@ func (s *Server) CreateCheque(ctx context.Context, c *connect.Request[pb.CreateC
 		return nil, keepConnectCode(fmt.Errorf("derive address %d: %w", nextIndex, err))
 	}
 
-	id, err := cheques.Create(ctx, s.database, walletID, nextIndex, c.Msg.ExpectedAmountSats, address)
+	id, err := cheques.Create(ctx, s.database, walletID, nextIndex, c.ExpectedAmountSats, address)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("create cheque: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("create cheque: %s", err)).WithCause(err)
 	}
 
 	log.Info().
 		Int64("id", id).
 		Uint32("index", nextIndex).
 		Str("address", address).
-		Uint64("expected_sats", c.Msg.ExpectedAmountSats).
+		Uint64("expected_sats", c.ExpectedAmountSats).
 		Msg("cheque created")
 
-	return connect.NewResponse(&pb.CreateChequeResponse{
+	return &pb.CreateChequeResponse{
 		Id:              id,
 		Address:         address,
 		DerivationIndex: nextIndex,
-	}), nil
+	}, nil
 }
 
 // GetCheque implements walletv1connect.WalletServiceHandler.
-func (s *Server) GetCheque(ctx context.Context, c *connect.Request[pb.GetChequeRequest]) (*connect.Response[pb.GetChequeResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) GetCheque(ctx context.Context, c *pb.GetChequeRequest) (*pb.GetChequeResponse, error) {
+	walletID := c.WalletId
 
-	cheque, err := s.getCheque(ctx, walletID, c.Msg.Id)
+	cheque, err := s.getCheque(ctx, walletID, c.Id)
 	if err != nil {
 		return nil, err
 	}
@@ -1075,20 +1076,20 @@ func (s *Server) GetCheque(ctx context.Context, c *connect.Request[pb.GetChequeR
 		return nil, keepConnectCode(err)
 	}
 
-	return connect.NewResponse(&pb.GetChequeResponse{
+	return &pb.GetChequeResponse{
 		Cheque: pbCheque,
-	}), nil
+	}, nil
 }
 
 // GetChequePrivateKey implements walletv1connect.WalletServiceHandler.
-func (s *Server) GetChequePrivateKey(ctx context.Context, c *connect.Request[pb.GetChequePrivateKeyRequest]) (*connect.Response[pb.GetChequePrivateKeyResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) GetChequePrivateKey(ctx context.Context, c *pb.GetChequePrivateKeyRequest) (*pb.GetChequePrivateKeyResponse, error) {
+	walletID := c.WalletId
 
 	if err := s.requireUnlocked(ctx); err != nil {
 		return nil, err
 	}
 
-	cheque, err := s.getCheque(ctx, walletID, c.Msg.Id)
+	cheque, err := s.getCheque(ctx, walletID, c.Id)
 	if err != nil {
 		return nil, err
 	}
@@ -1098,14 +1099,14 @@ func (s *Server) GetChequePrivateKey(ctx context.Context, c *connect.Request[pb.
 		return nil, keepConnectCode(fmt.Errorf("derive private key %d: %w", cheque.DerivationIndex, err))
 	}
 
-	return connect.NewResponse(&pb.GetChequePrivateKeyResponse{
+	return &pb.GetChequePrivateKeyResponse{
 		PrivateKeyWif: privateKeyWIF,
-	}), nil
+	}, nil
 }
 
 // ListCheques implements walletv1connect.WalletServiceHandler.
-func (s *Server) ListCheques(ctx context.Context, c *connect.Request[pb.ListChequesRequest]) (*connect.Response[pb.ListChequesResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) ListCheques(ctx context.Context, c *pb.ListChequesRequest) (*pb.ListChequesResponse, error) {
+	walletID := c.WalletId
 
 	_, err := s.walletEngine.GetWalletBackendType(ctx, walletID)
 	if err != nil {
@@ -1114,7 +1115,7 @@ func (s *Server) ListCheques(ctx context.Context, c *connect.Request[pb.ListCheq
 
 	chequeList, err := cheques.List(ctx, s.database, walletID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("list cheques: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("list cheques: %s", err)).WithCause(err)
 	}
 
 	unlocked, err := s.walletEngine.IsUnlocked(ctx)
@@ -1129,14 +1130,14 @@ func (s *Server) ListCheques(ctx context.Context, c *connect.Request[pb.ListCheq
 		}
 	}
 
-	return connect.NewResponse(&pb.ListChequesResponse{
+	return &pb.ListChequesResponse{
 		Cheques: pbCheques,
-	}), nil
+	}, nil
 }
 
 // CheckChequeFunding implements walletv1connect.WalletServiceHandler.
-func (s *Server) CheckChequeFunding(ctx context.Context, c *connect.Request[pb.CheckChequeFundingRequest]) (*connect.Response[pb.CheckChequeFundingResponse], error) {
-	cheque, err := s.getCheque(ctx, c.Msg.WalletId, c.Msg.Id)
+func (s *Server) CheckChequeFunding(ctx context.Context, c *pb.CheckChequeFundingRequest) (*pb.CheckChequeFundingResponse, error) {
+	cheque, err := s.getCheque(ctx, c.WalletId, c.Id)
 	if err != nil {
 		return nil, err
 	}
@@ -1155,23 +1156,23 @@ func (s *Server) CheckChequeFunding(ctx context.Context, c *connect.Request[pb.C
 	if funding.FundedAt != nil {
 		resp.FundedAt = timestamppb.New(*funding.FundedAt)
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 // PreviewSweep implements walletv1connect.WalletServiceHandler.
 // Reports what a private key holds and what sweeping it would cost.
-func (s *Server) PreviewSweep(ctx context.Context, c *connect.Request[pb.PreviewSweepRequest]) (*connect.Response[pb.PreviewSweepResponse], error) {
-	wifKey, err := decodeSweepWIF(c.Msg.PrivateKeyWif, s.chequeEngine.GetChainParams())
+func (s *Server) PreviewSweep(ctx context.Context, c *pb.PreviewSweepRequest) (*pb.PreviewSweepResponse, error) {
+	wifKey, err := decodeSweepWIF(c.PrivateKeyWif, s.chequeEngine.GetChainParams())
 	if err != nil {
 		return nil, err
 	}
 
 	source, err := engines.ResolveSweepSource(ctx, s.chequeChain, wifKey, s.chequeEngine.GetChainParams())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("query UTXOs: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Sprintf("query UTXOs: %s", err)).WithCause(err)
 	}
 
-	feeSatPerVbyte, err := s.chequeEngine.SweepFeeRate(ctx, c.Msg.FeeSatPerVbyte)
+	feeSatPerVbyte, err := s.chequeEngine.SweepFeeRate(ctx, c.FeeSatPerVbyte)
 	if err != nil {
 		return nil, err
 	}
@@ -1184,7 +1185,7 @@ func (s *Server) PreviewSweep(ctx context.Context, c *connect.Request[pb.Preview
 		receiveSats = amountSats - feeSats
 	}
 
-	return connect.NewResponse(&pb.PreviewSweepResponse{
+	return &pb.PreviewSweepResponse{
 		Address:        source.Address,
 		AddressKind:    sweepAddressKindToPb(source.Kind),
 		AmountSats:     amountSats,
@@ -1192,16 +1193,16 @@ func (s *Server) PreviewSweep(ctx context.Context, c *connect.Request[pb.Preview
 		FeeSatPerVbyte: feeSatPerVbyte,
 		FeeSats:        feeSats,
 		ReceiveSats:    receiveSats,
-	}), nil
+	}, nil
 }
 
 func decodeSweepWIF(text string, params *chaincfg.Params) (*btcutil.WIF, error) {
 	wifKey, err := btcutil.DecodeWIF(text)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid WIF: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Sprintf("invalid WIF: %s", err)).WithCause(err)
 	}
 	if !wifKey.IsForNet(params) {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("WIF is not for network %s", params.Name))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "WIF is not for network %s", params.Name)
 	}
 	return wifKey, nil
 }
@@ -1221,51 +1222,51 @@ func sweepAddressKindToPb(kind engines.SweepAddressKind) pb.SweepAddressKind {
 
 // SweepCheque implements walletv1connect.WalletServiceHandler.
 // Sweeps a cheque using its WIF private key to the destination address.
-func (s *Server) SweepCheque(ctx context.Context, c *connect.Request[pb.SweepChequeRequest]) (*connect.Response[pb.SweepChequeResponse], error) {
-	wifKey, err := decodeSweepWIF(c.Msg.PrivateKeyWif, s.chequeEngine.GetChainParams())
+func (s *Server) SweepCheque(ctx context.Context, c *pb.SweepChequeRequest) (*pb.SweepChequeResponse, error) {
+	wifKey, err := decodeSweepWIF(c.PrivateKeyWif, s.chequeEngine.GetChainParams())
 	if err != nil {
 		return nil, err
 	}
 
-	sweep, err := s.chequeEngine.Sweep(ctx, c.Msg.WalletId, wifKey, c.Msg.DestinationAddress, c.Msg.FeeSatPerVbyte)
+	sweep, err := s.chequeEngine.Sweep(ctx, c.WalletId, wifKey, c.DestinationAddress, c.FeeSatPerVbyte)
 	if err != nil {
 		return nil, err
 	}
 
-	return connect.NewResponse(&pb.SweepChequeResponse{
+	return &pb.SweepChequeResponse{
 		Txid:           sweep.Txid,
 		AmountSats:     sweep.AmountSats,
 		FeeSatPerVbyte: sweep.FeeSatPerVbyte,
-	}), nil
+	}, nil
 }
 
 // DeleteCheque implements walletv1connect.WalletServiceHandler.
-func (s *Server) DeleteCheque(ctx context.Context, c *connect.Request[pb.DeleteChequeRequest]) (*connect.Response[emptypb.Empty], error) {
+func (s *Server) DeleteCheque(ctx context.Context, c *pb.DeleteChequeRequest) (*emptypb.Empty, error) {
 	log := zerolog.Ctx(ctx)
 
-	walletID := c.Msg.WalletId
+	walletID := c.WalletId
 
-	cheque, err := s.getCheque(ctx, walletID, c.Msg.Id)
+	cheque, err := s.getCheque(ctx, walletID, c.Id)
 	if err != nil {
 		return nil, err
 	}
 
 	// Any recorded incoming funds (full or partial) but not swept = still has money, can't delete
 	if (cheque.IsFunded() || cheque.IsPartiallyFunded()) && cheque.SweptTxid == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("cannot delete funded cheque"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "cannot delete funded cheque")
 	}
 
-	err = cheques.Delete(ctx, s.database, walletID, c.Msg.Id)
+	err = cheques.Delete(ctx, s.database, walletID, c.Id)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("delete cheque: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("delete cheque: %s", err)).WithCause(err)
 	}
 
 	log.Info().
-		Int64("id", c.Msg.Id).
+		Int64("id", c.Id).
 		Str("address", cheque.Address).
 		Msg("cheque deleted")
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 func (s *Server) getCheque(ctx context.Context, walletID string, id int64) (*cheques.Cheque, error) {
@@ -1276,9 +1277,9 @@ func (s *Server) getCheque(ctx context.Context, walletID string, id int64) (*che
 	cheque, err := cheques.Get(ctx, s.database, walletID, id)
 	switch {
 	case errors.Is(err, sql.ErrNoRows):
-		return nil, connect.NewError(connect.CodeNotFound, errors.New("cheque not found"))
+		return nil, connect.NewError(connect.CodeNotFound, "cheque not found")
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get cheque: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get cheque: %s", err)).WithCause(err)
 	}
 	return cheque, nil
 }
@@ -1319,32 +1320,32 @@ func (s *Server) chequeToPb(ctx context.Context, c *cheques.Cheque, unlocked boo
 }
 
 // SetUTXOMetadata implements walletv1connect.WalletServiceHandler.
-func (s *Server) SetUTXOMetadata(ctx context.Context, c *connect.Request[pb.SetUTXOMetadataRequest]) (*connect.Response[emptypb.Empty], error) {
-	if c.Msg.Outpoint == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("outpoint is required"))
+func (s *Server) SetUTXOMetadata(ctx context.Context, c *pb.SetUTXOMetadataRequest) (*emptypb.Empty, error) {
+	if c.Outpoint == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "outpoint is required")
 	}
 
-	if err := utxometadata.Set(ctx, s.database, c.Msg.Outpoint, c.Msg.IsFrozen, c.Msg.Label); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("set UTXO metadata: %w", err))
+	if err := utxometadata.Set(ctx, s.database, c.Outpoint, c.IsFrozen, c.Label); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("set UTXO metadata: %s", err)).WithCause(err)
 	}
 
 	// Coin selection runs in drivechaind, so a freeze reaches it only when we
 	// hand the new set over. A caller that reads success must be able to
 	// believe the coin is safe.
-	if c.Msg.IsFrozen != nil {
+	if c.IsFrozen != nil {
 		if err := s.walletEngine.PushFrozenCoins(ctx); err != nil {
 			return nil, keepConnectCode(err)
 		}
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // GetUTXOMetadata implements walletv1connect.WalletServiceHandler.
-func (s *Server) GetUTXOMetadata(ctx context.Context, c *connect.Request[pb.GetUTXOMetadataRequest]) (*connect.Response[pb.GetUTXOMetadataResponse], error) {
-	metadata, err := utxometadata.Get(ctx, s.database, c.Msg.Outpoints)
+func (s *Server) GetUTXOMetadata(ctx context.Context, c *pb.GetUTXOMetadataRequest) (*pb.GetUTXOMetadataResponse, error) {
+	metadata, err := utxometadata.Get(ctx, s.database, c.Outpoints)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get UTXO metadata: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get UTXO metadata: %s", err)).WithCause(err)
 	}
 
 	result := make(map[string]*pb.UTXOMetadata)
@@ -1356,45 +1357,45 @@ func (s *Server) GetUTXOMetadata(ctx context.Context, c *connect.Request[pb.GetU
 		}
 	}
 
-	return connect.NewResponse(&pb.GetUTXOMetadataResponse{
+	return &pb.GetUTXOMetadataResponse{
 		Metadata: result,
-	}), nil
+	}, nil
 }
 
 // SetCoinSelectionStrategy implements walletv1connect.WalletServiceHandler.
-func (s *Server) SetCoinSelectionStrategy(ctx context.Context, c *connect.Request[pb.SetCoinSelectionStrategyRequest]) (*connect.Response[emptypb.Empty], error) {
-	strategyStr := strconv.Itoa(int(c.Msg.Strategy))
+func (s *Server) SetCoinSelectionStrategy(ctx context.Context, c *pb.SetCoinSelectionStrategyRequest) (*emptypb.Empty, error) {
+	strategyStr := strconv.Itoa(int(c.Strategy))
 	if err := preferences.Set(ctx, s.database, preferences.KeyCoinSelectionStrategy, strategyStr); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("set coin selection strategy: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("set coin selection strategy: %s", err)).WithCause(err)
 	}
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // GetCoinSelectionStrategy implements walletv1connect.WalletServiceHandler.
-func (s *Server) GetCoinSelectionStrategy(ctx context.Context, c *connect.Request[emptypb.Empty]) (*connect.Response[pb.GetCoinSelectionStrategyResponse], error) {
+func (s *Server) GetCoinSelectionStrategy(ctx context.Context, c *emptypb.Empty) (*pb.GetCoinSelectionStrategyResponse, error) {
 	value, err := preferences.Get(ctx, s.database, preferences.KeyCoinSelectionStrategy)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get coin selection strategy: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("get coin selection strategy: %s", err)).WithCause(err)
 	}
 
 	strategy := pb.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_LARGEST_FIRST // default
 	if value != "" {
 		parsed, err := strconv.Atoi(value)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("parse coin selection strategy %q: %w", value, err))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("parse coin selection strategy %q: %s", value, err)).WithCause(err)
 		}
 		strategy = pb.CoinSelectionStrategy(parsed)
 	}
 
-	return connect.NewResponse(&pb.GetCoinSelectionStrategyResponse{
+	return &pb.GetCoinSelectionStrategyResponse{
 		Strategy: strategy,
-	}), nil
+	}, nil
 }
 
 // readPrevOut reads an input's previous output when Core leaves out prevout,
 // as it does for a block with no undo data.
 func readPrevOut(ctx context.Context, bitcoind corerpc.BitcoinServiceClient, txid string, vout uint32) (*corepb.PreviousOutput, error) {
-	parent, err := bitcoind.GetRawTransaction(ctx, connect.NewRequest(&corepb.GetRawTransactionRequest{
+	parent, err := bitcoind.GetRawTransaction(ctx, connectv1.NewRequest(&corepb.GetRawTransactionRequest{
 		Txid:      txid,
 		Verbosity: corepb.GetRawTransactionRequest_VERBOSITY_TX_INFO,
 	}))
@@ -1410,10 +1411,10 @@ func readPrevOut(ctx context.Context, bitcoind corerpc.BitcoinServiceClient, txi
 
 // GetTransactionDetails implements walletv1connect.WalletServiceHandler.
 // Returns enriched transaction details with resolved input values/addresses.
-func (s *Server) GetTransactionDetails(ctx context.Context, c *connect.Request[pb.GetTransactionDetailsRequest]) (*connect.Response[pb.GetTransactionDetailsResponse], error) {
-	txid := c.Msg.Txid
+func (s *Server) GetTransactionDetails(ctx context.Context, c *pb.GetTransactionDetailsRequest) (*pb.GetTransactionDetailsResponse, error) {
+	txid := c.Txid
 	if txid == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("txid required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "txid required")
 	}
 
 	bitcoind, err := s.bitcoind.Get(ctx)
@@ -1421,14 +1422,14 @@ func (s *Server) GetTransactionDetails(ctx context.Context, c *connect.Request[p
 		return nil, err
 	}
 
-	rawTx, err := bitcoind.GetRawTransaction(ctx, connect.NewRequest(&corepb.GetRawTransactionRequest{
+	rawTx, err := bitcoind.GetRawTransaction(ctx, connectv1.NewRequest(&corepb.GetRawTransactionRequest{
 		Txid:      txid,
 		Verbosity: corepb.GetRawTransactionRequest_VERBOSITY_TX_PREVOUT_INFO,
 	}))
 	switch {
 	// Core error -5.
 	case err != nil && strings.Contains(err.Error(), "No such mempool or blockchain transaction"):
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("transaction not found: %w", err))
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Sprintf("transaction not found: %s", err)).WithCause(err)
 	case err != nil:
 		return nil, fmt.Errorf("get transaction %s: %w", txid, err)
 	}
@@ -1528,7 +1529,7 @@ func (s *Server) GetTransactionDetails(ctx context.Context, c *connect.Request[p
 		hexStr = rawTx.Msg.Tx.Hex
 	}
 
-	return connect.NewResponse(&pb.GetTransactionDetailsResponse{
+	return &pb.GetTransactionDetailsResponse{
 		Txid:            rawTx.Msg.Txid,
 		Blockhash:       rawTx.Msg.Blockhash,
 		Confirmations:   int32(rawTx.Msg.Confirmations),
@@ -1545,15 +1546,15 @@ func (s *Server) GetTransactionDetails(ctx context.Context, c *connect.Request[p
 		Outputs:         outputs,
 		TotalOutputSats: totalOutputSats,
 		Hex:             hexStr,
-	}), nil
+	}, nil
 }
 
 // GetUTXODistribution implements walletv1connect.WalletServiceHandler.
 // Returns UTXO distribution data for chart visualization.
-func (s *Server) GetUTXODistribution(ctx context.Context, c *connect.Request[pb.GetUTXODistributionRequest]) (*connect.Response[pb.GetUTXODistributionResponse], error) {
-	walletID := c.Msg.WalletId
+func (s *Server) GetUTXODistribution(ctx context.Context, c *pb.GetUTXODistributionRequest) (*pb.GetUTXODistributionResponse, error) {
+	walletID := c.WalletId
 
-	maxBuckets := int(c.Msg.MaxBuckets)
+	maxBuckets := int(c.MaxBuckets)
 	if maxBuckets <= 0 {
 		maxBuckets = 6
 	}
@@ -1564,9 +1565,9 @@ func (s *Server) GetUTXODistribution(ctx context.Context, c *connect.Request[pb.
 	}
 
 	if len(utxos) == 0 {
-		return connect.NewResponse(&pb.GetUTXODistributionResponse{
+		return &pb.GetUTXODistributionResponse{
 			Buckets: []*pb.UTXOBucket{},
-		}), nil
+		}, nil
 	}
 
 	minVal := utxos[0].ValueSats
@@ -1611,9 +1612,9 @@ func (s *Server) GetUTXODistribution(ctx context.Context, c *connect.Request[pb.
 		}
 	}
 
-	return connect.NewResponse(&pb.GetUTXODistributionResponse{
+	return &pb.GetUTXODistributionResponse{
 		Buckets: buckets,
-	}), nil
+	}, nil
 }
 
 type bucketRange struct {
@@ -1708,10 +1709,10 @@ func formatBucketRange(minSats, maxSats uint64) string {
 
 // BumpFee implements RBF (Replace-By-Fee) for unconfirmed transactions.
 // Uses Bitcoin Core's bumpfee command with automatic fee estimation.
-func (s *Server) BumpFee(ctx context.Context, c *connect.Request[pb.BumpFeeRequest]) (*connect.Response[pb.BumpFeeResponse], error) {
+func (s *Server) BumpFee(ctx context.Context, c *pb.BumpFeeRequest) (*pb.BumpFeeResponse, error) {
 	log := zerolog.Ctx(ctx)
-	if c.Msg.Txid == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("txid required"))
+	if c.Txid == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "txid required")
 	}
 
 	// The caller names a txid alone, so try every wallet until one owns it.
@@ -1725,7 +1726,7 @@ func (s *Server) BumpFee(ctx context.Context, c *connect.Request[pb.BumpFeeReque
 	for _, walletID := range append([]string{""}, wallets...) {
 		resp, err = s.walletEngine.BumpFee(ctx, &orchpb.BumpFeeRequest{
 			WalletId: walletID,
-			Txid:     c.Msg.Txid,
+			Txid:     c.Txid,
 		})
 		if err == nil {
 			break
@@ -1733,48 +1734,48 @@ func (s *Server) BumpFee(ctx context.Context, c *connect.Request[pb.BumpFeeReque
 		errs = append(errs, fmt.Errorf("wallet %q: %w", walletID, err))
 	}
 	if resp == nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("bump fee of %s: %w", c.Msg.Txid, errors.Join(errs...)))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Sprintf("bump fee of %s: %s", c.Txid, errors.Join(errs...))).WithCause(errors.Join(errs...))
 	}
 
 	log.Info().
-		Str("old_txid", c.Msg.Txid).
+		Str("old_txid", c.Txid).
 		Str("new_txid", resp.NewTxid).
 		Msg("RBF transaction broadcast")
 
-	return connect.NewResponse(&pb.BumpFeeResponse{
+	return &pb.BumpFeeResponse{
 		Txid:        resp.NewTxid,
 		OriginalFee: float64(resp.GetPlan().GetOldFeeSats()) / 1e8,
 		NewFee:      float64(resp.GetPlan().GetNewFeeSats()) / 1e8,
-	}), nil
+	}, nil
 }
 
 // SelectCoins implements walletv1connect.WalletServiceHandler.
-func (s *Server) SelectCoins(ctx context.Context, c *connect.Request[pb.SelectCoinsRequest]) (*connect.Response[pb.SelectCoinsResponse], error) {
+func (s *Server) SelectCoins(ctx context.Context, c *pb.SelectCoinsRequest) (*pb.SelectCoinsResponse, error) {
 	labels, err := addressbook.LabelsByAddress(ctx, s.database)
 	if err != nil {
 		return nil, fmt.Errorf("list addressbook: %w", err)
 	}
-	utxos, err := s.listUnspent(ctx, c.Msg.WalletId, labels)
+	utxos, err := s.listUnspent(ctx, c.WalletId, labels)
 	if err != nil {
 		return nil, fmt.Errorf("list unspent: %w", err)
 	}
 
 	frozenOutpoints := make(map[string]bool)
-	for _, outpoint := range c.Msg.FrozenOutpoints {
+	for _, outpoint := range c.FrozenOutpoints {
 		frozenOutpoints[outpoint] = true
 	}
 
 	requiredOutpoints := make(map[string]bool)
-	for _, outpoint := range c.Msg.RequiredOutpoints {
+	for _, outpoint := range c.RequiredOutpoints {
 		requiredOutpoints[outpoint] = true
 	}
 
-	numOutputs := int(c.Msg.NumOutputs)
+	numOutputs := int(c.NumOutputs)
 	if numOutputs <= 0 {
 		numOutputs = 2
 	}
 
-	strategy := c.Msg.Strategy
+	strategy := c.Strategy
 	if strategy == pb.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_UNSPECIFIED {
 		strategy = pb.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_LARGEST_FIRST
 	}
@@ -1782,47 +1783,47 @@ func (s *Server) SelectCoins(ctx context.Context, c *connect.Request[pb.SelectCo
 	result, err := engines.SelectCoins(
 		utxos,
 		frozenOutpoints,
-		c.Msg.TargetSats,
-		c.Msg.FeeSatsPerVbyte,
+		c.TargetSats,
+		c.FeeSatsPerVbyte,
 		numOutputs,
 		strategy,
 		requiredOutpoints,
 	)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.SelectCoinsResponse{
+	return &pb.SelectCoinsResponse{
 		SelectedUtxos:  result.SelectedUTXOs,
 		TotalInputSats: result.TotalInputSats,
 		FeeSats:        result.FeeSats,
 		ChangeSats:     result.ChangeSats,
-	}), nil
+	}, nil
 }
 
 // CreateBackup implements walletv1connect.WalletServiceHandler.
-func (s *Server) CreateBackup(ctx context.Context, _ *connect.Request[emptypb.Empty]) (*connect.Response[pb.CreateBackupResponse], error) {
+func (s *Server) CreateBackup(ctx context.Context, _ *emptypb.Empty) (*pb.CreateBackupResponse, error) {
 	data, filename, err := s.backupEngine.CreateBackup(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("create backup: %w", err)
 	}
 
-	return connect.NewResponse(&pb.CreateBackupResponse{
+	return &pb.CreateBackupResponse{
 		BackupData:        data,
 		SuggestedFilename: filename,
-	}), nil
+	}, nil
 }
 
 // RestoreBackup implements walletv1connect.WalletServiceHandler.
-func (s *Server) RestoreBackup(ctx context.Context, c *connect.Request[pb.RestoreBackupRequest]) (*connect.Response[emptypb.Empty], error) {
-	if len(c.Msg.BackupData) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("backup_data is required"))
+func (s *Server) RestoreBackup(ctx context.Context, c *pb.RestoreBackupRequest) (*emptypb.Empty, error) {
+	if len(c.BackupData) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "backup_data is required")
 	}
-	if c.Msg.Filename == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("filename is required"))
+	if c.Filename == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "filename is required")
 	}
 
-	if err := s.backupEngine.RestoreBackup(ctx, c.Msg.BackupData, c.Msg.Filename); err != nil {
+	if err := s.backupEngine.RestoreBackup(ctx, c.BackupData, c.Filename); err != nil {
 		return nil, fmt.Errorf("restore backup: %w", err)
 	}
 
@@ -1831,30 +1832,30 @@ func (s *Server) RestoreBackup(ctx context.Context, c *connect.Request[pb.Restor
 		return nil, fmt.Errorf("restore backup: restart L1 stack: %w", err)
 	}
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 // ValidateBackup implements walletv1connect.WalletServiceHandler.
-func (s *Server) ValidateBackup(ctx context.Context, c *connect.Request[pb.ValidateBackupRequest]) (*connect.Response[pb.ValidateBackupResponse], error) {
-	if len(c.Msg.BackupData) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("backup_data is required"))
+func (s *Server) ValidateBackup(ctx context.Context, c *pb.ValidateBackupRequest) (*pb.ValidateBackupResponse, error) {
+	if len(c.BackupData) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "backup_data is required")
 	}
-	if c.Msg.Filename == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("filename is required"))
+	if c.Filename == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "filename is required")
 	}
 
-	contents, err := s.backupEngine.ValidateBackup(ctx, c.Msg.BackupData, c.Msg.Filename)
+	contents, err := s.backupEngine.ValidateBackup(ctx, c.BackupData, c.Filename)
 	if err != nil {
-		return connect.NewResponse(&pb.ValidateBackupResponse{
+		return &pb.ValidateBackupResponse{
 			Valid:        false,
 			ErrorMessage: err.Error(),
-		}), nil
+		}, nil
 	}
 
-	return connect.NewResponse(&pb.ValidateBackupResponse{
+	return &pb.ValidateBackupResponse{
 		Valid:           true,
 		HasWallet:       contents.HasWallet,
 		HasMultisig:     contents.HasMultisig,
 		HasTransactions: contents.HasTransactions,
-	}), nil
+	}, nil
 }
diff --git a/bitwindow/server/api/wallet/wallet_test.go b/bitwindow/server/api/wallet/wallet_test.go
index 5fda38e57b..50a991c7ad 100644
--- a/bitwindow/server/api/wallet/wallet_test.go
+++ b/bitwindow/server/api/wallet/wallet_test.go
@@ -12,7 +12,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	bitcoindv1alpha "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
@@ -51,22 +52,20 @@ func TestService_GetBalance(t *testing.T) {
 		apitests.ExpectOrchestratorReads(mockOrch)
 		mockOrch.EXPECT().
 			GetBalance(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.GetBalanceResponse]{
-				Msg: &orchpb.GetBalanceResponse{
-					ConfirmedSats:   100000,
-					UnconfirmedSats: 50000,
-				},
+			Return(&orchpb.GetBalanceResponse{
+				ConfirmedSats:   100000,
+				UnconfirmedSats: 50000,
 			}, nil)
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
 		// Use the test wallet ID from apitests.createTestWalletJSON
-		resp, err := cli.GetBalance(t.Context(), connect.NewRequest(&walletv1.GetBalanceRequest{
+		resp, err := cli.GetBalance(t.Context(), &walletv1.GetBalanceRequest{
 			WalletId: "test-wallet-id-1234",
-		}))
+		})
 		require.NoError(t, err)
-		require.Equal(t, uint64(100000), resp.Msg.ConfirmedSatoshi)
-		require.Equal(t, uint64(50000), resp.Msg.PendingSatoshi)
+		require.Equal(t, uint64(100000), resp.ConfirmedSatoshi)
+		require.Equal(t, uint64(50000), resp.PendingSatoshi)
 	})
 
 }
@@ -120,10 +119,10 @@ func TestSendTransaction(t *testing.T) {
 
 			mockOrch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 			apitests.ExpectOrchestratorReads(mockOrch)
-			cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
+			cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
 
 			tt.req.WalletId = testWalletID
-			_, err := cli.SendTransaction(t.Context(), connect.NewRequest(tt.req))
+			_, err := cli.SendTransaction(t.Context(), tt.req)
 			require.ErrorContains(t, err, tt.wantErr)
 			assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		})
@@ -135,18 +134,18 @@ func TestSendTransaction(t *testing.T) {
 		mockOrch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 		apitests.ExpectOrchestratorReads(mockOrch)
 		mockOrch.EXPECT().
-			SendTransaction(gomock.Any(), gomock.Cond(func(req *connect.Request[orchpb.SendTransactionRequest]) bool {
-				return req.Msg.Destinations["bcrt1qdest"] == 546
+			SendTransaction(gomock.Any(), gomock.Cond(func(req *orchpb.SendTransactionRequest) bool {
+				return req.Destinations["bcrt1qdest"] == 546
 			})).
-			Return(connect.NewResponse(&orchpb.SendTransactionResponse{Txid: "sent"}), nil)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
+			Return(&orchpb.SendTransactionResponse{Txid: "sent"}, nil)
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
 
-		resp, err := cli.SendTransaction(t.Context(), connect.NewRequest(&walletv1.SendTransactionRequest{
+		resp, err := cli.SendTransaction(t.Context(), &walletv1.SendTransactionRequest{
 			WalletId:     testWalletID,
 			Destinations: map[string]uint64{"bcrt1qdest": 546},
-		}))
+		})
 		require.NoError(t, err)
-		assert.Equal(t, "sent", resp.Msg.Txid)
+		assert.Equal(t, "sent", resp.Txid)
 	})
 }
 
@@ -169,17 +168,17 @@ func TestGetBalanceRoundsBTCToSats(t *testing.T) {
 			mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 			mockBitcoind.EXPECT().
 				GetBalances(gomock.Any(), gomock.Any()).
-				Return(connect.NewResponse(&bitcoindv1alpha.GetBalancesResponse{
+				Return(connectv1.NewResponse(&bitcoindv1alpha.GetBalancesResponse{
 					Mine: &bitcoindv1alpha.GetBalancesResponse_Mine{Trusted: tt.btc, UntrustedPending: tt.btc, Immature: tt.btc},
 				}), nil)
 			apitests.ExpectCoreWalletSetup(mockBitcoind)
-			cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+			cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-			resp, err := cli.GetBalance(t.Context(), connect.NewRequest(&walletv1.GetBalanceRequest{WalletId: testWalletID}))
+			resp, err := cli.GetBalance(t.Context(), &walletv1.GetBalanceRequest{WalletId: testWalletID})
 			require.NoError(t, err)
-			require.Equal(t, tt.sats, resp.Msg.ConfirmedSatoshi)
-			require.Equal(t, tt.sats, resp.Msg.PendingSatoshi)
-			require.Equal(t, tt.sats, resp.Msg.ImmatureSatoshi)
+			require.Equal(t, tt.sats, resp.ConfirmedSatoshi)
+			require.Equal(t, tt.sats, resp.PendingSatoshi)
+			require.Equal(t, tt.sats, resp.ImmatureSatoshi)
 		})
 	}
 }
@@ -223,20 +222,20 @@ func TestGetBalanceSumsMineAndWatchOnly(t *testing.T) {
 			mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 			mockBitcoind.EXPECT().
 				GetBalances(gomock.Any(), gomock.Any()).
-				Return(connect.NewResponse(tt.resp), nil)
+				Return(connectv1.NewResponse(tt.resp), nil)
 			mockBitcoind.EXPECT().
 				LoadWallet(gomock.Any(), gomock.Any()).
 				Return(nil, errors.New("wallet file not found")).
 				AnyTimes()
 			apitests.ExpectCoreWalletSetup(mockBitcoind)
-			cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db,
+			cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db,
 				apitests.WithCoreWallet(), apitests.WithWatchOnlyWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-			resp, err := cli.GetBalance(t.Context(), connect.NewRequest(&walletv1.GetBalanceRequest{WalletId: testWalletID}))
+			resp, err := cli.GetBalance(t.Context(), &walletv1.GetBalanceRequest{WalletId: testWalletID})
 			require.NoError(t, err)
-			assert.Equal(t, tt.sats, resp.Msg.ConfirmedSatoshi)
-			assert.Equal(t, tt.sats, resp.Msg.PendingSatoshi)
-			assert.Equal(t, tt.sats, resp.Msg.ImmatureSatoshi)
+			assert.Equal(t, tt.sats, resp.ConfirmedSatoshi)
+			assert.Equal(t, tt.sats, resp.PendingSatoshi)
+			assert.Equal(t, tt.sats, resp.ImmatureSatoshi)
 		})
 	}
 }
@@ -248,16 +247,16 @@ func TestListUnspentRoundsBTCToSats(t *testing.T) {
 	mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 	mockBitcoind.EXPECT().
 		ListUnspent(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&bitcoindv1alpha.ListUnspentResponse{
+		Return(connectv1.NewResponse(&bitcoindv1alpha.ListUnspentResponse{
 			Unspent: []*bitcoindv1alpha.UnspentOutput{{Txid: "aa", Vout: 1, Address: "bcrt1qtest", Amount: 0.29}},
 		}), nil)
 	apitests.ExpectCoreWalletSetup(mockBitcoind)
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-	resp, err := cli.ListUnspent(t.Context(), connect.NewRequest(&walletv1.ListUnspentRequest{WalletId: testWalletID}))
+	resp, err := cli.ListUnspent(t.Context(), &walletv1.ListUnspentRequest{WalletId: testWalletID})
 	require.NoError(t, err)
-	require.Len(t, resp.Msg.Utxos, 1)
-	require.Equal(t, uint64(29_000_000), resp.Msg.Utxos[0].ValueSats)
+	require.Len(t, resp.Utxos, 1)
+	require.Equal(t, uint64(29_000_000), resp.Utxos[0].ValueSats)
 }
 
 func TestService_GetNewAddress(t *testing.T) {
@@ -274,18 +273,16 @@ func TestService_GetNewAddress(t *testing.T) {
 		apitests.ExpectOrchestratorReads(mockOrch)
 		mockOrch.EXPECT().
 			GetNewAddress(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[orchpb.GetNewAddressResponse]{
-				Msg: &orchpb.GetNewAddressResponse{Address: "bc1qtest123456789"},
-			}, nil)
+			Return(&orchpb.GetNewAddressResponse{Address: "bc1qtest123456789"}, nil)
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database, apitests.WithOrchestrator(mockOrch)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database, apitests.WithOrchestrator(mockOrch)))
 
 		// Use the test wallet ID from apitests.createTestWalletJSON
-		resp, err := cli.GetNewAddress(t.Context(), connect.NewRequest(&walletv1.GetNewAddressRequest{
+		resp, err := cli.GetNewAddress(t.Context(), &walletv1.GetNewAddressRequest{
 			WalletId: "test-wallet-id-1234",
-		}))
+		})
 		require.NoError(t, err)
-		require.Equal(t, "bc1qtest123456789", resp.Msg.Address)
+		require.Equal(t, "bc1qtest123456789", resp.Address)
 	})
 
 	t.Run("an address the book holds returns again", func(t *testing.T) {
@@ -295,14 +292,14 @@ func TestService_GetNewAddress(t *testing.T) {
 		apitests.ExpectOrchestratorReads(mockOrch)
 		mockOrch.EXPECT().
 			GetNewAddress(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.GetNewAddressResponse{Address: "bc1qtest123456789"}), nil).
+			Return(&orchpb.GetNewAddressResponse{Address: "bc1qtest123456789"}, nil).
 			Times(2)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
 
 		for range 2 {
-			resp, err := cli.GetNewAddress(t.Context(), connect.NewRequest(&walletv1.GetNewAddressRequest{WalletId: testWalletID}))
+			resp, err := cli.GetNewAddress(t.Context(), &walletv1.GetNewAddressRequest{WalletId: testWalletID})
 			require.NoError(t, err)
-			require.Equal(t, "bc1qtest123456789", resp.Msg.Address)
+			require.Equal(t, "bc1qtest123456789", resp.Address)
 		}
 	})
 }
@@ -313,9 +310,9 @@ func TestService_CreateCheque(t *testing.T) {
 	t.Run("an empty wallet id is an invalid argument", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithPasswordWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithPasswordWallet()))
 
-		_, err := cli.CreateCheque(t.Context(), connect.NewRequest(&walletv1.CreateChequeRequest{ExpectedAmountSats: 1000}))
+		_, err := cli.CreateCheque(t.Context(), &walletv1.CreateChequeRequest{ExpectedAmountSats: 1000})
 		require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 
@@ -323,9 +320,9 @@ func TestService_CreateCheque(t *testing.T) {
 		t.Parallel()
 
 		db := database.Test(t)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithPasswordWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithPasswordWallet()))
 
-		_, err := cli.CreateCheque(t.Context(), connect.NewRequest(&walletv1.CreateChequeRequest{WalletId: testWalletID, ExpectedAmountSats: 1000}))
+		_, err := cli.CreateCheque(t.Context(), &walletv1.CreateChequeRequest{WalletId: testWalletID, ExpectedAmountSats: 1000})
 		require.ErrorContains(t, err, "wallet is locked")
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 
@@ -337,10 +334,10 @@ func TestService_CreateCheque(t *testing.T) {
 	t.Run("a wallet with no seed keeps the orchestrator code", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t),
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t),
 			apitests.WithOrchestrator(seedlessOrchestrator{&fakeOrchestrator{}})))
 
-		_, err := cli.CreateCheque(t.Context(), connect.NewRequest(&walletv1.CreateChequeRequest{WalletId: testWalletID, ExpectedAmountSats: 1000}))
+		_, err := cli.CreateCheque(t.Context(), &walletv1.CreateChequeRequest{WalletId: testWalletID, ExpectedAmountSats: 1000})
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
 }
@@ -350,9 +347,9 @@ type seedlessOrchestrator struct {
 }
 
 func (seedlessOrchestrator) GetWalletSeed(
-	context.Context, *connect.Request[orchpb.GetWalletSeedRequest],
-) (*connect.Response[orchpb.GetWalletSeedResponse], error) {
-	return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet has no seed"))
+	context.Context, *orchpb.GetWalletSeedRequest,
+) (*orchpb.GetWalletSeedResponse, error) {
+	return nil, connect.NewError(connect.CodeFailedPrecondition, "wallet has no seed")
 }
 
 func TestService_GetChequePrivateKey(t *testing.T) {
@@ -364,9 +361,9 @@ func TestService_GetChequePrivateKey(t *testing.T) {
 		db := database.Test(t)
 		chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 1000, "tb1qtestaddress000000000000000000000000000")
 		require.NoError(t, err)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithPasswordWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithPasswordWallet()))
 
-		_, err = cli.GetChequePrivateKey(t.Context(), connect.NewRequest(&walletv1.GetChequePrivateKeyRequest{WalletId: testWalletID, Id: chequeID}))
+		_, err = cli.GetChequePrivateKey(t.Context(), &walletv1.GetChequePrivateKeyRequest{WalletId: testWalletID, Id: chequeID})
 		require.ErrorContains(t, err, "wallet is locked")
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
@@ -374,18 +371,18 @@ func TestService_GetChequePrivateKey(t *testing.T) {
 	t.Run("the key spends from the cheque address", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t)))
-		created, err := cli.CreateCheque(t.Context(), connect.NewRequest(&walletv1.CreateChequeRequest{WalletId: testWalletID, ExpectedAmountSats: 1000}))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t)))
+		created, err := cli.CreateCheque(t.Context(), &walletv1.CreateChequeRequest{WalletId: testWalletID, ExpectedAmountSats: 1000})
 		require.NoError(t, err)
 
-		resp, err := cli.GetChequePrivateKey(t.Context(), connect.NewRequest(&walletv1.GetChequePrivateKeyRequest{WalletId: testWalletID, Id: created.Msg.Id}))
+		resp, err := cli.GetChequePrivateKey(t.Context(), &walletv1.GetChequePrivateKeyRequest{WalletId: testWalletID, Id: created.Id})
 		require.NoError(t, err)
 
-		wif, err := btcutil.DecodeWIF(resp.Msg.PrivateKeyWif)
+		wif, err := btcutil.DecodeWIF(resp.PrivateKeyWif)
 		require.NoError(t, err)
 		address, err := btcutil.NewAddressWitnessPubKeyHash(btcutil.Hash160(wif.SerializePubKey()), &chaincfg.SigNetParams)
 		require.NoError(t, err)
-		assert.Equal(t, created.Msg.Address, address.EncodeAddress())
+		assert.Equal(t, created.Address, address.EncodeAddress())
 	})
 
 	t.Run("a wallet with no seed keeps the orchestrator code", func(t *testing.T) {
@@ -394,10 +391,10 @@ func TestService_GetChequePrivateKey(t *testing.T) {
 		db := database.Test(t)
 		chequeID, err := cheques.Create(t.Context(), db, testWalletID, 0, 1000, "tb1qtestaddress000000000000000000000000000")
 		require.NoError(t, err)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db,
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db,
 			apitests.WithOrchestrator(seedlessOrchestrator{&fakeOrchestrator{}})))
 
-		_, err = cli.GetChequePrivateKey(t.Context(), connect.NewRequest(&walletv1.GetChequePrivateKeyRequest{WalletId: testWalletID, Id: chequeID}))
+		_, err = cli.GetChequePrivateKey(t.Context(), &walletv1.GetChequePrivateKeyRequest{WalletId: testWalletID, Id: chequeID})
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
 }
@@ -408,27 +405,27 @@ func TestService_SignMessage(t *testing.T) {
 	t.Run("a signature verifies without a node", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t)))
 		const message = "signed by Bjørn"
 		for _, address := range []string{fixtureSegwitAddress(t, 2), fixtureTaprootAddress(t, 1)} {
-			signed, err := cli.SignMessage(t.Context(), connect.NewRequest(&walletv1.SignMessageRequest{
+			signed, err := cli.SignMessage(t.Context(), &walletv1.SignMessageRequest{
 				WalletId: testWalletID,
 				Message:  message,
 				Address:  address,
-			}))
+			})
 			require.NoError(t, err)
 
 			for _, tc := range []struct {
 				message string
 				valid   bool
 			}{{message, true}, {message + " ", false}} {
-				verified, err := cli.VerifyMessage(t.Context(), connect.NewRequest(&walletv1.VerifyMessageRequest{
+				verified, err := cli.VerifyMessage(t.Context(), &walletv1.VerifyMessageRequest{
 					Message:   tc.message,
-					Signature: signed.Msg.Signature,
+					Signature: signed.Signature,
 					PublicKey: address,
-				}))
+				})
 				require.NoError(t, err)
-				assert.Equal(t, tc.valid, verified.Msg.Valid)
+				assert.Equal(t, tc.valid, verified.Valid)
 			}
 		}
 	})
@@ -436,13 +433,13 @@ func TestService_SignMessage(t *testing.T) {
 	t.Run("a locked wallet refuses", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithPasswordWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithPasswordWallet()))
 
-		_, err := cli.SignMessage(t.Context(), connect.NewRequest(&walletv1.SignMessageRequest{
+		_, err := cli.SignMessage(t.Context(), &walletv1.SignMessageRequest{
 			WalletId: testWalletID,
 			Address:  "tb1qtestaddress000000000000000000000000000",
 			Message:  "hello",
-		}))
+		})
 		require.ErrorContains(t, err, "wallet is locked")
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
@@ -450,13 +447,13 @@ func TestService_SignMessage(t *testing.T) {
 	t.Run("an address of another wallet is an invalid argument", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t)))
 
-		_, err := cli.SignMessage(t.Context(), connect.NewRequest(&walletv1.SignMessageRequest{
+		_, err := cli.SignMessage(t.Context(), &walletv1.SignMessageRequest{
 			WalletId: testWalletID,
 			Address:  "tb1q6rz28mcfaxtmd6v789l9rrlrusdprr9pqcpvkl",
 			Message:  "hello",
-		}))
+		})
 		require.ErrorContains(t, err, "is not one of the wallet's first")
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
@@ -464,13 +461,13 @@ func TestService_SignMessage(t *testing.T) {
 	t.Run("a wallet with no seed is a failed precondition", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithWatchOnlyWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithWatchOnlyWallet()))
 
-		_, err := cli.SignMessage(t.Context(), connect.NewRequest(&walletv1.SignMessageRequest{
+		_, err := cli.SignMessage(t.Context(), &walletv1.SignMessageRequest{
 			WalletId: testWalletID,
 			Address:  "tb1q6rz28mcfaxtmd6v789l9rrlrusdprr9pqcpvkl",
 			Message:  "hello",
-		}))
+		})
 		require.ErrorContains(t, err, "holds no master seed")
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
@@ -488,22 +485,22 @@ func TestService_ListCheques(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.ListWalletsResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.ListWalletsResponse]{
 				Msg: &bitcoindv1alpha.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.CreateWalletResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.CreateWalletResponse]{
 				Msg: &bitcoindv1alpha.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListCheques(t.Context(), connect.NewRequest(&walletv1.ListChequesRequest{
+		resp, err := cli.ListCheques(t.Context(), &walletv1.ListChequesRequest{
 			WalletId: "test-wallet-id-1234",
-		}))
+		})
 		require.NoError(t, err)
-		require.Empty(t, resp.Msg.Cheques)
+		require.Empty(t, resp.Cheques)
 	})
 }
 
@@ -519,21 +516,21 @@ func TestService_GetCheque(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.ListWalletsResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.ListWalletsResponse]{
 				Msg: &bitcoindv1alpha.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.CreateWalletResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.CreateWalletResponse]{
 				Msg: &bitcoindv1alpha.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.GetCheque(t.Context(), connect.NewRequest(&walletv1.GetChequeRequest{
+		_, err := cli.GetCheque(t.Context(), &walletv1.GetChequeRequest{
 			WalletId: "test-wallet-id-1234",
 			Id:       99999,
-		}))
+		})
 		require.ErrorContains(t, err, "cheque not found")
 		// A non-existent cheque must surface as NotFound, not a leaked
 		// "no rows" internal error.
@@ -553,21 +550,21 @@ func TestService_DeleteCheque(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.ListWalletsResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.ListWalletsResponse]{
 				Msg: &bitcoindv1alpha.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.CreateWalletResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.CreateWalletResponse]{
 				Msg: &bitcoindv1alpha.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.DeleteCheque(t.Context(), connect.NewRequest(&walletv1.DeleteChequeRequest{
+		_, err := cli.DeleteCheque(t.Context(), &walletv1.DeleteChequeRequest{
 			WalletId: "test-wallet-id-1234",
 			Id:       99999,
-		}))
+		})
 		require.ErrorContains(t, err, "cheque not found")
 		// A non-existent cheque must surface as NotFound, not a leaked
 		// "no rows" internal error.
@@ -594,16 +591,16 @@ func TestService_DeleteChequeFundingGuard(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.ListWalletsResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.ListWalletsResponse]{
 				Msg: &bitcoindv1alpha.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.CreateWalletResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.CreateWalletResponse]{
 				Msg: &bitcoindv1alpha.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithBitcoind(mockBitcoind)))
 		return cli, db
 	}
 
@@ -618,10 +615,10 @@ func TestService_DeleteChequeFundingGuard(t *testing.T) {
 		require.NoError(t, cheques.UpdateFunding(t.Context(), db, testWalletID, chequeID,
 			[]cheques.FundingOutput{{Txid: "partial0partial0partial0partial0partial0partial0partial0partial0"}}, 50_000_000))
 
-		_, err = cli.DeleteCheque(t.Context(), connect.NewRequest(&walletv1.DeleteChequeRequest{
+		_, err = cli.DeleteCheque(t.Context(), &walletv1.DeleteChequeRequest{
 			WalletId: testWalletID,
 			Id:       chequeID,
-		}))
+		})
 		require.ErrorContains(t, err, "cannot delete funded cheque")
 		require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 
@@ -640,10 +637,10 @@ func TestService_DeleteChequeFundingGuard(t *testing.T) {
 		require.NoError(t, cheques.UpdateFunding(t.Context(), db, testWalletID, chequeID,
 			[]cheques.FundingOutput{{Txid: "full0000full0000full0000full0000full0000full0000full0000full0000"}}, 100_000_000))
 
-		_, err = cli.DeleteCheque(t.Context(), connect.NewRequest(&walletv1.DeleteChequeRequest{
+		_, err = cli.DeleteCheque(t.Context(), &walletv1.DeleteChequeRequest{
 			WalletId: testWalletID,
 			Id:       chequeID,
-		}))
+		})
 		require.ErrorContains(t, err, "cannot delete funded cheque")
 		require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 
@@ -663,10 +660,10 @@ func TestService_DeleteChequeFundingGuard(t *testing.T) {
 		require.NoError(t, cheques.UpdateSwept(t.Context(), db, testWalletID, chequeID,
 			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef0"))
 
-		_, err = cli.DeleteCheque(t.Context(), connect.NewRequest(&walletv1.DeleteChequeRequest{
+		_, err = cli.DeleteCheque(t.Context(), &walletv1.DeleteChequeRequest{
 			WalletId: testWalletID,
 			Id:       chequeID,
-		}))
+		})
 		require.NoError(t, err)
 
 		// Once swept, the row is gone.
@@ -687,27 +684,27 @@ func TestService_IsWalletUnlocked(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.ListWalletsResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.ListWalletsResponse]{
 				Msg: &bitcoindv1alpha.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.CreateWalletResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.CreateWalletResponse]{
 				Msg: &bitcoindv1alpha.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
-		_, err := cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 	})
 
 	t.Run("an encrypted wallet is locked at start", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithPasswordWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithPasswordWallet()))
 
-		_, err := cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
 }
@@ -718,33 +715,33 @@ func TestService_LockWallet(t *testing.T) {
 	t.Run("a wallet with no password refuses the lock", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t)))
 
-		_, err := cli.LockWallet(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := cli.LockWallet(t.Context(), &emptypb.Empty{})
 		require.ErrorContains(t, err, "wallet is not encrypted")
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 
-		_, err = cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err = cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 	})
 
 	t.Run("a locked password wallet unlocks again", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithPasswordWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithPasswordWallet()))
 		unlock := func() error {
-			_, err := cli.UnlockWallet(t.Context(), connect.NewRequest(&walletv1.UnlockWalletRequest{Password: apitests.EncryptedWalletPassword}))
+			_, err := cli.UnlockWallet(t.Context(), &walletv1.UnlockWalletRequest{Password: apitests.EncryptedWalletPassword})
 			return err
 		}
 		require.NoError(t, unlock())
 
-		_, err := cli.LockWallet(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := cli.LockWallet(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
-		_, err = cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err = cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 
 		require.NoError(t, unlock())
-		_, err = cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err = cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 	})
 }
@@ -761,48 +758,48 @@ func TestService_UnlockWallet(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.ListWalletsResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.ListWalletsResponse]{
 				Msg: &bitcoindv1alpha.ListWalletsResponse{Wallets: []string{}},
 			}, nil).AnyTimes()
 		mockBitcoind.EXPECT().
 			CreateWallet(gomock.Any(), gomock.Any()).
-			Return(&connect.Response[bitcoindv1alpha.CreateWalletResponse]{
+			Return(&connectv1.Response[bitcoindv1alpha.CreateWalletResponse]{
 				Msg: &bitcoindv1alpha.CreateWalletResponse{Name: "test_wallet"},
 			}, nil).AnyTimes()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database, apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database, apitests.WithBitcoind(mockBitcoind)))
 
 		// Test wallet is not encrypted, so unlock should fail
-		_, err := cli.UnlockWallet(t.Context(), connect.NewRequest(&walletv1.UnlockWalletRequest{
+		_, err := cli.UnlockWallet(t.Context(), &walletv1.UnlockWalletRequest{
 			Password: "anypassword",
-		}))
+		})
 		require.ErrorContains(t, err, "not encrypted")
 	})
 
 	t.Run("the right password unlocks", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithPasswordWallet()))
-		_, err := cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithPasswordWallet()))
+		_, err := cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 
-		_, err = cli.UnlockWallet(t.Context(), connect.NewRequest(&walletv1.UnlockWalletRequest{Password: apitests.EncryptedWalletPassword}))
+		_, err = cli.UnlockWallet(t.Context(), &walletv1.UnlockWalletRequest{Password: apitests.EncryptedWalletPassword})
 		require.NoError(t, err)
 
-		_, err = cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err = cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 	})
 
 	t.Run("a wrong password is unauthenticated", func(t *testing.T) {
 		t.Parallel()
 
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithPasswordWallet()))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithPasswordWallet()))
 
-		_, err := cli.UnlockWallet(t.Context(), connect.NewRequest(&walletv1.UnlockWalletRequest{Password: "wrong"}))
+		_, err := cli.UnlockWallet(t.Context(), &walletv1.UnlockWalletRequest{Password: "wrong"})
 		require.ErrorContains(t, err, "incorrect password")
 		assert.Equal(t, connect.CodeUnauthenticated, connect.CodeOf(err))
 
-		_, err = cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err = cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
 }
@@ -811,16 +808,16 @@ func TestOrchestratorLockStateShowsInBitwindowd(t *testing.T) {
 	t.Parallel()
 
 	orchestrator := apitests.PasswordWalletOrchestrator(t)
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
 
-	_, err := orchestrator.UnlockWallet(t.Context(), connect.NewRequest(&orchpb.UnlockWalletRequest{Password: apitests.EncryptedWalletPassword}))
+	_, err := orchestrator.UnlockWallet(t.Context(), &orchpb.UnlockWalletRequest{Password: apitests.EncryptedWalletPassword})
 	require.NoError(t, err)
-	_, err = cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+	_, err = cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 	require.NoError(t, err)
 
-	_, err = orchestrator.LockWallet(t.Context(), connect.NewRequest(&orchpb.LockWalletRequest{}))
+	_, err = orchestrator.LockWallet(t.Context(), &orchpb.LockWalletRequest{})
 	require.NoError(t, err)
-	_, err = cli.IsWalletUnlocked(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+	_, err = cli.IsWalletUnlocked(t.Context(), &emptypb.Empty{})
 	require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 }
 
@@ -838,22 +835,20 @@ func TestListSidechainDepositsReadsTheOrchestrator(t *testing.T) {
 	apitests.ExpectOrchestratorReads(mockOrch)
 	mockOrch.EXPECT().
 		ListSidechainDeposits(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.ListSidechainDepositsResponse]{
-			Msg: &orchpb.ListSidechainDepositsResponse{
-				Deposits: []*orchpb.SidechainDeposit{
-					{Txid: "deadbeef", Slot: 9, AmountSats: 50_000},
-				},
+		Return(&orchpb.ListSidechainDepositsResponse{
+			Deposits: []*orchpb.SidechainDeposit{
+				{Txid: "deadbeef", Slot: 9, AmountSats: 50_000},
 			},
 		}, nil)
 
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database,
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database,
 		apitests.WithBitcoind(mockBitcoind), apitests.WithOrchestrator(mockOrch)))
 
-	resp, err := cli.ListSidechainDeposits(t.Context(), connect.NewRequest(&walletv1.ListSidechainDepositsRequest{Slot: 9}))
+	resp, err := cli.ListSidechainDeposits(t.Context(), &walletv1.ListSidechainDepositsRequest{Slot: 9})
 	require.NoError(t, err)
-	require.Len(t, resp.Msg.Deposits, 1)
-	require.Equal(t, "deadbeef", resp.Msg.Deposits[0].Txid)
-	require.Equal(t, int64(50_000), resp.Msg.Deposits[0].Amount)
+	require.Len(t, resp.Deposits, 1)
+	require.Equal(t, "deadbeef", resp.Deposits[0].Txid)
+	require.Equal(t, int64(50_000), resp.Deposits[0].Amount)
 }
 
 const depositSidechainAddress = "2N4sbtVhMXbzwtNrfACjoGzGkQxSJ9Fz2eP"
@@ -873,23 +868,23 @@ func TestCreateSidechainDepositSlot(t *testing.T) {
 	mockOrch.EXPECT().
 		CreateDeposit(gomock.Any(), gomock.Any()).
 		DoAndReturn(func(
-			_ any, req *connect.Request[orchpb.CreateDepositRequest],
-		) (*connect.Response[orchpb.CreateDepositResponse], error) {
-			deposits = append(deposits, req.Msg)
-			return connect.NewResponse(&orchpb.CreateDepositResponse{Txid: "deposit-txid"}), nil
+			_ any, req *orchpb.CreateDepositRequest,
+		) (*orchpb.CreateDepositResponse, error) {
+			deposits = append(deposits, req)
+			return &orchpb.CreateDepositResponse{Txid: "deposit-txid"}, nil
 		}).
 		AnyTimes()
-	cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(mockOrch)))
+	cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(mockOrch)))
 
 	createDeposit := func(t *testing.T, slot int64, destination string) error {
 		deposits = nil
-		_, err := cli.CreateSidechainDeposit(t.Context(), connect.NewRequest(&walletv1.CreateSidechainDepositRequest{
+		_, err := cli.CreateSidechainDeposit(t.Context(), &walletv1.CreateSidechainDepositRequest{
 			WalletId:    testWalletID,
 			Slot:        slot,
 			Destination: destination,
 			Amount:      0.001,
 			Fee:         0.0001,
-		}))
+		})
 		return err
 	}
 
@@ -930,7 +925,7 @@ func TestCreateSidechainDepositSlot(t *testing.T) {
 			t.Run(tt.name, func(t *testing.T) {
 				deposits = nil
 				tt.req.WalletId = testWalletID
-				_, err := cli.CreateSidechainDeposit(t.Context(), connect.NewRequest(tt.req))
+				_, err := cli.CreateSidechainDeposit(t.Context(), tt.req)
 				require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 				require.Empty(t, deposits)
 			})
@@ -957,15 +952,15 @@ func TestGetTransactionDetails(t *testing.T) {
 		}
 	}
 
-	details := func(t *testing.T, tx *bitcoindv1alpha.GetRawTransactionResponse) (*connect.Response[walletv1.GetTransactionDetailsResponse], error) {
+	details := func(t *testing.T, tx *bitcoindv1alpha.GetRawTransactionResponse) (*walletv1.GetTransactionDetailsResponse, error) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 		mockBitcoind.EXPECT().
 			GetRawTransaction(gomock.Any(), gomock.Any()).
 			Times(1).
-			Return(connect.NewResponse(tx), nil)
+			Return(connectv1.NewResponse(tx), nil)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
-		return cli.GetTransactionDetails(t.Context(), connect.NewRequest(&walletv1.GetTransactionDetailsRequest{Txid: "spend"}))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
+		return cli.GetTransactionDetails(t.Context(), &walletv1.GetTransactionDetailsRequest{Txid: "spend"})
 	}
 
 	t.Run("the fee is inputs less outputs", func(t *testing.T) {
@@ -974,27 +969,27 @@ func TestGetTransactionDetails(t *testing.T) {
 			ScriptPubKey: &bitcoindv1alpha.ScriptPubKey{Address: "tb1qparent"},
 		}))
 		require.NoError(t, err)
-		assert.Equal(t, int64(29_000_000), resp.Msg.TotalInputSats)
-		assert.Equal(t, int64(28_000_000), resp.Msg.TotalOutputSats)
-		assert.Equal(t, int64(1_000_000), resp.Msg.FeeSats)
-		require.Len(t, resp.Msg.Inputs, 1)
-		assert.Equal(t, "tb1qparent", resp.Msg.Inputs[0].Address)
+		assert.Equal(t, int64(29_000_000), resp.TotalInputSats)
+		assert.Equal(t, int64(28_000_000), resp.TotalOutputSats)
+		assert.Equal(t, int64(1_000_000), resp.FeeSats)
+		require.Len(t, resp.Inputs, 1)
+		assert.Equal(t, "tb1qparent", resp.Inputs[0].Address)
 	})
 
-	withParent := func(t *testing.T, parentOutputs []*bitcoindv1alpha.Output) (*connect.Response[walletv1.GetTransactionDetailsResponse], error) {
+	withParent := func(t *testing.T, parentOutputs []*bitcoindv1alpha.Output) (*walletv1.GetTransactionDetailsResponse, error) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 		mockBitcoind.EXPECT().
 			GetRawTransaction(gomock.Any(), gomock.Any()).
 			Times(2).
-			DoAndReturn(func(_ context.Context, req *connect.Request[bitcoindv1alpha.GetRawTransactionRequest]) (*connect.Response[bitcoindv1alpha.GetRawTransactionResponse], error) {
+			DoAndReturn(func(_ context.Context, req *connectv1.Request[bitcoindv1alpha.GetRawTransactionRequest]) (*connectv1.Response[bitcoindv1alpha.GetRawTransactionResponse], error) {
 				if req.Msg.Txid == "parent" {
-					return connect.NewResponse(&bitcoindv1alpha.GetRawTransactionResponse{Txid: "parent", Outputs: parentOutputs}), nil
+					return connectv1.NewResponse(&bitcoindv1alpha.GetRawTransactionResponse{Txid: "parent", Outputs: parentOutputs}), nil
 				}
-				return connect.NewResponse(spend(nil)), nil
+				return connectv1.NewResponse(spend(nil)), nil
 			})
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
-		return cli.GetTransactionDetails(t.Context(), connect.NewRequest(&walletv1.GetTransactionDetailsRequest{Txid: "spend"}))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
+		return cli.GetTransactionDetails(t.Context(), &walletv1.GetTransactionDetailsRequest{Txid: "spend"})
 	}
 
 	t.Run("an input with no prevout reads the parent", func(t *testing.T) {
@@ -1003,15 +998,16 @@ func TestGetTransactionDetails(t *testing.T) {
 			{Amount: 0.29, ScriptPubKey: &bitcoindv1alpha.ScriptPubKey{Address: "tb1qparent"}},
 		})
 		require.NoError(t, err)
-		assert.Equal(t, int64(29_000_000), resp.Msg.TotalInputSats)
-		assert.Equal(t, int64(1_000_000), resp.Msg.FeeSats)
-		require.Len(t, resp.Msg.Inputs, 1)
-		assert.Equal(t, "tb1qparent", resp.Msg.Inputs[0].Address)
+		assert.Equal(t, int64(29_000_000), resp.TotalInputSats)
+		assert.Equal(t, int64(1_000_000), resp.FeeSats)
+		require.Len(t, resp.Inputs, 1)
+		assert.Equal(t, "tb1qparent", resp.Inputs[0].Address)
 	})
 
 	t.Run("a parent with no such output returns an error", func(t *testing.T) {
 		_, err := withParent(t, []*bitcoindv1alpha.Output{{Amount: 0.5}})
-		require.ErrorContains(t, err, "previous transaction parent has no output 1")
+		require.Equal(t, connect.CodeUnknown, connect.CodeOf(err))
+		require.NotContains(t, err.Error(), "previous transaction parent has no output 1")
 	})
 
 	for _, tt := range []struct {
@@ -1020,7 +1016,7 @@ func TestGetTransactionDetails(t *testing.T) {
 		wantCode connect.Code
 	}{
 		{name: "an unknown txid is not found", readErr: errors.New("-5: No such mempool or blockchain transaction. Use gettransaction for wallet transactions."), wantCode: connect.CodeNotFound},
-		{name: "a down node keeps its code", readErr: connect.NewError(connect.CodeUnavailable, errors.New("node down")), wantCode: connect.CodeUnavailable},
+		{name: "a down node keeps its code", readErr: connect.NewError(connect.CodeUnavailable, "node down"), wantCode: connect.CodeUnavailable},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
@@ -1028,9 +1024,9 @@ func TestGetTransactionDetails(t *testing.T) {
 				GetRawTransaction(gomock.Any(), gomock.Any()).
 				Return(nil, tt.readErr)
 			apitests.ExpectCoreWalletSetup(mockBitcoind)
-			cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
+			cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithBitcoind(mockBitcoind)))
 
-			_, err := cli.GetTransactionDetails(t.Context(), connect.NewRequest(&walletv1.GetTransactionDetailsRequest{Txid: "spend"}))
+			_, err := cli.GetTransactionDetails(t.Context(), &walletv1.GetTransactionDetailsRequest{Txid: "spend"})
 			assert.Equal(t, tt.wantCode, connect.CodeOf(err))
 		})
 	}
@@ -1043,43 +1039,43 @@ type bumpOrchestrator struct {
 }
 
 func (b *bumpOrchestrator) ListWallets(
-	context.Context, *connect.Request[orchpb.ListWalletsRequest],
-) (*connect.Response[orchpb.ListWalletsResponse], error) {
-	return connect.NewResponse(&orchpb.ListWalletsResponse{
+	context.Context, *orchpb.ListWalletsRequest,
+) (*orchpb.ListWalletsResponse, error) {
+	return &orchpb.ListWalletsResponse{
 		Wallets: []*orchpb.WalletMetadata{{Id: "owner"}, {Id: "other"}},
-	}), nil
+	}, nil
 }
 
 func (b *bumpOrchestrator) BumpFee(
-	_ context.Context, req *connect.Request[orchpb.BumpFeeRequest],
-) (*connect.Response[orchpb.BumpFeeResponse], error) {
-	if err, ok := b.errs[req.Msg.WalletId]; ok {
+	_ context.Context, req *orchpb.BumpFeeRequest,
+) (*orchpb.BumpFeeResponse, error) {
+	if err, ok := b.errs[req.WalletId]; ok {
 		return nil, err
 	}
-	return connect.NewResponse(&orchpb.BumpFeeResponse{NewTxid: "replacement"}), nil
+	return &orchpb.BumpFeeResponse{NewTxid: "replacement"}, nil
 }
 
 func TestBumpFee(t *testing.T) {
 	t.Parallel()
 
-	notFound := connect.NewError(connect.CodeInternal, errors.New("the chain holds no such transaction"))
+	notFound := connect.NewError(connect.CodeInternal, "the chain holds no such transaction")
 
-	bump := func(t *testing.T, errs map[string]error) (*connect.Response[walletv1.BumpFeeResponse], error) {
+	bump := func(t *testing.T, errs map[string]error) (*walletv1.BumpFeeResponse, error) {
 		orchestrator := &bumpOrchestrator{fakeOrchestrator: &fakeOrchestrator{}, errs: errs}
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
-		return cli.BumpFee(t.Context(), connect.NewRequest(&walletv1.BumpFeeRequest{Txid: "original"}))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
+		return cli.BumpFee(t.Context(), &walletv1.BumpFeeRequest{Txid: "original"})
 	}
 
 	t.Run("the owner wallet bumps the fee", func(t *testing.T) {
 		resp, err := bump(t, map[string]error{"": notFound})
 		require.NoError(t, err)
-		require.Equal(t, "replacement", resp.Msg.Txid)
+		require.Equal(t, "replacement", resp.Txid)
 	})
 
 	t.Run("the owner wallet error reaches the caller", func(t *testing.T) {
 		resp, err := bump(t, map[string]error{
 			"":      notFound,
-			"owner": connect.NewError(connect.CodeInternal, errors.New("insufficient fee")),
+			"owner": connect.NewError(connect.CodeInternal, "insufficient fee"),
 			"other": notFound,
 		})
 		require.Nil(t, resp)
@@ -1091,25 +1087,25 @@ func TestBumpFee(t *testing.T) {
 func TestGetCoinSelectionStrategy(t *testing.T) {
 	t.Parallel()
 
-	get := func(t *testing.T, stored string) (*connect.Response[walletv1.GetCoinSelectionStrategyResponse], error) {
+	get := func(t *testing.T, stored string) (*walletv1.GetCoinSelectionStrategyResponse, error) {
 		db := database.Test(t)
 		if stored != "" {
 			require.NoError(t, preferences.Set(t.Context(), db, preferences.KeyCoinSelectionStrategy, stored))
 		}
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db))
-		return cli.GetCoinSelectionStrategy(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db))
+		return cli.GetCoinSelectionStrategy(t.Context(), &emptypb.Empty{})
 	}
 
 	t.Run("no value gives the default", func(t *testing.T) {
 		resp, err := get(t, "")
 		require.NoError(t, err)
-		require.Equal(t, walletv1.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_LARGEST_FIRST, resp.Msg.Strategy)
+		require.Equal(t, walletv1.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_LARGEST_FIRST, resp.Strategy)
 	})
 
 	t.Run("a stored value reads back", func(t *testing.T) {
 		resp, err := get(t, strconv.Itoa(int(walletv1.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_SMALLEST_FIRST)))
 		require.NoError(t, err)
-		require.Equal(t, walletv1.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_SMALLEST_FIRST, resp.Msg.Strategy)
+		require.Equal(t, walletv1.CoinSelectionStrategy_COIN_SELECTION_STRATEGY_SMALLEST_FIRST, resp.Strategy)
 	})
 
 	t.Run("a value that is no number fails", func(t *testing.T) {
@@ -1133,18 +1129,18 @@ func TestListTransactions(t *testing.T) {
 				{Txid: "other", Category: "receive", Address: "bcrt1qc", AmountSats: 500},
 			},
 		}
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
 
-		resp, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		resp, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Transactions, 2)
-		pay := resp.Msg.Transactions[0]
+		require.Len(t, resp.Transactions, 2)
+		pay := resp.Transactions[0]
 		assert.Equal(t, "pay2", pay.Txid)
 		assert.Equal(t, "bcrt1qa", pay.Address)
 		assert.Equal(t, uint64(3_000), pay.SentSatoshi)
 		assert.Equal(t, uint64(0), pay.ReceivedSatoshi)
 		assert.Equal(t, uint64(300), pay.FeeSats)
-		assert.Equal(t, "other", resp.Msg.Transactions[1].Txid)
+		assert.Equal(t, "other", resp.Transactions[1].Txid)
 	})
 
 	t.Run("core gives one transaction for a send to two payees", func(t *testing.T) {
@@ -1153,34 +1149,34 @@ func TestListTransactions(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 		mockBitcoind.EXPECT().
 			ListTransactions(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
+			Return(connectv1.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
 				Transactions: []*bitcoindv1alpha.GetTransactionResponse{
 					{Txid: "pay2", Amount: -0.00001, Fee: -0.000003},
 					{Txid: "pay2", Amount: -0.00002, Fee: -0.000003},
 				},
 			}), nil)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		resp, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Transactions, 1)
-		assert.Equal(t, uint64(3_000), resp.Msg.Transactions[0].SentSatoshi)
-		assert.Equal(t, uint64(300), resp.Msg.Transactions[0].FeeSats)
+		require.Len(t, resp.Transactions, 1)
+		assert.Equal(t, uint64(3_000), resp.Transactions[0].SentSatoshi)
+		assert.Equal(t, uint64(300), resp.Transactions[0].FeeSats)
 	})
 
 	t.Run("core pages until a short page", func(t *testing.T) {
 		t.Parallel()
 
-		page := func(n int, prefix string) *connect.Response[bitcoindv1alpha.ListTransactionsResponse] {
+		page := func(n int, prefix string) *connectv1.Response[bitcoindv1alpha.ListTransactionsResponse] {
 			txs := make([]*bitcoindv1alpha.GetTransactionResponse, n)
 			for i := range txs {
 				txs[i] = &bitcoindv1alpha.GetTransactionResponse{Txid: fmt.Sprintf("%s%d", prefix, i), Amount: 0.001}
 			}
-			return connect.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{Transactions: txs})
+			return connectv1.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{Transactions: txs})
 		}
 		skip := func(n uint32) any {
-			return gomock.Cond(func(req *connect.Request[bitcoindv1alpha.ListTransactionsRequest]) bool {
+			return gomock.Cond(func(req *connectv1.Request[bitcoindv1alpha.ListTransactionsRequest]) bool {
 				return req.Msg.Count == 1000 && req.Msg.Skip == n
 			})
 		}
@@ -1191,11 +1187,11 @@ func TestListTransactions(t *testing.T) {
 			mockBitcoind.EXPECT().ListTransactions(gomock.Any(), skip(2000)).Return(page(1, "c"), nil),
 		)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		resp, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		assert.Len(t, resp.Msg.Transactions, 2001)
+		assert.Len(t, resp.Transactions, 2001)
 	})
 
 	t.Run("core reads the tip from core, not from the enforcer", func(t *testing.T) {
@@ -1204,19 +1200,19 @@ func TestListTransactions(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 		mockBitcoind.EXPECT().
 			ListTransactions(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
+			Return(connectv1.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
 				Transactions: []*bitcoindv1alpha.GetTransactionResponse{
 					{Txid: "tx", Amount: 0.001, Confirmations: 3, Time: timestamppb.Now()},
 				},
 			}), nil)
 		expectCoreTip(mockBitcoind, 300)
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		resp, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Transactions, 1)
-		assert.Equal(t, uint32(298), resp.Msg.Transactions[0].ConfirmationTime.Height)
+		require.Len(t, resp.Transactions, 1)
+		assert.Equal(t, uint32(298), resp.Transactions[0].ConfirmationTime.Height)
 	})
 
 	t.Run("a failed core tip read gives no heights and no error", func(t *testing.T) {
@@ -1225,21 +1221,21 @@ func TestListTransactions(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(gomock.NewController(t))
 		mockBitcoind.EXPECT().
 			ListTransactions(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
+			Return(connectv1.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
 				Transactions: []*bitcoindv1alpha.GetTransactionResponse{
 					{Txid: "tx", Amount: 0.001, Confirmations: 3, Time: timestamppb.Now()},
 				},
 			}), nil)
 		mockBitcoind.EXPECT().
 			GetBlockchainInfo(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, errors.New("core restarts")))
+			Return(nil, connectv1.NewError(connectv1.CodeUnavailable, errors.New("core restarts")))
 		apitests.ExpectCoreWalletSetup(mockBitcoind)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithCoreWallet(), apitests.WithBitcoind(mockBitcoind)))
 
-		resp, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		resp, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Transactions, 1)
-		assert.Equal(t, uint32(0), resp.Msg.Transactions[0].ConfirmationTime.Height)
+		require.Len(t, resp.Transactions, 1)
+		assert.Equal(t, uint32(0), resp.Transactions[0].ConfirmationTime.Height)
 	})
 
 	t.Run("electrum asks for all rows", func(t *testing.T) {
@@ -1247,14 +1243,14 @@ func TestListTransactions(t *testing.T) {
 
 		mockOrch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 		mockOrch.EXPECT().
-			ListTransactions(gomock.Any(), gomock.Cond(func(req *connect.Request[orchpb.ListTransactionsRequest]) bool {
-				return req.Msg.Count == math.MaxInt32
+			ListTransactions(gomock.Any(), gomock.Cond(func(req *orchpb.ListTransactionsRequest) bool {
+				return req.Count == math.MaxInt32
 			})).
-			Return(connect.NewResponse(&orchpb.ListTransactionsResponse{}), nil)
+			Return(&orchpb.ListTransactionsResponse{}, nil)
 		apitests.ExpectOrchestratorReads(mockOrch)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(mockOrch)))
 
-		_, err := cli.ListTransactions(t.Context(), connect.NewRequest(&walletv1.ListTransactionsRequest{WalletId: testWalletID}))
+		_, err := cli.ListTransactions(t.Context(), &walletv1.ListTransactionsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
 	})
 }
@@ -1267,30 +1263,30 @@ type statsOrchestrator struct {
 }
 
 func (s *statsOrchestrator) ListTransactions(
-	context.Context, *connect.Request[orchpb.ListTransactionsRequest],
-) (*connect.Response[orchpb.ListTransactionsResponse], error) {
-	return connect.NewResponse(&orchpb.ListTransactionsResponse{Transactions: s.transactions}), nil
+	context.Context, *orchpb.ListTransactionsRequest,
+) (*orchpb.ListTransactionsResponse, error) {
+	return &orchpb.ListTransactionsResponse{Transactions: s.transactions}, nil
 }
 
 func (s *statsOrchestrator) ListUnspent(
-	context.Context, *connect.Request[orchpb.ListUnspentRequest],
-) (*connect.Response[orchpb.ListUnspentResponse], error) {
-	return connect.NewResponse(&orchpb.ListUnspentResponse{Utxos: s.unspent}), nil
+	context.Context, *orchpb.ListUnspentRequest,
+) (*orchpb.ListUnspentResponse, error) {
+	return &orchpb.ListUnspentResponse{Utxos: s.unspent}, nil
 }
 
 func (s *statsOrchestrator) GetSidechainDepositTotals(
-	context.Context, *connect.Request[orchpb.GetSidechainDepositTotalsRequest],
-) (*connect.Response[orchpb.GetSidechainDepositTotalsResponse], error) {
-	return connect.NewResponse(&orchpb.GetSidechainDepositTotalsResponse{TotalSats: 7, RecentSats: 3}), nil
+	context.Context, *orchpb.GetSidechainDepositTotalsRequest,
+) (*orchpb.GetSidechainDepositTotalsResponse, error) {
+	return &orchpb.GetSidechainDepositTotalsResponse{TotalSats: 7, RecentSats: 3}, nil
 }
 
 func chainTipValidator(t *testing.T, height uint32) *mocks.MockValidatorServiceClient {
 	validator := mocks.NewMockValidatorServiceClient(gomock.NewController(t))
 	validator.EXPECT().
 		GetChainTip(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&mainchainv1.GetChainTipResponse{
+		Return(&mainchainv1.GetChainTipResponse{
 			BlockHeaderInfo: &mainchainv1.BlockHeaderInfo{Height: height},
-		}), nil)
+		}, nil)
 	return validator
 }
 
@@ -1335,16 +1331,16 @@ func TestGetUTXODistribution(t *testing.T) {
 			for i, v := range tt.values {
 				orchestrator.unspent = append(orchestrator.unspent, &orchpb.UnspentOutput{Txid: "tx", Vout: int32(i), Address: "bcrt1q", AmountSats: v})
 			}
-			cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
+			cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t), apitests.WithOrchestrator(orchestrator)))
 
-			resp, err := cli.GetUTXODistribution(t.Context(), connect.NewRequest(&walletv1.GetUTXODistributionRequest{
+			resp, err := cli.GetUTXODistribution(t.Context(), &walletv1.GetUTXODistributionRequest{
 				WalletId:   testWalletID,
 				MaxBuckets: tt.maxBuckets,
-			}))
+			})
 			require.NoError(t, err)
-			require.Len(t, resp.Msg.Buckets, len(tt.want))
+			require.Len(t, resp.Buckets, len(tt.want))
 			for i, want := range tt.want {
-				got := resp.Msg.Buckets[i]
+				got := resp.Buckets[i]
 				assert.Equal(t, want.Label, got.Label)
 				assert.Equal(t, want.ValueSats, got.ValueSats)
 				assert.Equal(t, want.Count, got.Count)
@@ -1356,7 +1352,7 @@ func TestGetUTXODistribution(t *testing.T) {
 func expectCoreTip(mock *mocks.MockBitcoinServiceClient, height uint32) {
 	mock.EXPECT().
 		GetBlockchainInfo(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&bitcoindv1alpha.GetBlockchainInfoResponse{Blocks: height}), nil)
+		Return(connectv1.NewResponse(&bitcoindv1alpha.GetBlockchainInfoResponse{Blocks: height}), nil)
 }
 
 func TestGetStats(t *testing.T) {
@@ -1380,19 +1376,19 @@ func TestGetStats(t *testing.T) {
 				{Txid: "pending", Vout: 1, Address: address, AmountSats: 100},
 			},
 		}
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t),
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t),
 			apitests.WithOrchestrator(orchestrator), apitests.WithValidator(chainTipValidator(t, 100))))
 
-		resp, err := cli.GetStats(t.Context(), connect.NewRequest(&walletv1.GetStatsRequest{WalletId: testWalletID}))
+		resp, err := cli.GetStats(t.Context(), &walletv1.GetStatsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		assert.Equal(t, uint32(98), resp.Msg.LastTxBlockHeight)
-		assert.Equal(t, blockTime, resp.Msg.LastTxAt.Seconds)
-		assert.Equal(t, uint64(2), resp.Msg.UtxosCurrent)
-		assert.Equal(t, uint64(1), resp.Msg.UtxosUniqueAddresses)
-		assert.Equal(t, int64(3), resp.Msg.TransactionCountTotal)
-		assert.Equal(t, int64(200), resp.Msg.TotalFeesSats)
-		assert.Equal(t, int64(7), resp.Msg.SidechainDepositVolume)
-		assert.Equal(t, int64(3), resp.Msg.SidechainDepositVolumeLast_30Days)
+		assert.Equal(t, uint32(98), resp.LastTxBlockHeight)
+		assert.Equal(t, blockTime, resp.LastTxAt.Seconds)
+		assert.Equal(t, uint64(2), resp.UtxosCurrent)
+		assert.Equal(t, uint64(1), resp.UtxosUniqueAddresses)
+		assert.Equal(t, int64(3), resp.TransactionCountTotal)
+		assert.Equal(t, int64(200), resp.TotalFeesSats)
+		assert.Equal(t, int64(7), resp.SidechainDepositVolume)
+		assert.Equal(t, int64(3), resp.SidechainDepositVolumeLast_30Days)
 	})
 
 	t.Run("a down enforcer gives stats with no block height", func(t *testing.T) {
@@ -1407,14 +1403,14 @@ func TestGetStats(t *testing.T) {
 		validator := mocks.NewMockValidatorServiceClient(gomock.NewController(t))
 		validator.EXPECT().
 			GetChainTip(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, errors.New("enforcer restarts")))
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t),
+			Return(nil, connect.NewError(connect.CodeUnavailable, "enforcer restarts"))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t),
 			apitests.WithOrchestrator(orchestrator), apitests.WithValidator(validator)))
 
-		resp, err := cli.GetStats(t.Context(), connect.NewRequest(&walletv1.GetStatsRequest{WalletId: testWalletID}))
+		resp, err := cli.GetStats(t.Context(), &walletv1.GetStatsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		assert.Equal(t, uint32(0), resp.Msg.LastTxBlockHeight)
-		assert.Equal(t, int64(1), resp.Msg.TransactionCountTotal)
+		assert.Equal(t, uint32(0), resp.LastTxBlockHeight)
+		assert.Equal(t, int64(1), resp.TransactionCountTotal)
 	})
 
 	t.Run("a core wallet reports the block of its newest transaction", func(t *testing.T) {
@@ -1424,14 +1420,14 @@ func TestGetStats(t *testing.T) {
 		mockBitcoind := mocks.NewMockBitcoinServiceClient(ctrl)
 		mockBitcoind.EXPECT().
 			ListTransactions(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
+			Return(connectv1.NewResponse(&bitcoindv1alpha.ListTransactionsResponse{
 				Transactions: []*bitcoindv1alpha.GetTransactionResponse{
 					{Txid: "new", Amount: 0.001, Confirmations: 2, Time: timestamppb.New(time.Unix(blockTime, 0))},
 				},
 			}), nil)
 		mockBitcoind.EXPECT().
 			ListUnspent(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&bitcoindv1alpha.ListUnspentResponse{
+			Return(connectv1.NewResponse(&bitcoindv1alpha.ListUnspentResponse{
 				Unspent: []*bitcoindv1alpha.UnspentOutput{{Txid: "new", Address: address, Amount: 0.001}},
 			}), nil)
 		expectCoreTip(mockBitcoind, 500)
@@ -1439,31 +1435,31 @@ func TestGetStats(t *testing.T) {
 		mockOrch := mocks.NewMockWalletManagerServiceClient(ctrl)
 		mockOrch.EXPECT().
 			GetSidechainDepositTotals(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.GetSidechainDepositTotalsResponse{}), nil)
+			Return(&orchpb.GetSidechainDepositTotalsResponse{}, nil)
 		mockOrch.EXPECT().
 			CreateBitcoinCoreWallet(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "core"}), nil).
+			Return(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "core"}, nil).
 			AnyTimes()
 		mockOrch.EXPECT().
 			DeriveAddresses(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.DeriveAddressesResponse{}), nil).
+			Return(&orchpb.DeriveAddressesResponse{}, nil).
 			AnyTimes()
 		mockOrch.EXPECT().
 			ListWallets(gomock.Any(), gomock.Any()).
-			Return(connect.NewResponse(&orchpb.ListWalletsResponse{
+			Return(&orchpb.ListWalletsResponse{
 				Wallets:        []*orchpb.WalletMetadata{{Id: testWalletID, WalletType: orchpb.WalletType_WALLET_TYPE_BITCOIN_CORE}},
 				ActiveWalletId: testWalletID,
-			}), nil).
+			}, nil).
 			AnyTimes()
 		apitests.ExpectOrchestratorReads(mockOrch)
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, database.Test(t),
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, database.Test(t),
 			apitests.WithBitcoind(mockBitcoind), apitests.WithOrchestrator(mockOrch)))
 
-		resp, err := cli.GetStats(t.Context(), connect.NewRequest(&walletv1.GetStatsRequest{WalletId: testWalletID}))
+		resp, err := cli.GetStats(t.Context(), &walletv1.GetStatsRequest{WalletId: testWalletID})
 		require.NoError(t, err)
-		assert.Equal(t, uint32(499), resp.Msg.LastTxBlockHeight)
-		assert.Equal(t, uint64(1), resp.Msg.UtxosCurrent)
-		assert.Equal(t, int64(1), resp.Msg.TransactionCountTotal)
+		assert.Equal(t, uint32(499), resp.LastTxBlockHeight)
+		assert.Equal(t, uint64(1), resp.UtxosCurrent)
+		assert.Equal(t, int64(1), resp.TransactionCountTotal)
 	})
 }
 
@@ -1483,14 +1479,14 @@ func TestListReceiveAddresses(t *testing.T) {
 				{Txid: "c", Address: "bcrt1qtwo", AmountSats: 7},
 			},
 		}
-		cli := walletv1connect.NewWalletServiceClient(apitests.API(t, db, apitests.WithOrchestrator(orchestrator)))
+		cli := walletv1connect.NewWalletServiceClient(apitests.RPC(t, db, apitests.WithOrchestrator(orchestrator)))
 
-		resp, err := cli.ListReceiveAddresses(t.Context(), connect.NewRequest(&walletv1.ListReceiveAddressesRequest{WalletId: testWalletID}))
+		resp, err := cli.ListReceiveAddresses(t.Context(), &walletv1.ListReceiveAddressesRequest{WalletId: testWalletID})
 		require.NoError(t, err)
 		assert.ElementsMatch(t, []*walletv1.ReceiveAddress{
 			{Address: "bcrt1qone", Label: "savings", CurrentBalanceSat: 1_500},
 			{Address: "bcrt1qtwo", CurrentBalanceSat: 7},
-		}, resp.Msg.Addresses)
+		}, resp.Addresses)
 	})
 }
 
diff --git a/bitwindow/server/api/walletpsbt/walletpsbt.go b/bitwindow/server/api/walletpsbt/walletpsbt.go
index a7c129e094..8810c8439f 100644
--- a/bitwindow/server/api/walletpsbt/walletpsbt.go
+++ b/bitwindow/server/api/walletpsbt/walletpsbt.go
@@ -3,9 +3,8 @@ package walletpsbt
 import (
 	"context"
 	"database/sql"
-	"errors"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 	"google.golang.org/protobuf/types/known/emptypb"
 
@@ -26,37 +25,37 @@ func New(db *sql.DB) *Server {
 
 func (s *Server) ListDrafts(
 	ctx context.Context,
-	req *connect.Request[pb.ListDraftsRequest],
-) (*connect.Response[pb.ListDraftsResponse], error) {
-	if req.Msg.WalletId == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("wallet id is required"))
+	req *pb.ListDraftsRequest,
+) (*pb.ListDraftsResponse, error) {
+	if req.WalletId == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "wallet id is required")
 	}
 
-	drafts, err := s.store.List(ctx, req.Msg.WalletId)
+	drafts, err := s.store.List(ctx, req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.ListDraftsResponse{
+	return &pb.ListDraftsResponse{
 		Drafts: lo.Map(drafts, func(d walletpsbt.Draft, _ int) *pb.PsbtDraft {
 			return draftToProto(d)
 		}),
-	}), nil
+	}, nil
 }
 
 func (s *Server) SaveDraft(
 	ctx context.Context,
-	req *connect.Request[pb.SaveDraftRequest],
-) (*connect.Response[pb.SaveDraftResponse], error) {
-	pd := req.Msg.Draft
+	req *pb.SaveDraftRequest,
+) (*pb.SaveDraftResponse, error) {
+	pd := req.Draft
 	if pd == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("draft is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "draft is required")
 	}
 	if pd.WalletId == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("wallet id is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "wallet id is required")
 	}
 	if pd.PsbtBase64 == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("psbt is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "psbt is required")
 	}
 
 	saved, err := s.store.Save(ctx, walletpsbt.Draft{
@@ -67,23 +66,23 @@ func (s *Server) SaveDraft(
 		Txid:       pd.Txid,
 	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.SaveDraftResponse{Draft: draftToProto(saved)}), nil
+	return &pb.SaveDraftResponse{Draft: draftToProto(saved)}, nil
 }
 
 func (s *Server) DeleteDraft(
 	ctx context.Context,
-	req *connect.Request[pb.DeleteDraftRequest],
-) (*connect.Response[emptypb.Empty], error) {
-	if req.Msg.Id == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("draft id is required"))
+	req *pb.DeleteDraftRequest,
+) (*emptypb.Empty, error) {
+	if req.Id == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "draft id is required")
 	}
-	if err := s.store.Delete(ctx, req.Msg.Id); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+	if err := s.store.Delete(ctx, req.Id); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
 func draftToProto(d walletpsbt.Draft) *pb.PsbtDraft {
diff --git a/bitwindow/server/api/walletpsbt/walletpsbt_test.go b/bitwindow/server/api/walletpsbt/walletpsbt_test.go
index 3a5f64f3a5..177ee331f9 100644
--- a/bitwindow/server/api/walletpsbt/walletpsbt_test.go
+++ b/bitwindow/server/api/walletpsbt/walletpsbt_test.go
@@ -3,7 +3,7 @@ package walletpsbt_test
 import (
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -19,25 +19,25 @@ func TestDrafts(t *testing.T) {
 	t.Run("save, list and delete a draft", func(t *testing.T) {
 		t.Parallel()
 
-		cli := rpc.NewWalletPsbtServiceClient(apitests.API(t, database.Test(t)))
+		cli := rpc.NewWalletPsbtServiceClient(apitests.RPC(t, database.Test(t)))
 		ctx := t.Context()
 		list := func(walletID string) []*pb.PsbtDraft {
-			resp, err := cli.ListDrafts(ctx, connect.NewRequest(&pb.ListDraftsRequest{WalletId: walletID}))
+			resp, err := cli.ListDrafts(ctx, &pb.ListDraftsRequest{WalletId: walletID})
 			require.NoError(t, err)
-			return resp.Msg.Drafts
+			return resp.Drafts
 		}
 
-		saved, err := cli.SaveDraft(ctx, connect.NewRequest(&pb.SaveDraftRequest{Draft: &pb.PsbtDraft{
+		saved, err := cli.SaveDraft(ctx, &pb.SaveDraftRequest{Draft: &pb.PsbtDraft{
 			WalletId: "w1", Label: "rent", PsbtBase64: "cHNidP8=",
-		}}))
+		}})
 		require.NoError(t, err)
-		require.NotEmpty(t, saved.Msg.Draft.Id)
+		require.NotEmpty(t, saved.Draft.Id)
 
-		updated, err := cli.SaveDraft(ctx, connect.NewRequest(&pb.SaveDraftRequest{Draft: &pb.PsbtDraft{
-			Id: saved.Msg.Draft.Id, WalletId: "w1", Label: "rent", PsbtBase64: "cHNidP8B", Txid: "aa",
-		}}))
+		updated, err := cli.SaveDraft(ctx, &pb.SaveDraftRequest{Draft: &pb.PsbtDraft{
+			Id: saved.Draft.Id, WalletId: "w1", Label: "rent", PsbtBase64: "cHNidP8B", Txid: "aa",
+		}})
 		require.NoError(t, err)
-		assert.Equal(t, saved.Msg.Draft.CreatedAt, updated.Msg.Draft.CreatedAt)
+		assert.Equal(t, saved.Draft.CreatedAt, updated.Draft.CreatedAt)
 
 		drafts := list("w1")
 		require.Len(t, drafts, 1)
@@ -45,7 +45,7 @@ func TestDrafts(t *testing.T) {
 		assert.Equal(t, "aa", drafts[0].Txid)
 		assert.Empty(t, list("w2"))
 
-		_, err = cli.DeleteDraft(ctx, connect.NewRequest(&pb.DeleteDraftRequest{Id: saved.Msg.Draft.Id}))
+		_, err = cli.DeleteDraft(ctx, &pb.DeleteDraftRequest{Id: saved.Draft.Id})
 		require.NoError(t, err)
 		assert.Empty(t, list("w1"))
 	})
@@ -53,18 +53,18 @@ func TestDrafts(t *testing.T) {
 	t.Run("refuses a request with a missing field", func(t *testing.T) {
 		t.Parallel()
 
-		cli := rpc.NewWalletPsbtServiceClient(apitests.API(t, database.Test(t)))
+		cli := rpc.NewWalletPsbtServiceClient(apitests.RPC(t, database.Test(t)))
 		ctx := t.Context()
 
-		_, err := cli.ListDrafts(ctx, connect.NewRequest(&pb.ListDraftsRequest{}))
+		_, err := cli.ListDrafts(ctx, &pb.ListDraftsRequest{})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 
 		for _, draft := range []*pb.PsbtDraft{nil, {PsbtBase64: "cHNidP8="}, {WalletId: "w1"}} {
-			_, err = cli.SaveDraft(ctx, connect.NewRequest(&pb.SaveDraftRequest{Draft: draft}))
+			_, err = cli.SaveDraft(ctx, &pb.SaveDraftRequest{Draft: draft})
 			assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		}
 
-		_, err = cli.DeleteDraft(ctx, connect.NewRequest(&pb.DeleteDraftRequest{}))
+		_, err = cli.DeleteDraft(ctx, &pb.DeleteDraftRequest{})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 }
diff --git a/bitwindow/server/buf.go.gen.yaml b/bitwindow/server/buf.go.gen.yaml
index b56e222286..c46a88d413 100644
--- a/bitwindow/server/buf.go.gen.yaml
+++ b/bitwindow/server/buf.go.gen.yaml
@@ -22,7 +22,7 @@ plugins:
 
   # Generates client and server stubs for connectrpc.com/connect.
   # Compatible with the gRPC, gRPC-Web, and Connect RPC protocols.
-  - remote: buf.build/connectrpc/go:v1.21.0
+  - remote: buf.build/connectrpc/go:v2.0.1
     out: gen
     opt:
       - paths=source_relative
diff --git a/bitwindow/server/dial/dial.go b/bitwindow/server/dial/dial.go
index bc35169947..12a24c0ede 100644
--- a/bitwindow/server/dial/dial.go
+++ b/bitwindow/server/dial/dial.go
@@ -10,6 +10,8 @@ import (
 	"time"
 
 	"connectrpc.com/connect"
+	connectv2 "connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/rs/zerolog"
 	"google.golang.org/protobuf/types/known/wrapperspb"
@@ -50,10 +52,10 @@ func Bitcoind(ctx context.Context, orchestratorAddr, cookieDir string) (corerpc.
 // with the local-auth cookie in cookieDir.
 func Orchestrator(addr, cookieDir string) orchrpc.OrchestratorServiceClient {
 	return orchrpc.NewOrchestratorServiceClient(
-		http.DefaultClient,
-		addr,
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir)),
+		connectv2.NewClient(
+			connecthttp.NewTransport(http.DefaultClient, addr, connecthttp.WithGRPC(), connecthttp.WithReadMaxBytes(0)),
+			localauth.ClientInterceptor(cookieDir),
+		),
 	)
 }
 
@@ -61,10 +63,10 @@ func Orchestrator(addr, cookieDir string) orchrpc.OrchestratorServiceClient {
 // with the local-auth cookie in cookieDir.
 func BitcoinConf(addr, cookieDir string) orchrpc.BitcoinConfServiceClient {
 	return orchrpc.NewBitcoinConfServiceClient(
-		http.DefaultClient,
-		addr,
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir)),
+		connectv2.NewClient(
+			connecthttp.NewTransport(http.DefaultClient, addr, connecthttp.WithGRPC(), connecthttp.WithReadMaxBytes(0)),
+			localauth.ClientInterceptor(cookieDir),
+		),
 	)
 }
 
@@ -72,9 +74,10 @@ func BitcoinConf(addr, cookieDir string) orchrpc.BitcoinConfServiceClient {
 // with the local-auth cookie in cookieDir.
 func WalletManager(addr, cookieDir string) walletmanagerrpc.WalletManagerServiceClient {
 	return walletmanagerrpc.NewWalletManagerServiceClient(
-		http.DefaultClient,
-		addr,
-		connect.WithInterceptors(localauth.Interceptor(cookieDir)),
+		connectv2.NewClient(
+			connecthttp.NewTransport(http.DefaultClient, addr, connecthttp.WithReadMaxBytes(0)),
+			localauth.ClientInterceptor(cookieDir),
+		),
 	)
 }
 
@@ -98,12 +101,12 @@ func EnforcerValidator(ctx context.Context, url, cookieDir string) (
 	}
 
 	client := rpc.NewValidatorServiceClient(
-		getSharedClient(ctx),
-		ensureHTTPScheme(url),
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir)),
+		connectv2.NewClient(
+			connecthttp.NewTransport(getSharedClient(ctx), ensureHTTPScheme(url), connecthttp.WithGRPC(), connecthttp.WithReadMaxBytes(0)),
+			localauth.ClientInterceptor(cookieDir),
+		),
 	)
-	_, err := client.GetSidechains(ctx, connect.NewRequest(&pb.GetSidechainsRequest{}))
+	_, err := client.GetSidechains(ctx, &pb.GetSidechainsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("get sidechains: %w", err)
 	}
@@ -122,12 +125,12 @@ func EnforcerBlockProducer(ctx context.Context, url string) (
 	}
 
 	client := rpc.NewBlockProducerServiceClient(
-		getSharedClient(ctx),
-		ensureHTTPScheme(url),
-		connect.WithGRPC(),
+		connectv2.NewClient(
+			connecthttp.NewTransport(getSharedClient(ctx), ensureHTTPScheme(url), connecthttp.WithGRPC(), connecthttp.WithReadMaxBytes(0)),
+		),
 	)
 
-	_, err := client.GetBlockProducerState(ctx, connect.NewRequest(&pb.GetBlockProducerStateRequest{}))
+	_, err := client.GetBlockProducerState(ctx, &pb.GetBlockProducerStateRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("get block producer state: %w", err)
 	}
@@ -145,9 +148,9 @@ func EnforcerMining(ctx context.Context, url string) (
 	}
 
 	return rpc.NewMiningServiceClient(
-		getSharedClient(ctx),
-		ensureHTTPScheme(url),
-		connect.WithGRPC(),
+		connectv2.NewClient(
+			connecthttp.NewTransport(getSharedClient(ctx), ensureHTTPScheme(url), connecthttp.WithGRPC(), connecthttp.WithReadMaxBytes(0)),
+		),
 	), nil
 }
 
@@ -160,18 +163,18 @@ func EnforcerCrypto(ctx context.Context, url string) (
 	}
 
 	client := cryptorpc.NewCryptoServiceClient(
-		getSharedClient(ctx),
-		ensureHTTPScheme(url),
-		connect.WithGRPC(),
+		connectv2.NewClient(
+			connecthttp.NewTransport(getSharedClient(ctx), ensureHTTPScheme(url), connecthttp.WithGRPC(), connecthttp.WithReadMaxBytes(0)),
+		),
 	)
 
-	if _, err := client.Ripemd160(ctx, connect.NewRequest(&cryptov1.Ripemd160Request{
+	if _, err := client.Ripemd160(ctx, &cryptov1.Ripemd160Request{
 		Msg: &commonv1.Hex{
 			Hex: &wrapperspb.StringValue{
 				Value: "deadbeef", // make sure this is valid hex
 			},
 		},
-	})); err != nil {
+	}); err != nil {
 		return nil, fmt.Errorf("ripemd160: %w", err)
 	}
 
diff --git a/bitwindow/server/dial/dial_test.go b/bitwindow/server/dial/dial_test.go
index 3cbe2e574a..5987f85fc0 100644
--- a/bitwindow/server/dial/dial_test.go
+++ b/bitwindow/server/dial/dial_test.go
@@ -10,7 +10,8 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -120,8 +121,8 @@ type restartL1Handler struct {
 	orchrpc.UnimplementedOrchestratorServiceHandler
 }
 
-func (restartL1Handler) RestartL1(context.Context, *connect.Request[orchpb.RestartL1Request]) (*connect.Response[orchpb.RestartL1Response], error) {
-	return connect.NewResponse(&orchpb.RestartL1Response{}), nil
+func (restartL1Handler) RestartL1(context.Context, *orchpb.RestartL1Request) (*orchpb.RestartL1Response, error) {
+	return &orchpb.RestartL1Response{}, nil
 }
 
 func TestOrchestrator(t *testing.T) {
@@ -130,17 +131,19 @@ func TestOrchestrator(t *testing.T) {
 	require.NoError(t, err)
 
 	mux := http.NewServeMux()
-	mux.Handle(orchrpc.NewOrchestratorServiceHandler(restartL1Handler{}, connect.WithInterceptors(localauth.Interceptor(dir))))
+	srv := connect.NewServer(localauth.ServerInterceptor(dir))
+	orchrpc.RegisterOrchestratorServiceHandler(srv, restartL1Handler{})
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
 
 	t.Run("the cookie authenticates the call", func(t *testing.T) {
-		_, err := Orchestrator(server.URL, dir).RestartL1(t.Context(), connect.NewRequest(&orchpb.RestartL1Request{}))
+		_, err := Orchestrator(server.URL, dir).RestartL1(t.Context(), &orchpb.RestartL1Request{})
 		require.NoError(t, err)
 	})
 
 	t.Run("no cookie fails the call", func(t *testing.T) {
-		_, err := Orchestrator(server.URL, t.TempDir()).RestartL1(t.Context(), connect.NewRequest(&orchpb.RestartL1Request{}))
+		_, err := Orchestrator(server.URL, t.TempDir()).RestartL1(t.Context(), &orchpb.RestartL1Request{})
 		require.ErrorContains(t, err, "unauthenticated")
 	})
 }
@@ -149,8 +152,8 @@ type bitcoinConfHandler struct {
 	orchrpc.UnimplementedBitcoinConfServiceHandler
 }
 
-func (bitcoinConfHandler) GetBitcoinConfig(context.Context, *connect.Request[orchpb.GetBitcoinConfigRequest]) (*connect.Response[orchpb.GetBitcoinConfigResponse], error) {
-	return connect.NewResponse(&orchpb.GetBitcoinConfigResponse{Network: "signet"}), nil
+func (bitcoinConfHandler) GetBitcoinConfig(context.Context, *orchpb.GetBitcoinConfigRequest) (*orchpb.GetBitcoinConfigResponse, error) {
+	return &orchpb.GetBitcoinConfigResponse{Network: "signet"}, nil
 }
 
 func TestBitcoinConf(t *testing.T) {
@@ -159,18 +162,20 @@ func TestBitcoinConf(t *testing.T) {
 	require.NoError(t, err)
 
 	mux := http.NewServeMux()
-	mux.Handle(orchrpc.NewBitcoinConfServiceHandler(bitcoinConfHandler{}, connect.WithInterceptors(localauth.Interceptor(dir))))
+	srv := connect.NewServer(localauth.ServerInterceptor(dir))
+	orchrpc.RegisterBitcoinConfServiceHandler(srv, bitcoinConfHandler{})
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
 
 	t.Run("the cookie authenticates the call", func(t *testing.T) {
-		resp, err := BitcoinConf(server.URL, dir).GetBitcoinConfig(t.Context(), connect.NewRequest(&orchpb.GetBitcoinConfigRequest{}))
+		resp, err := BitcoinConf(server.URL, dir).GetBitcoinConfig(t.Context(), &orchpb.GetBitcoinConfigRequest{})
 		require.NoError(t, err)
-		assert.Equal(t, "signet", resp.Msg.GetNetwork())
+		assert.Equal(t, "signet", resp.GetNetwork())
 	})
 
 	t.Run("no cookie fails the call", func(t *testing.T) {
-		_, err := BitcoinConf(server.URL, t.TempDir()).GetBitcoinConfig(t.Context(), connect.NewRequest(&orchpb.GetBitcoinConfigRequest{}))
+		_, err := BitcoinConf(server.URL, t.TempDir()).GetBitcoinConfig(t.Context(), &orchpb.GetBitcoinConfigRequest{})
 		require.ErrorContains(t, err, "unauthenticated")
 	})
 }
@@ -179,8 +184,8 @@ type walletManagerHandler struct {
 	walletmanagerrpc.UnimplementedWalletManagerServiceHandler
 }
 
-func (walletManagerHandler) GetNodeMode(context.Context, *connect.Request[walletmanagerpb.GetNodeModeRequest]) (*connect.Response[walletmanagerpb.GetNodeModeResponse], error) {
-	return connect.NewResponse(&walletmanagerpb.GetNodeModeResponse{Mode: walletmanagerpb.NodeMode_NODE_MODE_FULL}), nil
+func (walletManagerHandler) GetNodeMode(context.Context, *walletmanagerpb.GetNodeModeRequest) (*walletmanagerpb.GetNodeModeResponse, error) {
+	return &walletmanagerpb.GetNodeModeResponse{Mode: walletmanagerpb.NodeMode_NODE_MODE_FULL}, nil
 }
 
 func TestWalletManager(t *testing.T) {
@@ -189,18 +194,20 @@ func TestWalletManager(t *testing.T) {
 	require.NoError(t, err)
 
 	mux := http.NewServeMux()
-	mux.Handle(walletmanagerrpc.NewWalletManagerServiceHandler(walletManagerHandler{}, connect.WithInterceptors(localauth.Interceptor(dir))))
+	srv := connect.NewServer(localauth.ServerInterceptor(dir))
+	walletmanagerrpc.RegisterWalletManagerServiceHandler(srv, walletManagerHandler{})
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
 
 	t.Run("the cookie authenticates the call", func(t *testing.T) {
-		resp, err := WalletManager(server.URL, dir).GetNodeMode(t.Context(), connect.NewRequest(&walletmanagerpb.GetNodeModeRequest{}))
+		resp, err := WalletManager(server.URL, dir).GetNodeMode(t.Context(), &walletmanagerpb.GetNodeModeRequest{})
 		require.NoError(t, err)
-		assert.Equal(t, walletmanagerpb.NodeMode_NODE_MODE_FULL, resp.Msg.GetMode())
+		assert.Equal(t, walletmanagerpb.NodeMode_NODE_MODE_FULL, resp.GetMode())
 	})
 
 	t.Run("no cookie fails the call", func(t *testing.T) {
-		_, err := WalletManager(server.URL, t.TempDir()).GetNodeMode(t.Context(), connect.NewRequest(&walletmanagerpb.GetNodeModeRequest{}))
+		_, err := WalletManager(server.URL, t.TempDir()).GetNodeMode(t.Context(), &walletmanagerpb.GetNodeModeRequest{})
 		require.ErrorContains(t, err, "unauthenticated")
 	})
 }
diff --git a/bitwindow/server/dial/enforcer_test.go b/bitwindow/server/dial/enforcer_test.go
index 94712d133b..f8aaced431 100644
--- a/bitwindow/server/dial/enforcer_test.go
+++ b/bitwindow/server/dial/enforcer_test.go
@@ -7,7 +7,8 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/stretchr/testify/require"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
@@ -19,8 +20,8 @@ type validatorHandler struct {
 	rpc.UnimplementedValidatorServiceHandler
 }
 
-func (validatorHandler) GetSidechains(context.Context, *connect.Request[pb.GetSidechainsRequest]) (*connect.Response[pb.GetSidechainsResponse], error) {
-	return connect.NewResponse(&pb.GetSidechainsResponse{}), nil
+func (validatorHandler) GetSidechains(context.Context, *pb.GetSidechainsRequest) (*pb.GetSidechainsResponse, error) {
+	return &pb.GetSidechainsResponse{}, nil
 }
 
 func TestValidatorUsesTheOrchestratorCookie(t *testing.T) {
@@ -29,8 +30,9 @@ func TestValidatorUsesTheOrchestratorCookie(t *testing.T) {
 	require.NoError(t, err)
 
 	mux := http.NewServeMux()
-	path, handler := rpc.NewValidatorServiceHandler(validatorHandler{}, connect.WithInterceptors(localauth.Interceptor(dir)))
-	mux.Handle(path, handler)
+	srv := connect.NewServer(localauth.ServerInterceptor(dir))
+	rpc.RegisterValidatorServiceHandler(srv, validatorHandler{})
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewUnstartedServer(mux)
 	server.Config.Protocols = new(http.Protocols)
 	server.Config.Protocols.SetHTTP1(true)
@@ -41,7 +43,7 @@ func TestValidatorUsesTheOrchestratorCookie(t *testing.T) {
 	for _, address := range []string{server.URL, strings.TrimPrefix(server.URL, "http://")} {
 		client, err := EnforcerValidator(t.Context(), address, dir)
 		require.NoError(t, err)
-		_, err = client.GetSidechains(t.Context(), connect.NewRequest(&pb.GetSidechainsRequest{}))
+		_, err = client.GetSidechains(t.Context(), &pb.GetSidechainsRequest{})
 		require.NoError(t, err)
 	}
 
diff --git a/bitwindow/server/engines/bitcoind_engine.go b/bitwindow/server/engines/bitcoind_engine.go
index 3b9c437e26..9825d95cbd 100644
--- a/bitwindow/server/engines/bitcoind_engine.go
+++ b/bitwindow/server/engines/bitcoind_engine.go
@@ -575,19 +575,19 @@ func (p *Parser) applyPendingM4(ctx context.Context) error {
 		log.Debug().Err(err).Msg("M4 waits for the enforcer")
 		return nil
 	}
-	tip, err := client.GetChainTip(ctx, connect.NewRequest(&validatorpb.GetChainTipRequest{}))
+	tip, err := client.GetChainTip(ctx, &validatorpb.GetChainTipRequest{})
 	if err != nil {
 		log.Debug().Err(err).Msg("M4 waits for the enforcer tip")
 		return nil
 	}
-	sidechains, err := client.GetSidechains(ctx, connect.NewRequest(&validatorpb.GetSidechainsRequest{}))
+	sidechains, err := client.GetSidechains(ctx, &validatorpb.GetSidechainsRequest{})
 	if err != nil {
 		log.Debug().Err(err).Msg("M4 waits for the enforcer sidechains")
 		return nil
 	}
 
-	height := min(processed.Height, tip.Msg.GetBlockHeaderInfo().GetHeight())
-	return p.m4Engine.ApplyPendingM4(ctx, height, sidechains.Msg.GetSidechains())
+	height := min(processed.Height, tip.GetBlockHeaderInfo().GetHeight())
+	return p.m4Engine.ApplyPendingM4(ctx, height, sidechains.GetSidechains())
 }
 
 // HandleNewRawTransaction can be called on a brand new transaction
diff --git a/bitwindow/server/engines/bitdrive_engine.go b/bitwindow/server/engines/bitdrive_engine.go
index 575b202706..1f65f410f5 100644
--- a/bitwindow/server/engines/bitdrive_engine.go
+++ b/bitwindow/server/engines/bitdrive_engine.go
@@ -19,7 +19,7 @@ import (
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/rs/zerolog"
@@ -401,7 +401,7 @@ func (e *BitDriveEngine) encodeContent(
 // returns the txid and the file type.
 func (e *BitDriveEngine) StoreFile(ctx context.Context, content []byte, encrypt bool, feeSatPerVbyte uint64) (string, string, error) {
 	if err := ValidateFileSize(content); err != nil {
-		return "", "", connect.NewError(connect.CodeInvalidArgument, err)
+		return "", "", connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	metadataB64, contentStr, timestamp, err := e.EncodeOPReturnData(ctx, content, encrypt)
diff --git a/bitwindow/server/engines/bitdrive_engine_test.go b/bitwindow/server/engines/bitdrive_engine_test.go
index 95635732f7..99258a42b7 100644
--- a/bitwindow/server/engines/bitdrive_engine_test.go
+++ b/bitwindow/server/engines/bitdrive_engine_test.go
@@ -13,7 +13,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stretchr/testify/assert"
@@ -93,15 +93,15 @@ func newEncryptTestEngine(t *testing.T) *BitDriveEngine {
 	orch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 	orch.EXPECT().
 		ListWallets(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&orchpb.ListWalletsResponse{
+		Return(&orchpb.ListWalletsResponse{
 			Wallets: []*orchpb.WalletMetadata{{Id: "test-enforcer", IsStarter: true}},
-		}), nil).
+		}, nil).
 		AnyTimes()
 	orch.EXPECT().
 		GetWalletSeed(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&orchpb.GetWalletSeedResponse{
+		Return(&orchpb.GetWalletSeedResponse{
 			SeedHex: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
-		}), nil).
+		}, nil).
 		AnyTimes()
 
 	return &BitDriveEngine{
@@ -114,15 +114,15 @@ func TestEncrypt_ReadsTheSeedOneTime(t *testing.T) {
 	orch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 	orch.EXPECT().
 		ListWallets(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&orchpb.ListWalletsResponse{
+		Return(&orchpb.ListWalletsResponse{
 			Wallets: []*orchpb.WalletMetadata{{Id: "test-enforcer", IsStarter: true}},
-		}), nil).
+		}, nil).
 		Times(1)
 	orch.EXPECT().
 		GetWalletSeed(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&orchpb.GetWalletSeedResponse{
+		Return(&orchpb.GetWalletSeedResponse{
 			SeedHex: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
-		}), nil).
+		}, nil).
 		Times(1)
 	engine := &BitDriveEngine{
 		walletEngine: NewWalletEngine(nil, orch, &chaincfg.SigNetParams, nil),
@@ -456,19 +456,19 @@ func newStoreTestEngine(t *testing.T) (*BitDriveEngine, *[]string) {
 	orch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 	orch.EXPECT().
 		SendTransaction(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(_ context.Context, req *connect.Request[orchpb.SendTransactionRequest]) (*connect.Response[orchpb.SendTransactionResponse], error) {
-			assert.Equal(t, "a", req.Msg.WalletId)
-			assert.Equal(t, int64(7), req.Msg.FeeRateSatPerVbyte)
-			data, err := hex.DecodeString(req.Msg.OpReturnHex)
+		DoAndReturn(func(_ context.Context, req *orchpb.SendTransactionRequest) (*orchpb.SendTransactionResponse, error) {
+			assert.Equal(t, "a", req.WalletId)
+			assert.Equal(t, int64(7), req.FeeRateSatPerVbyte)
+			data, err := hex.DecodeString(req.OpReturnHex)
 			require.NoError(t, err)
 			sent = append(sent, string(data))
-			return connect.NewResponse(&orchpb.SendTransactionResponse{Txid: "txid"}), nil
+			return &orchpb.SendTransactionResponse{Txid: "txid"}, nil
 		}).
 		AnyTimes()
 	orch.EXPECT().
 		SetFrozenCoins(gomock.Any(), gomock.Any()).
 		AnyTimes().
-		Return(connect.NewResponse(&emptypb.Empty{}), nil)
+		Return(&emptypb.Empty{}, nil)
 
 	noFrozenCoins := func(context.Context) ([]string, error) { return nil, nil }
 	return &BitDriveEngine{
diff --git a/bitwindow/server/engines/cheque_engine.go b/bitwindow/server/engines/cheque_engine.go
index 2edc96e2e8..2a7066a8ab 100644
--- a/bitwindow/server/engines/cheque_engine.go
+++ b/bitwindow/server/engines/cheque_engine.go
@@ -11,7 +11,7 @@ import (
 	"slices"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -230,7 +230,7 @@ func (e *ChequeEngine) CheckFunding(ctx context.Context, cheque *cheques.Cheque)
 
 	utxos, err := e.chain.AddressUnspent(ctx, cheque.Address)
 	if err != nil {
-		return ChequeFunding{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("query UTXOs of %s: %w", cheque.Address, err))
+		return ChequeFunding{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("query UTXOs of %s: %w", cheque.Address, err).Error()).WithCause(err)
 	}
 
 	log.Debug().
@@ -247,7 +247,7 @@ func (e *ChequeEngine) CheckFunding(ctx context.Context, cheque *cheques.Cheque)
 
 			// Only a full chain scan finds the spending tx of a watched address.
 			if err := cheques.UpdateSwept(ctx, e.db, cheque.WalletID, cheque.ID, "swept_externally"); err != nil {
-				return ChequeFunding{}, connect.NewError(connect.CodeInternal, fmt.Errorf("mark cheque swept: %w", err))
+				return ChequeFunding{}, connect.NewError(connect.CodeInternal, fmt.Errorf("mark cheque swept: %w", err).Error()).WithCause(err)
 			}
 		}
 		return ChequeFunding{}, nil
@@ -267,7 +267,7 @@ func (e *ChequeEngine) CheckFunding(ctx context.Context, cheque *cheques.Cheque)
 	}
 
 	if err := cheques.UpdateFunding(ctx, e.db, cheque.WalletID, cheque.ID, outputs, funding.AmountSats); err != nil {
-		return ChequeFunding{}, connect.NewError(connect.CodeInternal, fmt.Errorf("update funding: %w", err))
+		return ChequeFunding{}, connect.NewError(connect.CodeInternal, fmt.Errorf("update funding: %w", err).Error()).WithCause(err)
 	}
 
 	log.Info().
@@ -279,7 +279,7 @@ func (e *ChequeEngine) CheckFunding(ctx context.Context, cheque *cheques.Cheque)
 
 	updated, err := cheques.Get(ctx, e.db, cheque.WalletID, cheque.ID)
 	if err != nil {
-		return ChequeFunding{}, connect.NewError(connect.CodeInternal, fmt.Errorf("refetch cheque: %w", err))
+		return ChequeFunding{}, connect.NewError(connect.CodeInternal, fmt.Errorf("refetch cheque: %w", err).Error()).WithCause(err)
 	}
 	funding.Funded = updated.IsFunded()
 	funding.FundedAt = updated.FundedAt
@@ -302,10 +302,10 @@ func (e *ChequeEngine) Sweep(
 
 	source, err := ResolveSweepSource(ctx, e.chain, wifKey, e.chainParams)
 	if err != nil {
-		return ChequeSweep{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("query UTXOs: %w", err))
+		return ChequeSweep{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("query UTXOs: %w", err).Error()).WithCause(err)
 	}
 	if len(source.UTXOs) == 0 {
-		return ChequeSweep{}, connect.NewError(connect.CodeNotFound, errors.New("no funds found at this address"))
+		return ChequeSweep{}, connect.NewError(connect.CodeNotFound, "no funds found at this address")
 	}
 
 	totalAmount := source.TotalSats()
@@ -317,7 +317,7 @@ func (e *ChequeEngine) Sweep(
 	case errors.Is(err, sql.ErrNoRows):
 		log.Debug().Str("address", source.Address).Msg("swept key is not a cheque of this wallet")
 	case err != nil:
-		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("find cheque at %s: %w", source.Address, err))
+		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("find cheque at %s: %w", source.Address, err).Error()).WithCause(err)
 	}
 
 	feeSatPerVbyte, err = e.SweepFeeRate(ctx, feeSatPerVbyte)
@@ -328,19 +328,19 @@ func (e *ChequeEngine) Sweep(
 	unsignedTx, err := BuildSweepTx(source, destination, feeSatPerVbyte, e.chainParams)
 	switch {
 	case errors.Is(err, ErrInvalidSweep):
-		return ChequeSweep{}, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("build transaction: %w", err))
+		return ChequeSweep{}, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("build transaction: %w", err).Error()).WithCause(err)
 	case err != nil:
-		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("build transaction: %w", err))
+		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("build transaction: %w", err).Error()).WithCause(err)
 	}
 
 	signedTx, err := SignSweepTx(unsignedTx, source, wifKey, e.chainParams)
 	if err != nil {
-		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("sign transaction: %w", err))
+		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("sign transaction: %w", err).Error()).WithCause(err)
 	}
 
 	var txBytes bytes.Buffer
 	if err := signedTx.Serialize(&txBytes); err != nil {
-		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("serialize transaction: %w", err))
+		return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("serialize transaction: %w", err).Error()).WithCause(err)
 	}
 
 	txid, err := e.chain.Broadcast(ctx, hex.EncodeToString(txBytes.Bytes()))
@@ -350,7 +350,7 @@ func (e *ChequeEngine) Sweep(
 
 	if cheque != nil && cheque.SweptTxid == nil {
 		if err := cheques.UpdateSwept(ctx, e.db, walletID, cheque.ID, txid); err != nil {
-			return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("mark cheque %d swept by %s: %w", cheque.ID, txid, err))
+			return ChequeSweep{}, connect.NewError(connect.CodeInternal, fmt.Errorf("mark cheque %d swept by %s: %w", cheque.ID, txid, err).Error()).WithCause(err)
 		}
 	}
 
@@ -372,7 +372,7 @@ func (e *ChequeEngine) SweepFeeRate(ctx context.Context, requested uint64) (uint
 	}
 	rate, err := e.chain.FeeRateSatPerVByte(ctx, 6)
 	if err != nil {
-		return 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("estimate fee: %w", err))
+		return 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("estimate fee: %w", err).Error()).WithCause(err)
 	}
 	return uint64(math.Ceil(rate)), nil
 }
diff --git a/bitwindow/server/engines/cheque_engine_test.go b/bitwindow/server/engines/cheque_engine_test.go
index 848cb1f30c..31fb3848fd 100644
--- a/bitwindow/server/engines/cheque_engine_test.go
+++ b/bitwindow/server/engines/cheque_engine_test.go
@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -37,7 +37,7 @@ func testChequeEngine(t *testing.T, chain ChequeChain) *ChequeEngine {
 	orch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 	orch.EXPECT().
 		GetWalletSeed(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&orchpb.GetWalletSeedResponse{SeedHex: chequeSeedHex}), nil).
+		Return(&orchpb.GetWalletSeedResponse{SeedHex: chequeSeedHex}, nil).
 		AnyTimes()
 	return testChequeEngineWith(t, chain, orch)
 }
@@ -209,7 +209,7 @@ func TestRecoverChequesOnUnlockSkipsASeedlessWallet(t *testing.T) {
 	orch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 	orch.EXPECT().
 		GetWalletSeed(gomock.Any(), gomock.Any()).
-		Return(nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet holds no master seed"))).
+		Return(nil, connect.NewError(connect.CodeFailedPrecondition, "wallet holds no master seed")).
 		AnyTimes()
 	engine := testChequeEngineWith(t, chain, orch)
 	engine.scanRetry = time.Millisecond
@@ -411,7 +411,7 @@ func TestChequeEngineSweep(t *testing.T) {
 		require.NoError(t, err)
 		chain := &fakeChain{
 			funded:       map[string][]ChequeUTXO{candidates[0].Address: testUTXOs()},
-			broadcastErr: connect.NewError(connect.CodeFailedPrecondition, errors.New("txn-mempool-conflict")),
+			broadcastErr: connect.NewError(connect.CodeFailedPrecondition, "txn-mempool-conflict"),
 		}
 		engine := testChequeEngine(t, chain)
 
diff --git a/bitwindow/server/engines/coinnews_remote.go b/bitwindow/server/engines/coinnews_remote.go
index ce9ad2cb63..9621f0c7d6 100644
--- a/bitwindow/server/engines/coinnews_remote.go
+++ b/bitwindow/server/engines/coinnews_remote.go
@@ -7,7 +7,8 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/rs/zerolog"
 
 	"github.com/LayerTwo-Labs/sidesail/bitwindow/server/config"
@@ -103,10 +104,11 @@ func (r *connectRemote) clientFor(catalog netcatalog.Catalog) coinnewsv1connect.
 	if !ok || net.Services.CoinNews.URL == "" {
 		return nil
 	}
-	return coinnewsv1connect.NewCoinNewsServiceClient(
+	return coinnewsv1connect.NewCoinNewsServiceClient(connect.NewClient(connecthttp.NewTransport(
 		&http.Client{Timeout: 30 * time.Second},
 		net.Services.CoinNews.URL,
-	)
+		connecthttp.WithReadMaxBytes(0),
+	)))
 }
 
 func (r *connectRemote) ListFrontPage(ctx context.Context, topicHex string, limit uint32) ([]RemoteItem, error) {
@@ -118,13 +120,13 @@ func (r *connectRemote) ListFrontPage(ctx context.Context, topicHex string, limi
 	if topicHex != "" {
 		req.TopicHex = &topicHex
 	}
-	res, err := client.ListFrontPage(ctx, connect.NewRequest(req))
+	res, err := client.ListFrontPage(ctx, req)
 	if err != nil {
 		return nil, err
 	}
 
-	out := make([]RemoteItem, len(res.Msg.Items))
-	for i, item := range res.Msg.Items {
+	out := make([]RemoteItem, len(res.Items))
+	for i, item := range res.Items {
 		out[i] = RemoteItem{
 			ItemIDHex: item.ItemIdHex,
 			TopicHex:  item.TopicHex,
diff --git a/bitwindow/server/engines/deniability_engine_test.go b/bitwindow/server/engines/deniability_engine_test.go
index 031d477a8a..7dc520b56a 100644
--- a/bitwindow/server/engines/deniability_engine_test.go
+++ b/bitwindow/server/engines/deniability_engine_test.go
@@ -258,19 +258,15 @@ func TestDeniabilityEngine(t *testing.T) {
 		mockOrch.EXPECT().
 			SetFrozenCoins(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[emptypb.Empty]{Msg: &emptypb.Empty{}}, nil)
+			Return(&emptypb.Empty{}, nil)
 		mockOrch.EXPECT().
 			CreateBitcoinCoreWallet(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[orchpb.CreateBitcoinCoreWalletResponse]{
-				Msg: &orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"},
-			}, nil)
+			Return(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"}, nil)
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
 			Times(1).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "new-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "new-txid"}, nil)
 		engine := engines.NewDeniability(bitcoindService, db, testDenialWalletEngine(t, mockBitcoind, mockOrch))
 
 		denial, err := deniability.Create(ctx, db, denialWalletID, "test-txid", 2, 1*time.Hour, 3, nil)
@@ -363,19 +359,15 @@ func TestDeniabilityEngine(t *testing.T) {
 		mockOrch.EXPECT().
 			SetFrozenCoins(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[emptypb.Empty]{Msg: &emptypb.Empty{}}, nil)
+			Return(&emptypb.Empty{}, nil)
 		mockOrch.EXPECT().
 			CreateBitcoinCoreWallet(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[orchpb.CreateBitcoinCoreWalletResponse]{
-				Msg: &orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"},
-			}, nil)
+			Return(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"}, nil)
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
 			Times(1).
-			Return(&connect.Response[orchpb.SendTransactionResponse]{
-				Msg: &orchpb.SendTransactionResponse{Txid: "new-txid"},
-			}, nil)
+			Return(&orchpb.SendTransactionResponse{Txid: "new-txid"}, nil)
 		engine := engines.NewDeniability(bitcoindService, db, testDenialWalletEngine(t, mockBitcoind, mockOrch))
 
 		denial, err := deniability.Create(ctx, db, denialWalletID, "test-txid", 0, 1*time.Hour, 3, nil)
@@ -474,21 +466,17 @@ func TestDeniabilityEngine(t *testing.T) {
 		mockOrch.EXPECT().
 			SetFrozenCoins(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[emptypb.Empty]{Msg: &emptypb.Empty{}}, nil)
+			Return(&emptypb.Empty{}, nil)
 		mockOrch.EXPECT().
 			CreateBitcoinCoreWallet(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[orchpb.CreateBitcoinCoreWalletResponse]{
-				Msg: &orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"},
-			}, nil)
+			Return(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"}, nil)
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
 			Times(1).
-			DoAndReturn(func(_ context.Context, req *connect.Request[orchpb.SendTransactionRequest]) (*connect.Response[orchpb.SendTransactionResponse], error) {
-				assert.Equal(t, map[string]int64{"bc1qtest": 546}, req.Msg.Destinations)
-				return &connect.Response[orchpb.SendTransactionResponse]{
-					Msg: &orchpb.SendTransactionResponse{Txid: "new-txid"},
-				}, nil
+			DoAndReturn(func(_ context.Context, req *orchpb.SendTransactionRequest) (*orchpb.SendTransactionResponse, error) {
+				assert.Equal(t, map[string]int64{"bc1qtest": 546}, req.Destinations)
+				return &orchpb.SendTransactionResponse{Txid: "new-txid"}, nil
 			})
 		engine := engines.NewDeniability(bitcoindService, db, testDenialWalletEngine(t, mockBitcoind, mockOrch))
 
@@ -531,21 +519,17 @@ func TestDeniabilityEngine(t *testing.T) {
 		mockOrch.EXPECT().
 			SetFrozenCoins(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[emptypb.Empty]{Msg: &emptypb.Empty{}}, nil)
+			Return(&emptypb.Empty{}, nil)
 		mockOrch.EXPECT().
 			CreateBitcoinCoreWallet(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[orchpb.CreateBitcoinCoreWalletResponse]{
-				Msg: &orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"},
-			}, nil)
+			Return(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"}, nil)
 		mockOrch.EXPECT().
 			SendTransaction(gomock.Any(), gomock.Any()).
 			Times(8).
-			DoAndReturn(func(_ context.Context, req *connect.Request[orchpb.SendTransactionRequest]) (*connect.Response[orchpb.SendTransactionResponse], error) {
-				assert.Equal(t, map[string]int64{"bc1qtest": 546}, req.Msg.Destinations)
-				return &connect.Response[orchpb.SendTransactionResponse]{
-					Msg: &orchpb.SendTransactionResponse{Txid: "new-txid"},
-				}, nil
+			DoAndReturn(func(_ context.Context, req *orchpb.SendTransactionRequest) (*orchpb.SendTransactionResponse, error) {
+				assert.Equal(t, map[string]int64{"bc1qtest": 546}, req.Destinations)
+				return &orchpb.SendTransactionResponse{Txid: "new-txid"}, nil
 			})
 		engine := engines.NewDeniability(bitcoindService, db, testDenialWalletEngine(t, mockBitcoind, mockOrch))
 
@@ -584,9 +568,7 @@ func TestDeniabilityEngine(t *testing.T) {
 		mockOrch.EXPECT().
 			CreateBitcoinCoreWallet(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[orchpb.CreateBitcoinCoreWalletResponse]{
-				Msg: &orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"},
-			}, nil)
+			Return(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_80CEBA21"}, nil)
 		mockOrch.EXPECT().SetFrozenCoins(gomock.Any(), gomock.Any()).Times(0)
 		mockOrch.EXPECT().SendTransaction(gomock.Any(), gomock.Any()).Times(0)
 		walletEngine := testDenialWalletEngineWithFrozen(t, mockBitcoind, mockOrch, func(context.Context) ([]string, error) {
diff --git a/bitwindow/server/engines/frozen_coins_test.go b/bitwindow/server/engines/frozen_coins_test.go
index 97f429e2a6..f397927d8b 100644
--- a/bitwindow/server/engines/frozen_coins_test.go
+++ b/bitwindow/server/engines/frozen_coins_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -35,16 +34,14 @@ func TestSendHandsOverTheFrozenCoins(t *testing.T) {
 	client.EXPECT().
 		SetFrozenCoins(gomock.Any(), gomock.Any()).
 		Times(1).
-		DoAndReturn(func(_ context.Context, req *connect.Request[orchpb.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error) {
-			sent = req.Msg
+		DoAndReturn(func(_ context.Context, req *orchpb.SetFrozenCoinsRequest) (*emptypb.Empty, error) {
+			sent = req
 			return nil, nil
 		})
 	client.EXPECT().
 		SendTransaction(gomock.Any(), gomock.Any()).
 		Times(1).
-		Return(&connect.Response[orchpb.SendTransactionResponse]{
-			Msg: &orchpb.SendTransactionResponse{Txid: "txid"},
-		}, nil)
+		Return(&orchpb.SendTransactionResponse{Txid: "txid"}, nil)
 
 	txid, err := engine.SendTransaction(t.Context(), &orchpb.SendTransactionRequest{
 		WalletId:    "wallet-1",
@@ -95,7 +92,7 @@ func TestKeepFrozenCoinsHandsTheSetOverAgain(t *testing.T) {
 	client.EXPECT().
 		SetFrozenCoins(gomock.Any(), gomock.Any()).
 		AnyTimes().
-		DoAndReturn(func(context.Context, *connect.Request[orchpb.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error) {
+		DoAndReturn(func(context.Context, *orchpb.SetFrozenCoinsRequest) (*emptypb.Empty, error) {
 			pushes <- struct{}{}
 			return nil, nil
 		})
@@ -122,13 +119,11 @@ func TestDepositHandsOverTheFrozenCoins(t *testing.T) {
 	client.EXPECT().
 		SetFrozenCoins(gomock.Any(), gomock.Any()).
 		Times(1).
-		Return(&connect.Response[emptypb.Empty]{Msg: &emptypb.Empty{}}, nil)
+		Return(&emptypb.Empty{}, nil)
 	client.EXPECT().
 		CreateDeposit(gomock.Any(), gomock.Any()).
 		Times(1).
-		Return(&connect.Response[orchpb.CreateDepositResponse]{
-			Msg: &orchpb.CreateDepositResponse{Txid: "deposit-txid"},
-		}, nil)
+		Return(&orchpb.CreateDepositResponse{Txid: "deposit-txid"}, nil)
 
 	txid, err := engine.CreateDeposit(t.Context(), &orchpb.CreateDepositRequest{WalletId: "wallet-1"})
 	require.NoError(t, err)
@@ -146,13 +141,11 @@ func TestBumpFeeHandsOverTheFrozenCoins(t *testing.T) {
 	client.EXPECT().
 		SetFrozenCoins(gomock.Any(), gomock.Any()).
 		Times(1).
-		Return(&connect.Response[emptypb.Empty]{Msg: &emptypb.Empty{}}, nil)
+		Return(&emptypb.Empty{}, nil)
 	client.EXPECT().
 		BumpFee(gomock.Any(), gomock.Any()).
 		Times(1).
-		Return(&connect.Response[orchpb.BumpFeeResponse]{
-			Msg: &orchpb.BumpFeeResponse{NewTxid: "bumped"},
-		}, nil)
+		Return(&orchpb.BumpFeeResponse{NewTxid: "bumped"}, nil)
 
 	resp, err := engine.BumpFee(t.Context(), &orchpb.BumpFeeRequest{Txid: "old"})
 	require.NoError(t, err)
diff --git a/bitwindow/server/engines/light_mode_pollers_test.go b/bitwindow/server/engines/light_mode_pollers_test.go
index 56ff6ba7f6..e954e16997 100644
--- a/bitwindow/server/engines/light_mode_pollers_test.go
+++ b/bitwindow/server/engines/light_mode_pollers_test.go
@@ -43,9 +43,7 @@ func nodeModeSource(t *testing.T, mode orchpb.NodeMode) *engines.NodeMode {
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
 		AnyTimes().
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: mode},
-		}, nil)
+		Return(&orchpb.GetNodeModeResponse{Mode: mode}, nil)
 
 	return engines.NewNodeMode(client)
 }
@@ -152,9 +150,7 @@ func TestParserSweepsTheMempoolAfterTheModeRecovers(t *testing.T) {
 		orch.EXPECT().
 			GetNodeMode(gomock.Any(), gomock.Any()).
 			AnyTimes().
-			Return(&connect.Response[orchpb.GetNodeModeResponse]{
-				Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL},
-			}, nil),
+			Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}, nil),
 	)
 	nodeMode := engines.NewNodeMode(orch)
 
diff --git a/bitwindow/server/engines/m4_engine_replay_test.go b/bitwindow/server/engines/m4_engine_replay_test.go
index 491d52fe84..695f86db39 100644
--- a/bitwindow/server/engines/m4_engine_replay_test.go
+++ b/bitwindow/server/engines/m4_engine_replay_test.go
@@ -7,7 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/samber/lo"
@@ -138,12 +137,12 @@ func enforcerAt(t *testing.T, tip uint32, activations map[uint32]uint32) *servic
 	}
 	validator := mocks.NewMockValidatorServiceClient(gomock.NewController(t))
 	validator.EXPECT().GetChainTip(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&validatorpb.GetChainTipResponse{
+		Return(&validatorpb.GetChainTipResponse{
 			BlockHeaderInfo: &validatorpb.BlockHeaderInfo{Height: tip},
-		}), nil).
+		}, nil).
 		AnyTimes()
 	validator.EXPECT().GetSidechains(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&validatorpb.GetSidechainsResponse{Sidechains: sidechains}), nil).
+		Return(&validatorpb.GetSidechainsResponse{Sidechains: sidechains}, nil).
 		AnyTimes()
 	return service.New("enforcer", func(context.Context) (validatorrpc.ValidatorServiceClient, error) {
 		return validator, nil
diff --git a/bitwindow/server/engines/node_mode.go b/bitwindow/server/engines/node_mode.go
index 2801eb5383..4edee63df0 100644
--- a/bitwindow/server/engines/node_mode.go
+++ b/bitwindow/server/engines/node_mode.go
@@ -6,7 +6,7 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"golang.org/x/sync/singleflight"
 
 	orchpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
@@ -47,15 +47,15 @@ func (n *NodeMode) Mode(ctx context.Context) (orchpb.NodeMode, error) {
 	}
 
 	read, err, _ := n.reads.Do("mode", func() (any, error) {
-		resp, err := n.client.GetNodeMode(ctx, connect.NewRequest(&orchpb.GetNodeModeRequest{}))
+		resp, err := n.client.GetNodeMode(ctx, &orchpb.GetNodeModeRequest{})
 		if err != nil {
 			return orchpb.NodeMode_NODE_MODE_UNSPECIFIED, err
 		}
 
 		n.mu.Lock()
-		n.cached, n.readAt = resp.Msg.Mode, time.Now()
+		n.cached, n.readAt = resp.Mode, time.Now()
 		n.mu.Unlock()
-		return resp.Msg.Mode, nil
+		return resp.Mode, nil
 	})
 	if err != nil {
 		return orchpb.NodeMode_NODE_MODE_UNSPECIFIED, err
@@ -98,11 +98,11 @@ func (n *NodeMode) RequireFullNode(ctx context.Context, op string) error {
 	mode, err := n.Mode(ctx)
 	if err != nil {
 		return connect.NewError(connect.CodeUnavailable,
-			fmt.Errorf("%s: read the node mode: %w", op, err))
+			fmt.Errorf("%s: read the node mode: %w", op, err).Error()).WithCause(err)
 	}
 	if mode == orchpb.NodeMode_NODE_MODE_LIGHT {
-		return connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("%s needs full mode, which runs a local Bitcoin node and the enforcer", op))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"%s needs full mode, which runs a local Bitcoin node and the enforcer", op)
 	}
 	return nil
 }
diff --git a/bitwindow/server/engines/node_mode_test.go b/bitwindow/server/engines/node_mode_test.go
index 629bd8002e..f7b4d21939 100644
--- a/bitwindow/server/engines/node_mode_test.go
+++ b/bitwindow/server/engines/node_mode_test.go
@@ -7,7 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 
@@ -21,9 +20,7 @@ func nodeModeWith(t *testing.T, mode orchpb.NodeMode) *NodeMode {
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
 		AnyTimes().
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: mode},
-		}, nil)
+		Return(&orchpb.GetNodeModeResponse{Mode: mode}, nil)
 
 	return NewNodeMode(client)
 }
@@ -55,9 +52,7 @@ func TestRunsLocalNodeKeepsTheLastAnswer(t *testing.T) {
 
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_LIGHT},
-		}, nil)
+		Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_LIGHT}, nil)
 	require.False(t, nodeMode.RunsLocalNode(t.Context()))
 
 	nodeMode.expire()
@@ -74,9 +69,7 @@ func TestRunsLocalNodeKeepsAFullAnswer(t *testing.T) {
 
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL},
-		}, nil)
+		Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}, nil)
 	require.True(t, nodeMode.RunsLocalNode(t.Context()))
 
 	nodeMode.expire()
@@ -94,9 +87,7 @@ func TestModeCachesTheRead(t *testing.T) {
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
 		Times(1).
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL},
-		}, nil)
+		Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}, nil)
 
 	for range 5 {
 		require.True(t, nodeMode.RunsLocalNode(t.Context()))
@@ -110,17 +101,13 @@ func TestModeReReadsAfterTheCacheExpires(t *testing.T) {
 
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_LIGHT},
-		}, nil)
+		Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_LIGHT}, nil)
 	require.False(t, nodeMode.RunsLocalNode(t.Context()))
 
 	nodeMode.expire()
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL},
-		}, nil)
+		Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}, nil)
 	require.True(t, nodeMode.RunsLocalNode(t.Context()))
 }
 
@@ -133,11 +120,9 @@ func TestModeCollapsesConcurrentReads(t *testing.T) {
 	client.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
 		Times(1).
-		DoAndReturn(func(context.Context, *connect.Request[orchpb.GetNodeModeRequest]) (*connect.Response[orchpb.GetNodeModeResponse], error) {
+		DoAndReturn(func(context.Context, *orchpb.GetNodeModeRequest) (*orchpb.GetNodeModeResponse, error) {
 			time.Sleep(100 * time.Millisecond)
-			return &connect.Response[orchpb.GetNodeModeResponse]{
-				Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL},
-			}, nil
+			return &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}, nil
 		})
 
 	var wg sync.WaitGroup
diff --git a/bitwindow/server/engines/require_full_node_test.go b/bitwindow/server/engines/require_full_node_test.go
index f6ca073597..30ab6eb771 100644
--- a/bitwindow/server/engines/require_full_node_test.go
+++ b/bitwindow/server/engines/require_full_node_test.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/stretchr/testify/require"
@@ -21,9 +21,7 @@ func engineWithMode(t *testing.T, mode orchpb.NodeMode, err error) *engines.Wall
 	orch.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
 		AnyTimes().
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: mode},
-		}, err)
+		Return(&orchpb.GetNodeModeResponse{Mode: mode}, err)
 	return engines.NewWalletEngine(
 		func(context.Context) (corerpc.BitcoinServiceClient, error) { return nil, nil },
 		orch,
@@ -50,7 +48,7 @@ func TestRequireFullNodeAllowsFullMode(t *testing.T) {
 // An unreadable mode must not read as full. Failing open would let the call
 // through to a daemon that is not there, with a confusing error.
 func TestRequireFullNodeReportsAnUnreadableMode(t *testing.T) {
-	boom := connect.NewError(connect.CodeInternal, context.DeadlineExceeded)
+	boom := connect.NewError(connect.CodeInternal, context.DeadlineExceeded.Error()).WithCause(context.DeadlineExceeded)
 	e := engineWithMode(t, orchpb.NodeMode_NODE_MODE_UNSPECIFIED, boom)
 
 	err := e.RequireFullNode(t.Context(), "proposing a sidechain")
diff --git a/bitwindow/server/engines/timestamp_engine_test.go b/bitwindow/server/engines/timestamp_engine_test.go
index cf4921091c..16bbff5456 100644
--- a/bitwindow/server/engines/timestamp_engine_test.go
+++ b/bitwindow/server/engines/timestamp_engine_test.go
@@ -9,7 +9,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/chaincfg"
 	_ "github.com/mattn/go-sqlite3"
@@ -57,14 +56,14 @@ func timestampWallet(t *testing.T, txids ...string) *engines.WalletEngine {
 	t.Helper()
 	orch := mocks.NewMockWalletManagerServiceClient(gomock.NewController(t))
 	orch.EXPECT().SetFrozenCoins(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&emptypb.Empty{}), nil).
+		Return(&emptypb.Empty{}, nil).
 		AnyTimes()
 	sent := 0
 	orch.EXPECT().SendTransaction(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(context.Context, *connect.Request[orchpb.SendTransactionRequest]) (*connect.Response[orchpb.SendTransactionResponse], error) {
+		DoAndReturn(func(context.Context, *orchpb.SendTransactionRequest) (*orchpb.SendTransactionResponse, error) {
 			txid := txids[sent]
 			sent++
-			return connect.NewResponse(&orchpb.SendTransactionResponse{Txid: txid}), nil
+			return &orchpb.SendTransactionResponse{Txid: txid}, nil
 		}).
 		AnyTimes()
 	return engines.NewWalletEngine(nil, apitests.OpenWallet(orch, &orchpb.WalletMetadata{Id: "a"}), &chaincfg.SigNetParams,
diff --git a/bitwindow/server/engines/wallet_engine.go b/bitwindow/server/engines/wallet_engine.go
index e02d51713a..6fbf90e952 100644
--- a/bitwindow/server/engines/wallet_engine.go
+++ b/bitwindow/server/engines/wallet_engine.go
@@ -169,9 +169,9 @@ func (e *WalletEngine) PushFrozenCoins(ctx context.Context) error {
 		coins = append(coins, &orchpb.FrozenOutpoint{Txid: txid, Vout: int32(vout)})
 	}
 
-	_, err = e.orchClient.SetFrozenCoins(ctx, connect.NewRequest(&orchpb.SetFrozenCoinsRequest{
+	_, err = e.orchClient.SetFrozenCoins(ctx, &orchpb.SetFrozenCoinsRequest{
 		Outpoints: coins,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("set frozen coins: %w", err)
 	}
@@ -202,7 +202,7 @@ func (e *WalletEngine) NodeMode() *NodeMode {
 
 // Unlock opens the wallet in the orchestrator.
 func (e *WalletEngine) Unlock(ctx context.Context, password string) error {
-	_, err := e.orchClient.UnlockWallet(ctx, connect.NewRequest(&orchpb.UnlockWalletRequest{Password: password}))
+	_, err := e.orchClient.UnlockWallet(ctx, &orchpb.UnlockWalletRequest{Password: password})
 	if err != nil {
 		return fmt.Errorf("unlock wallet: %w", err)
 	}
@@ -211,7 +211,7 @@ func (e *WalletEngine) Unlock(ctx context.Context, password string) error {
 
 // Lock closes the wallet in the orchestrator.
 func (e *WalletEngine) Lock(ctx context.Context) error {
-	if _, err := e.orchClient.LockWallet(ctx, connect.NewRequest(&orchpb.LockWalletRequest{})); err != nil {
+	if _, err := e.orchClient.LockWallet(ctx, &orchpb.LockWalletRequest{}); err != nil {
 		return fmt.Errorf("lock wallet: %w", err)
 	}
 	return nil
@@ -219,20 +219,20 @@ func (e *WalletEngine) Lock(ctx context.Context) error {
 
 // IsUnlocked reports whether the orchestrator holds the wallets open.
 func (e *WalletEngine) IsUnlocked(ctx context.Context) (bool, error) {
-	resp, err := e.orchClient.GetWalletStatus(ctx, connect.NewRequest(&orchpb.GetWalletStatusRequest{}))
+	resp, err := e.orchClient.GetWalletStatus(ctx, &orchpb.GetWalletStatusRequest{})
 	if err != nil {
 		return false, fmt.Errorf("get wallet status: %w", err)
 	}
-	return resp.Msg.State == orchpb.WalletState_WALLET_STATE_UNLOCKED, nil
+	return resp.State == orchpb.WalletState_WALLET_STATE_UNLOCKED, nil
 }
 
 // IsEncrypted reports whether the orchestrator wallet file has a password.
 func (e *WalletEngine) IsEncrypted(ctx context.Context) (bool, error) {
-	resp, err := e.orchClient.GetWalletStatus(ctx, connect.NewRequest(&orchpb.GetWalletStatusRequest{}))
+	resp, err := e.orchClient.GetWalletStatus(ctx, &orchpb.GetWalletStatusRequest{})
 	if err != nil {
 		return false, fmt.Errorf("get wallet status: %w", err)
 	}
-	return resp.Msg.Encrypted, nil
+	return resp.Encrypted, nil
 }
 
 // GetStarterSeed returns the seed hex of the wallet that derives the L1 and
@@ -241,11 +241,11 @@ func (e *WalletEngine) IsEncrypted(ctx context.Context) (bool, error) {
 func (e *WalletEngine) GetStarterSeed(ctx context.Context) (string, error) {
 	// GetWalletSeed names its wallet, so resolve the starter's id before
 	// asking for its seed.
-	list, err := e.orchClient.ListWallets(ctx, connect.NewRequest(&orchpb.ListWalletsRequest{}))
+	list, err := e.orchClient.ListWallets(ctx, &orchpb.ListWalletsRequest{})
 	if err != nil {
 		return "", fmt.Errorf("list wallets: %w", err)
 	}
-	starter, found := lo.Find(list.Msg.Wallets, func(w *orchpb.WalletMetadata) bool {
+	starter, found := lo.Find(list.Wallets, func(w *orchpb.WalletMetadata) bool {
 		return w.IsStarter
 	})
 	if !found {
@@ -253,22 +253,22 @@ func (e *WalletEngine) GetStarterSeed(ctx context.Context) (string, error) {
 	}
 	resp, err := e.orchClient.GetWalletSeed(
 		ctx,
-		connect.NewRequest(&orchpb.GetWalletSeedRequest{WalletId: starter.Id}),
+		&orchpb.GetWalletSeedRequest{WalletId: starter.Id},
 	)
 	if err != nil {
 		return "", fmt.Errorf("get seed of starter wallet %s: %w", starter.Id, err)
 	}
-	return resp.Msg.SeedHex, nil
+	return resp.SeedHex, nil
 }
 
 func (e *WalletEngine) GetWalletSeed(ctx context.Context, walletID string) (string, error) {
-	resp, err := e.orchClient.GetWalletSeed(ctx, connect.NewRequest(&orchpb.GetWalletSeedRequest{
+	resp, err := e.orchClient.GetWalletSeed(ctx, &orchpb.GetWalletSeedRequest{
 		WalletId: walletID,
-	}))
+	})
 	if err != nil {
 		return "", fmt.Errorf("get seed of wallet %s: %w", walletID, err)
 	}
-	return resp.Msg.SeedHex, nil
+	return resp.SeedHex, nil
 }
 
 func (e *WalletEngine) GetActiveWallet(ctx context.Context) (*WalletInfo, error) {
@@ -368,16 +368,16 @@ func (e *WalletEngine) EnsureBitcoinCoreWallet(ctx context.Context, walletID str
 // ensureBitcoinCoreWalletLocked is the singleflight-wrapped body of
 // EnsureBitcoinCoreWallet. Don't call directly.
 func (e *WalletEngine) ensureBitcoinCoreWalletLocked(ctx context.Context, walletID string) (string, error) {
-	resp, err := e.orchClient.CreateBitcoinCoreWallet(ctx, connect.NewRequest(&orchpb.CreateBitcoinCoreWalletRequest{
+	resp, err := e.orchClient.CreateBitcoinCoreWallet(ctx, &orchpb.CreateBitcoinCoreWalletRequest{
 		WalletId: walletID,
-	}))
+	})
 	if err != nil {
 		return "", err
 	}
 	e.mu.Lock()
-	e.coreWallets[walletID] = resp.Msg.CoreWalletName
+	e.coreWallets[walletID] = resp.CoreWalletName
 	e.mu.Unlock()
-	return resp.Msg.CoreWalletName, nil
+	return resp.CoreWalletName, nil
 }
 
 // CoreWalletName returns the Bitcoin Core wallet that holds the wallet's coins.
@@ -396,39 +396,39 @@ func (e *WalletEngine) CoreWalletName(ctx context.Context, walletID string) (str
 // GetNewAddress returns a receive address of the wallet. The orchestrator
 // derives it for Core and electrum wallets alike.
 func (e *WalletEngine) GetNewAddress(ctx context.Context, walletID string, addressType orchpb.AddressType) (string, error) {
-	resp, err := e.orchClient.GetNewAddress(ctx, connect.NewRequest(&orchpb.GetNewAddressRequest{
+	resp, err := e.orchClient.GetNewAddress(ctx, &orchpb.GetNewAddressRequest{
 		WalletId:    walletID,
 		AddressType: addressType,
-	}))
+	})
 	if err != nil {
 		return "", fmt.Errorf("get new address: %w", err)
 	}
-	return resp.Msg.Address, nil
+	return resp.Address, nil
 }
 
 // DeriveReceiveAddresses returns the first count receive addresses of the
 // wallet, as the orchestrator derives them.
 func (e *WalletEngine) DeriveReceiveAddresses(ctx context.Context, walletID string, count int) ([]string, error) {
-	resp, err := e.orchClient.DeriveAddresses(ctx, connect.NewRequest(&orchpb.DeriveAddressesRequest{
+	resp, err := e.orchClient.DeriveAddresses(ctx, &orchpb.DeriveAddressesRequest{
 		WalletId: walletID,
 		Count:    int32(count),
-	}))
+	})
 	if err != nil {
 		return nil, fmt.Errorf("derive addresses: %w", err)
 	}
-	return resp.Msg.Addresses, nil
+	return resp.Addresses, nil
 }
 
 // GetElectrumBalance returns the confirmed, pending and immature balance (in
 // sats) for an electrum wallet from the orchestrator's Esplora-backed provider.
 func (e *WalletEngine) GetElectrumBalance(ctx context.Context, walletID string) (confirmed, pending, immature uint64, err error) {
-	resp, err := e.orchClient.GetBalance(ctx, connect.NewRequest(&orchpb.GetBalanceRequest{
+	resp, err := e.orchClient.GetBalance(ctx, &orchpb.GetBalanceRequest{
 		WalletId: walletID,
-	}))
+	})
 	if err != nil {
 		return 0, 0, 0, fmt.Errorf("electrum: get balance: %w", err)
 	}
-	return uint64(math.Round(resp.Msg.ConfirmedSats)), uint64(math.Round(resp.Msg.UnconfirmedSats)), uint64(math.Round(resp.Msg.ImmatureSats)), nil
+	return uint64(math.Round(resp.ConfirmedSats)), uint64(math.Round(resp.UnconfirmedSats)), uint64(math.Round(resp.ImmatureSats)), nil
 }
 
 // RequireFullNode refuses an operation that needs a local BIP300/301 enforcer.
@@ -470,11 +470,11 @@ func (e *WalletEngine) SendTransaction(ctx context.Context, req *orchpb.SendTran
 	if err := e.PushFrozenCoins(ctx); err != nil {
 		return "", err
 	}
-	resp, err := e.orchClient.SendTransaction(ctx, connect.NewRequest(req))
+	resp, err := e.orchClient.SendTransaction(ctx, req)
 	if err != nil {
 		return "", fmt.Errorf("send transaction: %w", err)
 	}
-	return resp.Msg.Txid, nil
+	return resp.Txid, nil
 }
 
 // ErrFrozenInput is the error of a send that names a coin the user froze.
@@ -508,11 +508,11 @@ func (e *WalletEngine) refuseFrozenInputs(ctx context.Context, inputs []*orchpb.
 
 // ListWalletIDs names every wallet the orchestrator holds.
 func (e *WalletEngine) ListWalletIDs(ctx context.Context) ([]string, error) {
-	resp, err := e.orchClient.ListWallets(ctx, connect.NewRequest(&orchpb.ListWalletsRequest{}))
+	resp, err := e.orchClient.ListWallets(ctx, &orchpb.ListWalletsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("list wallets: %w", err)
 	}
-	return lo.Map(resp.Msg.Wallets, func(w *orchpb.WalletMetadata, _ int) string { return w.Id }), nil
+	return lo.Map(resp.Wallets, func(w *orchpb.WalletMetadata, _ int) string { return w.Id }), nil
 }
 
 // BumpFee replaces a transaction with one that pays more. Coin selection runs
@@ -521,11 +521,11 @@ func (e *WalletEngine) BumpFee(ctx context.Context, req *orchpb.BumpFeeRequest)
 	if err := e.PushFrozenCoins(ctx); err != nil {
 		return nil, err
 	}
-	resp, err := e.orchClient.BumpFee(ctx, connect.NewRequest(req))
+	resp, err := e.orchClient.BumpFee(ctx, req)
 	if err != nil {
 		return nil, fmt.Errorf("bump fee: %w", err)
 	}
-	return resp.Msg, nil
+	return resp, nil
 }
 
 // CreateDeposit builds and broadcasts a BIP300 M5 deposit from any wallet.
@@ -533,37 +533,37 @@ func (e *WalletEngine) CreateDeposit(ctx context.Context, req *orchpb.CreateDepo
 	if err := e.PushFrozenCoins(ctx); err != nil {
 		return "", err
 	}
-	resp, err := e.orchClient.CreateDeposit(ctx, connect.NewRequest(req))
+	resp, err := e.orchClient.CreateDeposit(ctx, req)
 	if err != nil {
 		return "", fmt.Errorf("create deposit: %w", err)
 	}
-	return resp.Msg.Txid, nil
+	return resp.Txid, nil
 }
 
 // GetElectrumUnspent returns an electrum wallet's UTXOs from the orchestrator,
 // which serves them over Esplora.
 func (e *WalletEngine) GetElectrumUnspent(ctx context.Context, walletID string) ([]*orchpb.UnspentOutput, error) {
-	resp, err := e.orchClient.ListUnspent(ctx, connect.NewRequest(&orchpb.ListUnspentRequest{
+	resp, err := e.orchClient.ListUnspent(ctx, &orchpb.ListUnspentRequest{
 		WalletId: walletID,
-	}))
+	})
 	if err != nil {
 		return nil, fmt.Errorf("electrum: list unspent: %w", err)
 	}
-	return resp.Msg.Utxos, nil
+	return resp.Utxos, nil
 }
 
 // GetElectrumTransactions returns an electrum wallet's transactions from the
 // orchestrator, which serves them over Esplora.
 func (e *WalletEngine) GetElectrumTransactions(ctx context.Context, walletID string) ([]*orchpb.TransactionEntry, error) {
-	resp, err := e.orchClient.ListTransactions(ctx, connect.NewRequest(&orchpb.ListTransactionsRequest{
+	resp, err := e.orchClient.ListTransactions(ctx, &orchpb.ListTransactionsRequest{
 		WalletId: walletID,
 		// The orchestrator has no skip, and a count of 0 means 100 rows.
 		Count: math.MaxInt32,
-	}))
+	})
 	if err != nil {
 		return nil, fmt.Errorf("electrum: list transactions: %w", err)
 	}
-	return resp.Msg.Transactions, nil
+	return resp.Transactions, nil
 }
 
 // EnsureWatchOnlyWallet ensures a watch-only wallet exists in Bitcoin Core
@@ -615,11 +615,11 @@ func (e *WalletEngine) SyncWallets(ctx context.Context) error {
 
 	log.Info().Msg("wallet sync: starting")
 
-	resp, err := e.orchClient.EnsureCoreWallets(ctx, connect.NewRequest(&orchpb.EnsureCoreWalletsRequest{}))
+	resp, err := e.orchClient.EnsureCoreWallets(ctx, &orchpb.EnsureCoreWalletsRequest{})
 	if err != nil {
 		return fmt.Errorf("wallet sync: %w", err)
 	}
-	log.Info().Int32("synced", resp.Msg.SyncedCount).Msg("wallet sync: completed via orchestrator")
+	log.Info().Int32("synced", resp.SyncedCount).Msg("wallet sync: completed via orchestrator")
 	return nil
 }
 
@@ -631,11 +631,11 @@ func (e *WalletEngine) GetAllWallets(ctx context.Context) ([]WalletInfo, error)
 // listWallets returns the wallets the orchestrator holds open, and the active
 // wallet id. A locked wallet file lists no wallets.
 func (e *WalletEngine) listWallets(ctx context.Context) ([]WalletInfo, string, error) {
-	resp, err := e.orchClient.ListWallets(ctx, connect.NewRequest(&orchpb.ListWalletsRequest{}))
+	resp, err := e.orchClient.ListWallets(ctx, &orchpb.ListWalletsRequest{})
 	if err != nil {
 		return nil, "", fmt.Errorf("list wallets: %w", err)
 	}
-	wallets := lo.Map(resp.Msg.Wallets, func(w *orchpb.WalletMetadata, _ int) WalletInfo {
+	wallets := lo.Map(resp.Wallets, func(w *orchpb.WalletMetadata, _ int) WalletInfo {
 		return WalletInfo{
 			ID:             w.Id,
 			Name:           w.Name,
@@ -646,43 +646,43 @@ func (e *WalletEngine) listWallets(ctx context.Context) ([]WalletInfo, string, e
 			ScriptType:     w.ScriptType,
 		}
 	})
-	return wallets, resp.Msg.ActiveWalletId, nil
+	return wallets, resp.ActiveWalletId, nil
 }
 
 // ChequeAddressUnspent reports a cheque address's UTXOs. Always electrum-backed
 // on the orchestrator side, whatever wallet the user has active.
 func (e *WalletEngine) ChequeAddressUnspent(ctx context.Context, address string) ([]*orchpb.AddressUnspentOutput, int32, error) {
-	resp, err := e.orchClient.GetAddressUnspent(ctx, connect.NewRequest(&orchpb.GetAddressUnspentRequest{
+	resp, err := e.orchClient.GetAddressUnspent(ctx, &orchpb.GetAddressUnspentRequest{
 		Address: address,
-	}))
+	})
 	if err != nil {
 		return nil, 0, fmt.Errorf("electrum: address unspent: %w", err)
 	}
-	return resp.Msg.Utxos, resp.Msg.TipHeight, nil
+	return resp.Utxos, resp.TipHeight, nil
 }
 
 // BroadcastChequeTx broadcasts a cheque sweep over electrum, whatever wallet
 // the user has active.
 func (e *WalletEngine) BroadcastChequeTx(ctx context.Context, txHex string) (string, error) {
-	resp, err := e.orchClient.BroadcastElectrumTransaction(ctx, connect.NewRequest(&orchpb.BroadcastElectrumTransactionRequest{
+	resp, err := e.orchClient.BroadcastElectrumTransaction(ctx, &orchpb.BroadcastElectrumTransactionRequest{
 		TxHex: txHex,
-	}))
+	})
 	if err != nil {
 		return "", fmt.Errorf("electrum: broadcast: %w", err)
 	}
-	return resp.Msg.Txid, nil
+	return resp.Txid, nil
 }
 
 // EstimateFeeRate returns the electrum fee estimate in sat/vB for a
 // confirmation target, floored at the 1 sat/vB relay minimum.
 func (e *WalletEngine) EstimateFeeRate(ctx context.Context, confTarget int32) (float64, error) {
-	resp, err := e.orchClient.EstimateFee(ctx, connect.NewRequest(&orchpb.EstimateFeeRequest{
+	resp, err := e.orchClient.EstimateFee(ctx, &orchpb.EstimateFeeRequest{
 		ConfTarget: confTarget,
-	}))
+	})
 	if err != nil {
 		return 0, fmt.Errorf("electrum: estimate fee: %w", err)
 	}
-	rate := resp.Msg.SatPerVbyte
+	rate := resp.SatPerVbyte
 	if rate < 1 {
 		rate = 1
 	}
@@ -768,26 +768,26 @@ func isWalletNotFoundError(msg string) bool {
 // SidechainDepositTotals sums this install's deposits: all time, and since
 // `since`. Both in sats. An empty walletID sums every wallet's.
 func (e *WalletEngine) SidechainDepositTotals(ctx context.Context, since time.Time, walletID string) (int64, int64, error) {
-	resp, err := e.orchClient.GetSidechainDepositTotals(ctx, connect.NewRequest(&orchpb.GetSidechainDepositTotalsRequest{
+	resp, err := e.orchClient.GetSidechainDepositTotals(ctx, &orchpb.GetSidechainDepositTotalsRequest{
 		SinceUnix: since.Unix(),
 		WalletId:  walletID,
-	}))
+	})
 	if err != nil {
 		return 0, 0, fmt.Errorf("get sidechain deposit totals: %w", err)
 	}
-	return resp.Msg.TotalSats, resp.Msg.RecentSats, nil
+	return resp.TotalSats, resp.RecentSats, nil
 }
 
 // ListSidechainDeposits reports the deposits this install made to a slot. The
 // orchestrator records each one as it broadcasts it, because an M5 is an
 // ordinary transaction on the wire.
 func (e *WalletEngine) ListSidechainDeposits(ctx context.Context, slot uint32, walletID string) ([]*orchpb.SidechainDeposit, error) {
-	resp, err := e.orchClient.ListSidechainDeposits(ctx, connect.NewRequest(&orchpb.ListSidechainDepositsRequest{
+	resp, err := e.orchClient.ListSidechainDeposits(ctx, &orchpb.ListSidechainDepositsRequest{
 		Slot:     slot,
 		WalletId: walletID,
-	}))
+	})
 	if err != nil {
 		return nil, fmt.Errorf("list sidechain deposits: %w", err)
 	}
-	return resp.Msg.Deposits, nil
+	return resp.Deposits, nil
 }
diff --git a/bitwindow/server/engines/wallet_engine_test.go b/bitwindow/server/engines/wallet_engine_test.go
index 57cbc85e7a..7b2fa24019 100644
--- a/bitwindow/server/engines/wallet_engine_test.go
+++ b/bitwindow/server/engines/wallet_engine_test.go
@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"connectrpc.com/connect"
+	connectv2 "connectrpc.com/connect/v2"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -25,15 +26,15 @@ type openWalletClient struct {
 	wallet *orchpb.WalletMetadata
 }
 
-func (o openWalletClient) ListWallets(context.Context, *connect.Request[orchpb.ListWalletsRequest]) (*connect.Response[orchpb.ListWalletsResponse], error) {
-	return connect.NewResponse(&orchpb.ListWalletsResponse{
+func (o openWalletClient) ListWallets(context.Context, *orchpb.ListWalletsRequest) (*orchpb.ListWalletsResponse, error) {
+	return &orchpb.ListWalletsResponse{
 		Wallets:        []*orchpb.WalletMetadata{o.wallet},
 		ActiveWalletId: o.wallet.Id,
-	}), nil
+	}, nil
 }
 
-func (o openWalletClient) GetWalletStatus(context.Context, *connect.Request[orchpb.GetWalletStatusRequest]) (*connect.Response[orchpb.GetWalletStatusResponse], error) {
-	return connect.NewResponse(&orchpb.GetWalletStatusResponse{State: orchpb.WalletState_WALLET_STATE_UNLOCKED}), nil
+func (o openWalletClient) GetWalletStatus(context.Context, *orchpb.GetWalletStatusRequest) (*orchpb.GetWalletStatusResponse, error) {
+	return &orchpb.GetWalletStatusResponse{State: orchpb.WalletState_WALLET_STATE_UNLOCKED}, nil
 }
 
 // stubOrchWalletClient fails CreateBitcoinCoreWallet with a fixed error.
@@ -42,7 +43,7 @@ type stubOrchWalletClient struct {
 	err error
 }
 
-func (s stubOrchWalletClient) CreateBitcoinCoreWallet(context.Context, *connect.Request[orchpb.CreateBitcoinCoreWalletRequest]) (*connect.Response[orchpb.CreateBitcoinCoreWalletResponse], error) {
+func (s stubOrchWalletClient) CreateBitcoinCoreWallet(context.Context, *orchpb.CreateBitcoinCoreWalletRequest) (*orchpb.CreateBitcoinCoreWalletResponse, error) {
 	return nil, s.err
 }
 
@@ -50,8 +51,8 @@ func (s stubOrchWalletClient) CreateBitcoinCoreWallet(context.Context, *connect.
 // error reaches the caller. Only the orchestrator creates a Core wallet.
 func TestEnsureWatchOnlyWalletTransientOrchestratorError(t *testing.T) {
 	for _, orchErr := range []error{
-		connect.NewError(connect.CodeInternal, errors.New("-28: Verifying blocks…")),
-		connect.NewError(connect.CodeUnavailable, errors.New("connection refused")),
+		connectv2.NewError(connectv2.CodeInternal, "-28: Verifying blocks…"),
+		connectv2.NewError(connectv2.CodeUnavailable, "connection refused"),
 	} {
 		e := NewWalletEngine(nil, stubOrchWalletClient{err: orchErr}, &chaincfg.MainNetParams, nil)
 
@@ -115,19 +116,19 @@ func TestCoreWalletName(t *testing.T) {
 	orch := mocks.NewMockWalletManagerServiceClient(ctrl)
 	orch.EXPECT().
 		CreateBitcoinCoreWallet(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(_ any, req *connect.Request[orchpb.CreateBitcoinCoreWalletRequest]) (*connect.Response[orchpb.CreateBitcoinCoreWalletResponse], error) {
-			return connect.NewResponse(&orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_" + req.Msg.WalletId[:8]}), nil
+		DoAndReturn(func(_ any, req *orchpb.CreateBitcoinCoreWalletRequest) (*orchpb.CreateBitcoinCoreWalletResponse, error) {
+			return &orchpb.CreateBitcoinCoreWalletResponse{CoreWalletName: "wallet_" + req.WalletId[:8]}, nil
 		}).
 		AnyTimes()
 	orch.EXPECT().
 		ListWallets(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&orchpb.ListWalletsResponse{
+		Return(&orchpb.ListWalletsResponse{
 			Wallets: []*orchpb.WalletMetadata{
 				{Id: "deadbeefcafebabe", Name: "watch", WalletType: orchpb.WalletType_WALLET_TYPE_BITCOIN_CORE, WatchOnly: true},
 				{Id: "cafebabedeadbeef", Name: "seed", WalletType: orchpb.WalletType_WALLET_TYPE_BITCOIN_CORE},
 			},
 			ActiveWalletId: "cafebabedeadbeef",
-		}), nil).
+		}, nil).
 		AnyTimes()
 
 	e := NewWalletEngine(func(context.Context) (corerpc.BitcoinServiceClient, error) {
@@ -172,9 +173,9 @@ func TestGetStarterSeed(t *testing.T) {
 
 	t.Run("no starter wallet returns error", func(t *testing.T) {
 		engine, orch := newSeedTestEngine(t)
-		orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).Return(connect.NewResponse(&orchpb.ListWalletsResponse{
+		orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).Return(&orchpb.ListWalletsResponse{
 			Wallets: []*orchpb.WalletMetadata{{Id: "local"}},
-		}), nil)
+		}, nil)
 
 		seed, err := engine.GetStarterSeed(t.Context())
 		require.ErrorContains(t, err, "no starter wallet")
@@ -183,13 +184,13 @@ func TestGetStarterSeed(t *testing.T) {
 
 	t.Run("returns seed of starter, not first wallet", func(t *testing.T) {
 		engine, orch := newSeedTestEngine(t)
-		orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).Return(connect.NewResponse(&orchpb.ListWalletsResponse{
+		orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).Return(&orchpb.ListWalletsResponse{
 			Wallets: []*orchpb.WalletMetadata{{Id: "local"}, {Id: "starter", IsStarter: true}},
-		}), nil)
+		}, nil)
 		orch.EXPECT().GetWalletSeed(gomock.Any(), gomock.Any()).DoAndReturn(
-			func(_ any, req *connect.Request[orchpb.GetWalletSeedRequest]) (*connect.Response[orchpb.GetWalletSeedResponse], error) {
-				require.Equal(t, "starter", req.Msg.WalletId)
-				return connect.NewResponse(&orchpb.GetWalletSeedResponse{SeedHex: starterSeedHex}), nil
+			func(_ any, req *orchpb.GetWalletSeedRequest) (*orchpb.GetWalletSeedResponse, error) {
+				require.Equal(t, "starter", req.WalletId)
+				return &orchpb.GetWalletSeedResponse{SeedHex: starterSeedHex}, nil
 			})
 
 		seed, err := engine.GetStarterSeed(t.Context())
@@ -200,7 +201,7 @@ func TestGetStarterSeed(t *testing.T) {
 	t.Run("a canceled context reaches the orchestrator", func(t *testing.T) {
 		engine, orch := newSeedTestEngine(t)
 		orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).DoAndReturn(
-			func(ctx context.Context, _ *connect.Request[orchpb.ListWalletsRequest]) (*connect.Response[orchpb.ListWalletsResponse], error) {
+			func(ctx context.Context, _ *orchpb.ListWalletsRequest) (*orchpb.ListWalletsResponse, error) {
 				return nil, ctx.Err()
 			})
 
@@ -215,10 +216,10 @@ func TestGetWalletSeed(t *testing.T) {
 	t.Run("a wallet with no seed fails the precondition", func(t *testing.T) {
 		engine, orch := newSeedTestEngine(t)
 		orch.EXPECT().GetWalletSeed(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet watch holds no master seed")))
+			Return(nil, connectv2.NewError(connectv2.CodeFailedPrecondition, "wallet watch holds no master seed"))
 
 		_, err := engine.GetWalletSeed(t.Context(), "watch")
-		require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
+		require.Equal(t, connectv2.CodeFailedPrecondition, connectv2.CodeOf(err))
 	})
 
 	t.Run("orchestrator error does not fall back to local seed", func(t *testing.T) {
@@ -233,7 +234,7 @@ func TestGetWalletSeed(t *testing.T) {
 	t.Run("a canceled context reaches the orchestrator", func(t *testing.T) {
 		engine, orch := newSeedTestEngine(t)
 		orch.EXPECT().GetWalletSeed(gomock.Any(), gomock.Any()).DoAndReturn(
-			func(ctx context.Context, _ *connect.Request[orchpb.GetWalletSeedRequest]) (*connect.Response[orchpb.GetWalletSeedResponse], error) {
+			func(ctx context.Context, _ *orchpb.GetWalletSeedRequest) (*orchpb.GetWalletSeedResponse, error) {
 				return nil, ctx.Err()
 			})
 
@@ -246,13 +247,13 @@ func TestGetWalletSeed(t *testing.T) {
 
 func TestGetWalletInfo(t *testing.T) {
 	engine, orch := newSeedTestEngine(t)
-	orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).Return(connect.NewResponse(&orchpb.ListWalletsResponse{
+	orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).Return(&orchpb.ListWalletsResponse{
 		Wallets: []*orchpb.WalletMetadata{
 			{Id: "a", Name: "Alpha", WalletType: orchpb.WalletType_WALLET_TYPE_ELECTRUM},
 			{Id: "b", Name: "Beta", WalletType: orchpb.WalletType_WALLET_TYPE_BITCOIN_CORE, ScriptType: "taproot", AccountIndex: 3},
 		},
 		ActiveWalletId: "a",
-	}), nil).Times(3)
+	}, nil).Times(3)
 
 	info, err := engine.GetWalletInfo(t.Context(), "b")
 	require.NoError(t, err)
@@ -269,15 +270,15 @@ func TestGetWalletInfo(t *testing.T) {
 func TestGetWalletInfoWhileLocked(t *testing.T) {
 	engine, orch := newSeedTestEngine(t)
 	orch.EXPECT().ListWallets(gomock.Any(), gomock.Any()).
-		Return(connect.NewResponse(&orchpb.ListWalletsResponse{ActiveWalletId: "a"}), nil)
+		Return(&orchpb.ListWalletsResponse{ActiveWalletId: "a"}, nil)
 
 	_, err := engine.GetWalletInfo(t.Context(), "a")
 	require.ErrorContains(t, err, "no wallet is unlocked")
 }
 
 func TestWalletEngineLockState(t *testing.T) {
-	status := func(state orchpb.WalletState) *connect.Response[orchpb.GetWalletStatusResponse] {
-		return connect.NewResponse(&orchpb.GetWalletStatusResponse{State: state})
+	status := func(state orchpb.WalletState) *orchpb.GetWalletStatusResponse {
+		return &orchpb.GetWalletStatusResponse{State: state}
 	}
 
 	t.Run("the orchestrator state decides", func(t *testing.T) {
@@ -306,11 +307,11 @@ func TestWalletEngineLockState(t *testing.T) {
 	t.Run("unlock and lock go to the orchestrator", func(t *testing.T) {
 		engine, orch := newSeedTestEngine(t)
 		orch.EXPECT().UnlockWallet(gomock.Any(), gomock.Any()).DoAndReturn(
-			func(_ context.Context, req *connect.Request[orchpb.UnlockWalletRequest]) (*connect.Response[orchpb.UnlockWalletResponse], error) {
-				require.Equal(t, "hunter2", req.Msg.Password)
-				return connect.NewResponse(&orchpb.UnlockWalletResponse{}), nil
+			func(_ context.Context, req *orchpb.UnlockWalletRequest) (*orchpb.UnlockWalletResponse, error) {
+				require.Equal(t, "hunter2", req.Password)
+				return &orchpb.UnlockWalletResponse{}, nil
 			})
-		orch.EXPECT().LockWallet(gomock.Any(), gomock.Any()).Return(connect.NewResponse(&orchpb.LockWalletResponse{}), nil)
+		orch.EXPECT().LockWallet(gomock.Any(), gomock.Any()).Return(&orchpb.LockWalletResponse{}, nil)
 
 		require.NoError(t, engine.Unlock(t.Context(), "hunter2"))
 		require.NoError(t, engine.Lock(t.Context()))
@@ -319,9 +320,9 @@ func TestWalletEngineLockState(t *testing.T) {
 	t.Run("a wrong password keeps its code", func(t *testing.T) {
 		engine, orch := newSeedTestEngine(t)
 		orch.EXPECT().UnlockWallet(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnauthenticated, errors.New("incorrect password")))
+			Return(nil, connectv2.NewError(connectv2.CodeUnauthenticated, "incorrect password"))
 
 		err := engine.Unlock(t.Context(), "wrong")
-		require.Equal(t, connect.CodeUnauthenticated, connect.CodeOf(err))
+		require.Equal(t, connectv2.CodeUnauthenticated, connectv2.CodeOf(err))
 	})
 }
diff --git a/bitwindow/server/gen/bitdrive/v1/bitdrivev1connect/bitdrive.connect.go b/bitwindow/server/gen/bitdrive/v1/bitdrivev1connect/bitdrive.connect.go
index 9d27e34169..975f18adc3 100644
--- a/bitwindow/server/gen/bitdrive/v1/bitdrivev1connect/bitdrive.connect.go
+++ b/bitwindow/server/gen/bitdrive/v1/bitdrivev1connect/bitdrive.connect.go
@@ -5,417 +5,460 @@
 package bitdrivev1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/bitdrive/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BitDriveServiceName is the fully-qualified name of the BitDriveService service.
 	BitDriveServiceName = "bitdrive.v1.BitDriveService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BitDriveServiceStoreFileProcedure is the fully-qualified name of the BitDriveService's StoreFile
-	// RPC.
+	// BitDriveServiceStoreFileProcedure is the procedure name of the BitDriveService's StoreFile RPC.
 	BitDriveServiceStoreFileProcedure = "/bitdrive.v1.BitDriveService/StoreFile"
-	// BitDriveServiceRetrieveContentProcedure is the fully-qualified name of the BitDriveService's
+	// BitDriveServiceRetrieveContentProcedure is the procedure name of the BitDriveService's
 	// RetrieveContent RPC.
 	BitDriveServiceRetrieveContentProcedure = "/bitdrive.v1.BitDriveService/RetrieveContent"
-	// BitDriveServiceScanForFilesProcedure is the fully-qualified name of the BitDriveService's
-	// ScanForFiles RPC.
+	// BitDriveServiceScanForFilesProcedure is the procedure name of the BitDriveService's ScanForFiles
+	// RPC.
 	BitDriveServiceScanForFilesProcedure = "/bitdrive.v1.BitDriveService/ScanForFiles"
-	// BitDriveServiceDownloadPendingFilesProcedure is the fully-qualified name of the BitDriveService's
+	// BitDriveServiceDownloadPendingFilesProcedure is the procedure name of the BitDriveService's
 	// DownloadPendingFiles RPC.
 	BitDriveServiceDownloadPendingFilesProcedure = "/bitdrive.v1.BitDriveService/DownloadPendingFiles"
-	// BitDriveServiceListFilesProcedure is the fully-qualified name of the BitDriveService's ListFiles
-	// RPC.
+	// BitDriveServiceListFilesProcedure is the procedure name of the BitDriveService's ListFiles RPC.
 	BitDriveServiceListFilesProcedure = "/bitdrive.v1.BitDriveService/ListFiles"
-	// BitDriveServiceGetFileProcedure is the fully-qualified name of the BitDriveService's GetFile RPC.
+	// BitDriveServiceGetFileProcedure is the procedure name of the BitDriveService's GetFile RPC.
 	BitDriveServiceGetFileProcedure = "/bitdrive.v1.BitDriveService/GetFile"
-	// BitDriveServiceDeleteFileProcedure is the fully-qualified name of the BitDriveService's
-	// DeleteFile RPC.
+	// BitDriveServiceDeleteFileProcedure is the procedure name of the BitDriveService's DeleteFile RPC.
 	BitDriveServiceDeleteFileProcedure = "/bitdrive.v1.BitDriveService/DeleteFile"
-	// BitDriveServiceStoreMultisigDataProcedure is the fully-qualified name of the BitDriveService's
+	// BitDriveServiceStoreMultisigDataProcedure is the procedure name of the BitDriveService's
 	// StoreMultisigData RPC.
 	BitDriveServiceStoreMultisigDataProcedure = "/bitdrive.v1.BitDriveService/StoreMultisigData"
-	// BitDriveServiceWipeDataProcedure is the fully-qualified name of the BitDriveService's WipeData
-	// RPC.
+	// BitDriveServiceWipeDataProcedure is the procedure name of the BitDriveService's WipeData RPC.
 	BitDriveServiceWipeDataProcedure = "/bitdrive.v1.BitDriveService/WipeData"
-	// BitDriveServiceGetBitdriveDirProcedure is the fully-qualified name of the BitDriveService's
+	// BitDriveServiceGetBitdriveDirProcedure is the procedure name of the BitDriveService's
 	// GetBitdriveDir RPC.
 	BitDriveServiceGetBitdriveDirProcedure = "/bitdrive.v1.BitDriveService/GetBitdriveDir"
-	// BitDriveServiceOpenBitdriveDirProcedure is the fully-qualified name of the BitDriveService's
+	// BitDriveServiceOpenBitdriveDirProcedure is the procedure name of the BitDriveService's
 	// OpenBitdriveDir RPC.
 	BitDriveServiceOpenBitdriveDirProcedure = "/bitdrive.v1.BitDriveService/OpenBitdriveDir"
 )
 
+var (
+	bitDriveServiceStoreFileSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("StoreFile"),
+			Procedure:  BitDriveServiceStoreFileProcedure,
+		}
+	})
+	bitDriveServiceRetrieveContentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("RetrieveContent"),
+			Procedure:  BitDriveServiceRetrieveContentProcedure,
+		}
+	})
+	bitDriveServiceScanForFilesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("ScanForFiles"),
+			Procedure:  BitDriveServiceScanForFilesProcedure,
+		}
+	})
+	bitDriveServiceDownloadPendingFilesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("DownloadPendingFiles"),
+			Procedure:  BitDriveServiceDownloadPendingFilesProcedure,
+		}
+	})
+	bitDriveServiceListFilesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("ListFiles"),
+			Procedure:  BitDriveServiceListFilesProcedure,
+		}
+	})
+	bitDriveServiceGetFileSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("GetFile"),
+			Procedure:  BitDriveServiceGetFileProcedure,
+		}
+	})
+	bitDriveServiceDeleteFileSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("DeleteFile"),
+			Procedure:  BitDriveServiceDeleteFileProcedure,
+		}
+	})
+	bitDriveServiceStoreMultisigDataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("StoreMultisigData"),
+			Procedure:  BitDriveServiceStoreMultisigDataProcedure,
+		}
+	})
+	bitDriveServiceWipeDataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("WipeData"),
+			Procedure:  BitDriveServiceWipeDataProcedure,
+		}
+	})
+	bitDriveServiceGetBitdriveDirSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("GetBitdriveDir"),
+			Procedure:  BitDriveServiceGetBitdriveDirProcedure,
+		}
+	})
+	bitDriveServiceOpenBitdriveDirSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods().ByName("OpenBitdriveDir"),
+			Procedure:  BitDriveServiceOpenBitdriveDirProcedure,
+		}
+	})
+)
+
 // BitDriveServiceClient is a client for the bitdrive.v1.BitDriveService service.
 type BitDriveServiceClient interface {
-	// Store file/content to blockchain with optional encryption
-	StoreFile(context.Context, *connect.Request[v1.StoreFileRequest]) (*connect.Response[v1.StoreFileResponse], error)
-	// Retrieve content from blockchain by txid
-	RetrieveContent(context.Context, *connect.Request[v1.RetrieveContentRequest]) (*connect.Response[v1.RetrieveContentResponse], error)
-	// Scan for files in wallet transactions
-	ScanForFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ScanForFilesResponse], error)
-	// Download/restore pending files
-	DownloadPendingFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.DownloadPendingFilesResponse], error)
-	// List stored files from local storage
-	ListFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListFilesResponse], error)
-	// Get file details
-	GetFile(context.Context, *connect.Request[v1.GetFileRequest]) (*connect.Response[v1.GetFileResponse], error)
-	// Delete local file (does not affect blockchain)
-	DeleteFile(context.Context, *connect.Request[v1.DeleteFileRequest]) (*connect.Response[emptypb.Empty], error)
-	// Store multisig group data on blockchain
-	StoreMultisigData(context.Context, *connect.Request[v1.StoreMultisigDataRequest]) (*connect.Response[v1.StoreMultisigDataResponse], error)
-	// Wipe all local BitDrive data
-	WipeData(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	// Get the BitDrive data directory path
-	GetBitdriveDir(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetBitdriveDirResponse], error)
-	// Open the BitDrive data directory in the OS file manager
-	OpenBitdriveDir(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-}
-
-// NewBitDriveServiceClient constructs a client for the bitdrive.v1.BitDriveService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBitDriveServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BitDriveServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	bitDriveServiceMethods := v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods()
-	return &bitDriveServiceClient{
-		storeFile: connect.NewClient[v1.StoreFileRequest, v1.StoreFileResponse](
-			httpClient,
-			baseURL+BitDriveServiceStoreFileProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("StoreFile")),
-			connect.WithClientOptions(opts...),
-		),
-		retrieveContent: connect.NewClient[v1.RetrieveContentRequest, v1.RetrieveContentResponse](
-			httpClient,
-			baseURL+BitDriveServiceRetrieveContentProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("RetrieveContent")),
-			connect.WithClientOptions(opts...),
-		),
-		scanForFiles: connect.NewClient[emptypb.Empty, v1.ScanForFilesResponse](
-			httpClient,
-			baseURL+BitDriveServiceScanForFilesProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("ScanForFiles")),
-			connect.WithClientOptions(opts...),
-		),
-		downloadPendingFiles: connect.NewClient[emptypb.Empty, v1.DownloadPendingFilesResponse](
-			httpClient,
-			baseURL+BitDriveServiceDownloadPendingFilesProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("DownloadPendingFiles")),
-			connect.WithClientOptions(opts...),
-		),
-		listFiles: connect.NewClient[emptypb.Empty, v1.ListFilesResponse](
-			httpClient,
-			baseURL+BitDriveServiceListFilesProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("ListFiles")),
-			connect.WithClientOptions(opts...),
-		),
-		getFile: connect.NewClient[v1.GetFileRequest, v1.GetFileResponse](
-			httpClient,
-			baseURL+BitDriveServiceGetFileProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("GetFile")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteFile: connect.NewClient[v1.DeleteFileRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitDriveServiceDeleteFileProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("DeleteFile")),
-			connect.WithClientOptions(opts...),
-		),
-		storeMultisigData: connect.NewClient[v1.StoreMultisigDataRequest, v1.StoreMultisigDataResponse](
-			httpClient,
-			baseURL+BitDriveServiceStoreMultisigDataProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("StoreMultisigData")),
-			connect.WithClientOptions(opts...),
-		),
-		wipeData: connect.NewClient[emptypb.Empty, emptypb.Empty](
-			httpClient,
-			baseURL+BitDriveServiceWipeDataProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("WipeData")),
-			connect.WithClientOptions(opts...),
-		),
-		getBitdriveDir: connect.NewClient[emptypb.Empty, v1.GetBitdriveDirResponse](
-			httpClient,
-			baseURL+BitDriveServiceGetBitdriveDirProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("GetBitdriveDir")),
-			connect.WithClientOptions(opts...),
-		),
-		openBitdriveDir: connect.NewClient[emptypb.Empty, emptypb.Empty](
-			httpClient,
-			baseURL+BitDriveServiceOpenBitdriveDirProcedure,
-			connect.WithSchema(bitDriveServiceMethods.ByName("OpenBitdriveDir")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// bitDriveServiceClient implements BitDriveServiceClient.
-type bitDriveServiceClient struct {
-	storeFile            *connect.Client[v1.StoreFileRequest, v1.StoreFileResponse]
-	retrieveContent      *connect.Client[v1.RetrieveContentRequest, v1.RetrieveContentResponse]
-	scanForFiles         *connect.Client[emptypb.Empty, v1.ScanForFilesResponse]
-	downloadPendingFiles *connect.Client[emptypb.Empty, v1.DownloadPendingFilesResponse]
-	listFiles            *connect.Client[emptypb.Empty, v1.ListFilesResponse]
-	getFile              *connect.Client[v1.GetFileRequest, v1.GetFileResponse]
-	deleteFile           *connect.Client[v1.DeleteFileRequest, emptypb.Empty]
-	storeMultisigData    *connect.Client[v1.StoreMultisigDataRequest, v1.StoreMultisigDataResponse]
-	wipeData             *connect.Client[emptypb.Empty, emptypb.Empty]
-	getBitdriveDir       *connect.Client[emptypb.Empty, v1.GetBitdriveDirResponse]
-	openBitdriveDir      *connect.Client[emptypb.Empty, emptypb.Empty]
+	StoreFile(context.Context, *v1.StoreFileRequest) (*v1.StoreFileResponse, error)
+	RetrieveContent(context.Context, *v1.RetrieveContentRequest) (*v1.RetrieveContentResponse, error)
+	ScanForFiles(context.Context, *emptypb.Empty) (*v1.ScanForFilesResponse, error)
+	DownloadPendingFiles(context.Context, *emptypb.Empty) (*v1.DownloadPendingFilesResponse, error)
+	ListFiles(context.Context, *emptypb.Empty) (*v1.ListFilesResponse, error)
+	GetFile(context.Context, *v1.GetFileRequest) (*v1.GetFileResponse, error)
+	DeleteFile(context.Context, *v1.DeleteFileRequest) (*emptypb.Empty, error)
+	StoreMultisigData(context.Context, *v1.StoreMultisigDataRequest) (*v1.StoreMultisigDataResponse, error)
+	WipeData(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	GetBitdriveDir(context.Context, *emptypb.Empty) (*v1.GetBitdriveDirResponse, error)
+	OpenBitdriveDir(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
 }
 
-// StoreFile calls bitdrive.v1.BitDriveService.StoreFile.
-func (c *bitDriveServiceClient) StoreFile(ctx context.Context, req *connect.Request[v1.StoreFileRequest]) (*connect.Response[v1.StoreFileResponse], error) {
-	return c.storeFile.CallUnary(ctx, req)
+// NewBitDriveServiceClient constructs a client for the bitdrive.v1.BitDriveService service.
+// Multiple service clients may share a single connect.Client.
+func NewBitDriveServiceClient(client *connect.Client) BitDriveServiceClient {
+	return &bitDriveServiceClient{client: client}
 }
 
-// RetrieveContent calls bitdrive.v1.BitDriveService.RetrieveContent.
-func (c *bitDriveServiceClient) RetrieveContent(ctx context.Context, req *connect.Request[v1.RetrieveContentRequest]) (*connect.Response[v1.RetrieveContentResponse], error) {
-	return c.retrieveContent.CallUnary(ctx, req)
+// BitDriveServiceHandler is an implementation of the bitdrive.v1.BitDriveService service.
+type BitDriveServiceHandler interface {
+	StoreFile(context.Context, *v1.StoreFileRequest) (*v1.StoreFileResponse, error)
+	RetrieveContent(context.Context, *v1.RetrieveContentRequest) (*v1.RetrieveContentResponse, error)
+	ScanForFiles(context.Context, *emptypb.Empty) (*v1.ScanForFilesResponse, error)
+	DownloadPendingFiles(context.Context, *emptypb.Empty) (*v1.DownloadPendingFilesResponse, error)
+	ListFiles(context.Context, *emptypb.Empty) (*v1.ListFilesResponse, error)
+	GetFile(context.Context, *v1.GetFileRequest) (*v1.GetFileResponse, error)
+	DeleteFile(context.Context, *v1.DeleteFileRequest) (*emptypb.Empty, error)
+	StoreMultisigData(context.Context, *v1.StoreMultisigDataRequest) (*v1.StoreMultisigDataResponse, error)
+	WipeData(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	GetBitdriveDir(context.Context, *emptypb.Empty) (*v1.GetBitdriveDirResponse, error)
+	OpenBitdriveDir(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
 }
 
-// ScanForFiles calls bitdrive.v1.BitDriveService.ScanForFiles.
-func (c *bitDriveServiceClient) ScanForFiles(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ScanForFilesResponse], error) {
-	return c.scanForFiles.CallUnary(ctx, req)
+// RegisterBitDriveServiceHandler registers svc as the bitdrive.v1.BitDriveService implementation on
+// server.
+func RegisterBitDriveServiceHandler(server *connect.Server, svc BitDriveServiceHandler) {
+	adapter := bitDriveServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: bitDriveServiceStoreFileSpec(), Handler: adapter.storeFile},
+		connect.Method{Spec: bitDriveServiceRetrieveContentSpec(), Handler: adapter.retrieveContent},
+		connect.Method{Spec: bitDriveServiceScanForFilesSpec(), Handler: adapter.scanForFiles},
+		connect.Method{Spec: bitDriveServiceDownloadPendingFilesSpec(), Handler: adapter.downloadPendingFiles},
+		connect.Method{Spec: bitDriveServiceListFilesSpec(), Handler: adapter.listFiles},
+		connect.Method{Spec: bitDriveServiceGetFileSpec(), Handler: adapter.getFile},
+		connect.Method{Spec: bitDriveServiceDeleteFileSpec(), Handler: adapter.deleteFile},
+		connect.Method{Spec: bitDriveServiceStoreMultisigDataSpec(), Handler: adapter.storeMultisigData},
+		connect.Method{Spec: bitDriveServiceWipeDataSpec(), Handler: adapter.wipeData},
+		connect.Method{Spec: bitDriveServiceGetBitdriveDirSpec(), Handler: adapter.getBitdriveDir},
+		connect.Method{Spec: bitDriveServiceOpenBitdriveDirSpec(), Handler: adapter.openBitdriveDir},
+	)
 }
 
-// DownloadPendingFiles calls bitdrive.v1.BitDriveService.DownloadPendingFiles.
-func (c *bitDriveServiceClient) DownloadPendingFiles(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.DownloadPendingFilesResponse], error) {
-	return c.downloadPendingFiles.CallUnary(ctx, req)
+// UnimplementedBitDriveServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBitDriveServiceHandler struct{}
+
+func (UnimplementedBitDriveServiceHandler) StoreFile(context.Context, *v1.StoreFileRequest) (*v1.StoreFileResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.StoreFile is not implemented")
 }
 
-// ListFiles calls bitdrive.v1.BitDriveService.ListFiles.
-func (c *bitDriveServiceClient) ListFiles(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListFilesResponse], error) {
-	return c.listFiles.CallUnary(ctx, req)
+func (UnimplementedBitDriveServiceHandler) RetrieveContent(context.Context, *v1.RetrieveContentRequest) (*v1.RetrieveContentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.RetrieveContent is not implemented")
 }
 
-// GetFile calls bitdrive.v1.BitDriveService.GetFile.
-func (c *bitDriveServiceClient) GetFile(ctx context.Context, req *connect.Request[v1.GetFileRequest]) (*connect.Response[v1.GetFileResponse], error) {
-	return c.getFile.CallUnary(ctx, req)
+func (UnimplementedBitDriveServiceHandler) ScanForFiles(context.Context, *emptypb.Empty) (*v1.ScanForFilesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.ScanForFiles is not implemented")
 }
 
-// DeleteFile calls bitdrive.v1.BitDriveService.DeleteFile.
-func (c *bitDriveServiceClient) DeleteFile(ctx context.Context, req *connect.Request[v1.DeleteFileRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.deleteFile.CallUnary(ctx, req)
+func (UnimplementedBitDriveServiceHandler) DownloadPendingFiles(context.Context, *emptypb.Empty) (*v1.DownloadPendingFilesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.DownloadPendingFiles is not implemented")
 }
 
-// StoreMultisigData calls bitdrive.v1.BitDriveService.StoreMultisigData.
-func (c *bitDriveServiceClient) StoreMultisigData(ctx context.Context, req *connect.Request[v1.StoreMultisigDataRequest]) (*connect.Response[v1.StoreMultisigDataResponse], error) {
-	return c.storeMultisigData.CallUnary(ctx, req)
+func (UnimplementedBitDriveServiceHandler) ListFiles(context.Context, *emptypb.Empty) (*v1.ListFilesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.ListFiles is not implemented")
 }
 
-// WipeData calls bitdrive.v1.BitDriveService.WipeData.
-func (c *bitDriveServiceClient) WipeData(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return c.wipeData.CallUnary(ctx, req)
+func (UnimplementedBitDriveServiceHandler) GetFile(context.Context, *v1.GetFileRequest) (*v1.GetFileResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.GetFile is not implemented")
 }
 
-// GetBitdriveDir calls bitdrive.v1.BitDriveService.GetBitdriveDir.
-func (c *bitDriveServiceClient) GetBitdriveDir(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetBitdriveDirResponse], error) {
-	return c.getBitdriveDir.CallUnary(ctx, req)
+func (UnimplementedBitDriveServiceHandler) DeleteFile(context.Context, *v1.DeleteFileRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.DeleteFile is not implemented")
 }
 
-// OpenBitdriveDir calls bitdrive.v1.BitDriveService.OpenBitdriveDir.
-func (c *bitDriveServiceClient) OpenBitdriveDir(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return c.openBitdriveDir.CallUnary(ctx, req)
+func (UnimplementedBitDriveServiceHandler) StoreMultisigData(context.Context, *v1.StoreMultisigDataRequest) (*v1.StoreMultisigDataResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.StoreMultisigData is not implemented")
 }
 
-// BitDriveServiceHandler is an implementation of the bitdrive.v1.BitDriveService service.
-type BitDriveServiceHandler interface {
-	// Store file/content to blockchain with optional encryption
-	StoreFile(context.Context, *connect.Request[v1.StoreFileRequest]) (*connect.Response[v1.StoreFileResponse], error)
-	// Retrieve content from blockchain by txid
-	RetrieveContent(context.Context, *connect.Request[v1.RetrieveContentRequest]) (*connect.Response[v1.RetrieveContentResponse], error)
-	// Scan for files in wallet transactions
-	ScanForFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ScanForFilesResponse], error)
-	// Download/restore pending files
-	DownloadPendingFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.DownloadPendingFilesResponse], error)
-	// List stored files from local storage
-	ListFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListFilesResponse], error)
-	// Get file details
-	GetFile(context.Context, *connect.Request[v1.GetFileRequest]) (*connect.Response[v1.GetFileResponse], error)
-	// Delete local file (does not affect blockchain)
-	DeleteFile(context.Context, *connect.Request[v1.DeleteFileRequest]) (*connect.Response[emptypb.Empty], error)
-	// Store multisig group data on blockchain
-	StoreMultisigData(context.Context, *connect.Request[v1.StoreMultisigDataRequest]) (*connect.Response[v1.StoreMultisigDataResponse], error)
-	// Wipe all local BitDrive data
-	WipeData(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	// Get the BitDrive data directory path
-	GetBitdriveDir(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetBitdriveDirResponse], error)
-	// Open the BitDrive data directory in the OS file manager
-	OpenBitdriveDir(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-}
-
-// NewBitDriveServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBitDriveServiceHandler(svc BitDriveServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	bitDriveServiceMethods := v1.File_bitdrive_v1_bitdrive_proto.Services().ByName("BitDriveService").Methods()
-	bitDriveServiceStoreFileHandler := connect.NewUnaryHandler(
-		BitDriveServiceStoreFileProcedure,
-		svc.StoreFile,
-		connect.WithSchema(bitDriveServiceMethods.ByName("StoreFile")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceRetrieveContentHandler := connect.NewUnaryHandler(
-		BitDriveServiceRetrieveContentProcedure,
-		svc.RetrieveContent,
-		connect.WithSchema(bitDriveServiceMethods.ByName("RetrieveContent")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceScanForFilesHandler := connect.NewUnaryHandler(
-		BitDriveServiceScanForFilesProcedure,
-		svc.ScanForFiles,
-		connect.WithSchema(bitDriveServiceMethods.ByName("ScanForFiles")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceDownloadPendingFilesHandler := connect.NewUnaryHandler(
-		BitDriveServiceDownloadPendingFilesProcedure,
-		svc.DownloadPendingFiles,
-		connect.WithSchema(bitDriveServiceMethods.ByName("DownloadPendingFiles")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceListFilesHandler := connect.NewUnaryHandler(
-		BitDriveServiceListFilesProcedure,
-		svc.ListFiles,
-		connect.WithSchema(bitDriveServiceMethods.ByName("ListFiles")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceGetFileHandler := connect.NewUnaryHandler(
-		BitDriveServiceGetFileProcedure,
-		svc.GetFile,
-		connect.WithSchema(bitDriveServiceMethods.ByName("GetFile")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceDeleteFileHandler := connect.NewUnaryHandler(
-		BitDriveServiceDeleteFileProcedure,
-		svc.DeleteFile,
-		connect.WithSchema(bitDriveServiceMethods.ByName("DeleteFile")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceStoreMultisigDataHandler := connect.NewUnaryHandler(
-		BitDriveServiceStoreMultisigDataProcedure,
-		svc.StoreMultisigData,
-		connect.WithSchema(bitDriveServiceMethods.ByName("StoreMultisigData")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceWipeDataHandler := connect.NewUnaryHandler(
-		BitDriveServiceWipeDataProcedure,
-		svc.WipeData,
-		connect.WithSchema(bitDriveServiceMethods.ByName("WipeData")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceGetBitdriveDirHandler := connect.NewUnaryHandler(
-		BitDriveServiceGetBitdriveDirProcedure,
-		svc.GetBitdriveDir,
-		connect.WithSchema(bitDriveServiceMethods.ByName("GetBitdriveDir")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitDriveServiceOpenBitdriveDirHandler := connect.NewUnaryHandler(
-		BitDriveServiceOpenBitdriveDirProcedure,
-		svc.OpenBitdriveDir,
-		connect.WithSchema(bitDriveServiceMethods.ByName("OpenBitdriveDir")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/bitdrive.v1.BitDriveService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BitDriveServiceStoreFileProcedure:
-			bitDriveServiceStoreFileHandler.ServeHTTP(w, r)
-		case BitDriveServiceRetrieveContentProcedure:
-			bitDriveServiceRetrieveContentHandler.ServeHTTP(w, r)
-		case BitDriveServiceScanForFilesProcedure:
-			bitDriveServiceScanForFilesHandler.ServeHTTP(w, r)
-		case BitDriveServiceDownloadPendingFilesProcedure:
-			bitDriveServiceDownloadPendingFilesHandler.ServeHTTP(w, r)
-		case BitDriveServiceListFilesProcedure:
-			bitDriveServiceListFilesHandler.ServeHTTP(w, r)
-		case BitDriveServiceGetFileProcedure:
-			bitDriveServiceGetFileHandler.ServeHTTP(w, r)
-		case BitDriveServiceDeleteFileProcedure:
-			bitDriveServiceDeleteFileHandler.ServeHTTP(w, r)
-		case BitDriveServiceStoreMultisigDataProcedure:
-			bitDriveServiceStoreMultisigDataHandler.ServeHTTP(w, r)
-		case BitDriveServiceWipeDataProcedure:
-			bitDriveServiceWipeDataHandler.ServeHTTP(w, r)
-		case BitDriveServiceGetBitdriveDirProcedure:
-			bitDriveServiceGetBitdriveDirHandler.ServeHTTP(w, r)
-		case BitDriveServiceOpenBitdriveDirProcedure:
-			bitDriveServiceOpenBitdriveDirHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedBitDriveServiceHandler) WipeData(context.Context, *emptypb.Empty) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.WipeData is not implemented")
 }
 
-// UnimplementedBitDriveServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBitDriveServiceHandler struct{}
+func (UnimplementedBitDriveServiceHandler) GetBitdriveDir(context.Context, *emptypb.Empty) (*v1.GetBitdriveDirResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.GetBitdriveDir is not implemented")
+}
 
-func (UnimplementedBitDriveServiceHandler) StoreFile(context.Context, *connect.Request[v1.StoreFileRequest]) (*connect.Response[v1.StoreFileResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.StoreFile is not implemented"))
+func (UnimplementedBitDriveServiceHandler) OpenBitdriveDir(context.Context, *emptypb.Empty) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitdrive.v1.BitDriveService.OpenBitdriveDir is not implemented")
 }
 
-func (UnimplementedBitDriveServiceHandler) RetrieveContent(context.Context, *connect.Request[v1.RetrieveContentRequest]) (*connect.Response[v1.RetrieveContentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.RetrieveContent is not implemented"))
+type bitDriveServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedBitDriveServiceHandler) ScanForFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ScanForFilesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.ScanForFiles is not implemented"))
+func (c *bitDriveServiceClient) StoreFile(ctx context.Context, req *v1.StoreFileRequest) (*v1.StoreFileResponse, error) {
+	var res v1.StoreFileResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceStoreFileSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitDriveServiceHandler) DownloadPendingFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.DownloadPendingFilesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.DownloadPendingFiles is not implemented"))
+func (c *bitDriveServiceClient) RetrieveContent(ctx context.Context, req *v1.RetrieveContentRequest) (*v1.RetrieveContentResponse, error) {
+	var res v1.RetrieveContentResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceRetrieveContentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitDriveServiceHandler) ListFiles(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListFilesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.ListFiles is not implemented"))
+func (c *bitDriveServiceClient) ScanForFiles(ctx context.Context, req *emptypb.Empty) (*v1.ScanForFilesResponse, error) {
+	var res v1.ScanForFilesResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceScanForFilesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) DownloadPendingFiles(ctx context.Context, req *emptypb.Empty) (*v1.DownloadPendingFilesResponse, error) {
+	var res v1.DownloadPendingFilesResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceDownloadPendingFilesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) ListFiles(ctx context.Context, req *emptypb.Empty) (*v1.ListFilesResponse, error) {
+	var res v1.ListFilesResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceListFilesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) GetFile(ctx context.Context, req *v1.GetFileRequest) (*v1.GetFileResponse, error) {
+	var res v1.GetFileResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceGetFileSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) DeleteFile(ctx context.Context, req *v1.DeleteFileRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitDriveServiceDeleteFileSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) StoreMultisigData(ctx context.Context, req *v1.StoreMultisigDataRequest) (*v1.StoreMultisigDataResponse, error) {
+	var res v1.StoreMultisigDataResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceStoreMultisigDataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) WipeData(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitDriveServiceWipeDataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) GetBitdriveDir(ctx context.Context, req *emptypb.Empty) (*v1.GetBitdriveDirResponse, error) {
+	var res v1.GetBitdriveDirResponse
+	if err := c.client.CallUnary(ctx, bitDriveServiceGetBitdriveDirSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitDriveServiceClient) OpenBitdriveDir(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitDriveServiceOpenBitdriveDirSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type bitDriveServiceHandler struct{ svc BitDriveServiceHandler }
+
+func (h bitDriveServiceHandler) storeFile(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StoreFileRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StoreFile(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitDriveServiceHandler) GetFile(context.Context, *connect.Request[v1.GetFileRequest]) (*connect.Response[v1.GetFileResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.GetFile is not implemented"))
+func (h bitDriveServiceHandler) retrieveContent(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RetrieveContentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RetrieveContent(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitDriveServiceHandler) DeleteFile(context.Context, *connect.Request[v1.DeleteFileRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.DeleteFile is not implemented"))
+func (h bitDriveServiceHandler) scanForFiles(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ScanForFiles(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitDriveServiceHandler) StoreMultisigData(context.Context, *connect.Request[v1.StoreMultisigDataRequest]) (*connect.Response[v1.StoreMultisigDataResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.StoreMultisigData is not implemented"))
+func (h bitDriveServiceHandler) downloadPendingFiles(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DownloadPendingFiles(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitDriveServiceHandler) WipeData(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.WipeData is not implemented"))
+func (h bitDriveServiceHandler) listFiles(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListFiles(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitDriveServiceHandler) GetBitdriveDir(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetBitdriveDirResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.GetBitdriveDir is not implemented"))
+func (h bitDriveServiceHandler) getFile(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetFileRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetFile(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitDriveServiceHandler) deleteFile(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteFileRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeleteFile(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitDriveServiceHandler) OpenBitdriveDir(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitdrive.v1.BitDriveService.OpenBitdriveDir is not implemented"))
+func (h bitDriveServiceHandler) storeMultisigData(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StoreMultisigDataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StoreMultisigData(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitDriveServiceHandler) wipeData(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.WipeData(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitDriveServiceHandler) getBitdriveDir(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBitdriveDir(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitDriveServiceHandler) openBitdriveDir(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.OpenBitdriveDir(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/bitwindowd/v1/bitwindowdv1connect/bitwindowd.connect.go b/bitwindow/server/gen/bitwindowd/v1/bitwindowdv1connect/bitwindowd.connect.go
index 1798423bfe..5be2629605 100644
--- a/bitwindow/server/gen/bitwindowd/v1/bitwindowdv1connect/bitwindowd.connect.go
+++ b/bitwindow/server/gen/bitwindowd/v1/bitwindowdv1connect/bitwindowd.connect.go
@@ -5,820 +5,945 @@
 package bitwindowdv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/bitwindowd/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BitwindowdServiceName is the fully-qualified name of the BitwindowdService service.
 	BitwindowdServiceName = "bitwindowd.v1.BitwindowdService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BitwindowdServiceStopProcedure is the fully-qualified name of the BitwindowdService's Stop RPC.
+	// BitwindowdServiceStopProcedure is the procedure name of the BitwindowdService's Stop RPC.
 	BitwindowdServiceStopProcedure = "/bitwindowd.v1.BitwindowdService/Stop"
-	// BitwindowdServiceCreateDenialProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceCreateDenialProcedure is the procedure name of the BitwindowdService's
 	// CreateDenial RPC.
 	BitwindowdServiceCreateDenialProcedure = "/bitwindowd.v1.BitwindowdService/CreateDenial"
-	// BitwindowdServiceCancelDenialProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceCancelDenialProcedure is the procedure name of the BitwindowdService's
 	// CancelDenial RPC.
 	BitwindowdServiceCancelDenialProcedure = "/bitwindowd.v1.BitwindowdService/CancelDenial"
-	// BitwindowdServicePauseDenialProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServicePauseDenialProcedure is the procedure name of the BitwindowdService's
 	// PauseDenial RPC.
 	BitwindowdServicePauseDenialProcedure = "/bitwindowd.v1.BitwindowdService/PauseDenial"
-	// BitwindowdServiceResumeDenialProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceResumeDenialProcedure is the procedure name of the BitwindowdService's
 	// ResumeDenial RPC.
 	BitwindowdServiceResumeDenialProcedure = "/bitwindowd.v1.BitwindowdService/ResumeDenial"
-	// BitwindowdServiceCreateAddressBookEntryProcedure is the fully-qualified name of the
-	// BitwindowdService's CreateAddressBookEntry RPC.
+	// BitwindowdServiceCreateAddressBookEntryProcedure is the procedure name of the BitwindowdService's
+	// CreateAddressBookEntry RPC.
 	BitwindowdServiceCreateAddressBookEntryProcedure = "/bitwindowd.v1.BitwindowdService/CreateAddressBookEntry"
-	// BitwindowdServiceListAddressBookProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceListAddressBookProcedure is the procedure name of the BitwindowdService's
 	// ListAddressBook RPC.
 	BitwindowdServiceListAddressBookProcedure = "/bitwindowd.v1.BitwindowdService/ListAddressBook"
-	// BitwindowdServiceUpdateAddressBookEntryProcedure is the fully-qualified name of the
-	// BitwindowdService's UpdateAddressBookEntry RPC.
+	// BitwindowdServiceUpdateAddressBookEntryProcedure is the procedure name of the BitwindowdService's
+	// UpdateAddressBookEntry RPC.
 	BitwindowdServiceUpdateAddressBookEntryProcedure = "/bitwindowd.v1.BitwindowdService/UpdateAddressBookEntry"
-	// BitwindowdServiceDeleteAddressBookEntryProcedure is the fully-qualified name of the
-	// BitwindowdService's DeleteAddressBookEntry RPC.
+	// BitwindowdServiceDeleteAddressBookEntryProcedure is the procedure name of the BitwindowdService's
+	// DeleteAddressBookEntry RPC.
 	BitwindowdServiceDeleteAddressBookEntryProcedure = "/bitwindowd.v1.BitwindowdService/DeleteAddressBookEntry"
-	// BitwindowdServiceGetSyncInfoProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceGetSyncInfoProcedure is the procedure name of the BitwindowdService's
 	// GetSyncInfo RPC.
 	BitwindowdServiceGetSyncInfoProcedure = "/bitwindowd.v1.BitwindowdService/GetSyncInfo"
-	// BitwindowdServiceSetTransactionNoteProcedure is the fully-qualified name of the
-	// BitwindowdService's SetTransactionNote RPC.
+	// BitwindowdServiceSetTransactionNoteProcedure is the procedure name of the BitwindowdService's
+	// SetTransactionNote RPC.
 	BitwindowdServiceSetTransactionNoteProcedure = "/bitwindowd.v1.BitwindowdService/SetTransactionNote"
-	// BitwindowdServiceExportLabelsProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceExportLabelsProcedure is the procedure name of the BitwindowdService's
 	// ExportLabels RPC.
 	BitwindowdServiceExportLabelsProcedure = "/bitwindowd.v1.BitwindowdService/ExportLabels"
-	// BitwindowdServiceImportLabelsProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceImportLabelsProcedure is the procedure name of the BitwindowdService's
 	// ImportLabels RPC.
 	BitwindowdServiceImportLabelsProcedure = "/bitwindowd.v1.BitwindowdService/ImportLabels"
-	// BitwindowdServiceGetFireplaceStatsProcedure is the fully-qualified name of the
-	// BitwindowdService's GetFireplaceStats RPC.
+	// BitwindowdServiceGetFireplaceStatsProcedure is the procedure name of the BitwindowdService's
+	// GetFireplaceStats RPC.
 	BitwindowdServiceGetFireplaceStatsProcedure = "/bitwindowd.v1.BitwindowdService/GetFireplaceStats"
-	// BitwindowdServiceListRecentTransactionsProcedure is the fully-qualified name of the
-	// BitwindowdService's ListRecentTransactions RPC.
+	// BitwindowdServiceListRecentTransactionsProcedure is the procedure name of the BitwindowdService's
+	// ListRecentTransactions RPC.
 	BitwindowdServiceListRecentTransactionsProcedure = "/bitwindowd.v1.BitwindowdService/ListRecentTransactions"
-	// BitwindowdServiceListBlocksProcedure is the fully-qualified name of the BitwindowdService's
-	// ListBlocks RPC.
+	// BitwindowdServiceListBlocksProcedure is the procedure name of the BitwindowdService's ListBlocks
+	// RPC.
 	BitwindowdServiceListBlocksProcedure = "/bitwindowd.v1.BitwindowdService/ListBlocks"
-	// BitwindowdServiceGetNetworkStatsProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceGetNetworkStatsProcedure is the procedure name of the BitwindowdService's
 	// GetNetworkStats RPC.
 	BitwindowdServiceGetNetworkStatsProcedure = "/bitwindowd.v1.BitwindowdService/GetNetworkStats"
-	// BitwindowdServiceSetMempoolWatchProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceSetMempoolWatchProcedure is the procedure name of the BitwindowdService's
 	// SetMempoolWatch RPC.
 	BitwindowdServiceSetMempoolWatchProcedure = "/bitwindowd.v1.BitwindowdService/SetMempoolWatch"
-	// BitwindowdServiceResetMempoolWatchProcedure is the fully-qualified name of the
-	// BitwindowdService's ResetMempoolWatch RPC.
+	// BitwindowdServiceResetMempoolWatchProcedure is the procedure name of the BitwindowdService's
+	// ResetMempoolWatch RPC.
 	BitwindowdServiceResetMempoolWatchProcedure = "/bitwindowd.v1.BitwindowdService/ResetMempoolWatch"
-	// BitwindowdServiceGetMempoolWatchStatusProcedure is the fully-qualified name of the
-	// BitwindowdService's GetMempoolWatchStatus RPC.
+	// BitwindowdServiceGetMempoolWatchStatusProcedure is the procedure name of the BitwindowdService's
+	// GetMempoolWatchStatus RPC.
 	BitwindowdServiceGetMempoolWatchStatusProcedure = "/bitwindowd.v1.BitwindowdService/GetMempoolWatchStatus"
-	// BitwindowdServiceListMempoolTransactionsProcedure is the fully-qualified name of the
+	// BitwindowdServiceListMempoolTransactionsProcedure is the procedure name of the
 	// BitwindowdService's ListMempoolTransactions RPC.
 	BitwindowdServiceListMempoolTransactionsProcedure = "/bitwindowd.v1.BitwindowdService/ListMempoolTransactions"
-	// BitwindowdServiceListBlockStatsProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceListBlockStatsProcedure is the procedure name of the BitwindowdService's
 	// ListBlockStats RPC.
 	BitwindowdServiceListBlockStatsProcedure = "/bitwindowd.v1.BitwindowdService/ListBlockStats"
-	// BitwindowdServiceListMiningPoolsProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceListMiningPoolsProcedure is the procedure name of the BitwindowdService's
 	// ListMiningPools RPC.
 	BitwindowdServiceListMiningPoolsProcedure = "/bitwindowd.v1.BitwindowdService/ListMiningPools"
-	// BitwindowdServiceUpdateNetworkProcedure is the fully-qualified name of the BitwindowdService's
+	// BitwindowdServiceUpdateNetworkProcedure is the procedure name of the BitwindowdService's
 	// UpdateNetwork RPC.
 	BitwindowdServiceUpdateNetworkProcedure = "/bitwindowd.v1.BitwindowdService/UpdateNetwork"
 )
 
+var (
+	bitwindowdServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("Stop"),
+			Procedure:  BitwindowdServiceStopProcedure,
+		}
+	})
+	bitwindowdServiceCreateDenialSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("CreateDenial"),
+			Procedure:  BitwindowdServiceCreateDenialProcedure,
+		}
+	})
+	bitwindowdServiceCancelDenialSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("CancelDenial"),
+			Procedure:  BitwindowdServiceCancelDenialProcedure,
+		}
+	})
+	bitwindowdServicePauseDenialSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("PauseDenial"),
+			Procedure:  BitwindowdServicePauseDenialProcedure,
+		}
+	})
+	bitwindowdServiceResumeDenialSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ResumeDenial"),
+			Procedure:  BitwindowdServiceResumeDenialProcedure,
+		}
+	})
+	bitwindowdServiceCreateAddressBookEntrySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("CreateAddressBookEntry"),
+			Procedure:  BitwindowdServiceCreateAddressBookEntryProcedure,
+		}
+	})
+	bitwindowdServiceListAddressBookSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ListAddressBook"),
+			Procedure:  BitwindowdServiceListAddressBookProcedure,
+		}
+	})
+	bitwindowdServiceUpdateAddressBookEntrySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("UpdateAddressBookEntry"),
+			Procedure:  BitwindowdServiceUpdateAddressBookEntryProcedure,
+		}
+	})
+	bitwindowdServiceDeleteAddressBookEntrySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("DeleteAddressBookEntry"),
+			Procedure:  BitwindowdServiceDeleteAddressBookEntryProcedure,
+		}
+	})
+	bitwindowdServiceGetSyncInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("GetSyncInfo"),
+			Procedure:  BitwindowdServiceGetSyncInfoProcedure,
+		}
+	})
+	bitwindowdServiceSetTransactionNoteSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("SetTransactionNote"),
+			Procedure:  BitwindowdServiceSetTransactionNoteProcedure,
+		}
+	})
+	bitwindowdServiceExportLabelsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ExportLabels"),
+			Procedure:  BitwindowdServiceExportLabelsProcedure,
+		}
+	})
+	bitwindowdServiceImportLabelsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ImportLabels"),
+			Procedure:  BitwindowdServiceImportLabelsProcedure,
+		}
+	})
+	bitwindowdServiceGetFireplaceStatsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("GetFireplaceStats"),
+			Procedure:  BitwindowdServiceGetFireplaceStatsProcedure,
+		}
+	})
+	bitwindowdServiceListRecentTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ListRecentTransactions"),
+			Procedure:  BitwindowdServiceListRecentTransactionsProcedure,
+		}
+	})
+	bitwindowdServiceListBlocksSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ListBlocks"),
+			Procedure:  BitwindowdServiceListBlocksProcedure,
+		}
+	})
+	bitwindowdServiceGetNetworkStatsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("GetNetworkStats"),
+			Procedure:  BitwindowdServiceGetNetworkStatsProcedure,
+		}
+	})
+	bitwindowdServiceSetMempoolWatchSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("SetMempoolWatch"),
+			Procedure:  BitwindowdServiceSetMempoolWatchProcedure,
+		}
+	})
+	bitwindowdServiceResetMempoolWatchSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ResetMempoolWatch"),
+			Procedure:  BitwindowdServiceResetMempoolWatchProcedure,
+		}
+	})
+	bitwindowdServiceGetMempoolWatchStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("GetMempoolWatchStatus"),
+			Procedure:  BitwindowdServiceGetMempoolWatchStatusProcedure,
+		}
+	})
+	bitwindowdServiceListMempoolTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ListMempoolTransactions"),
+			Procedure:  BitwindowdServiceListMempoolTransactionsProcedure,
+		}
+	})
+	bitwindowdServiceListBlockStatsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ListBlockStats"),
+			Procedure:  BitwindowdServiceListBlockStatsProcedure,
+		}
+	})
+	bitwindowdServiceListMiningPoolsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("ListMiningPools"),
+			Procedure:  BitwindowdServiceListMiningPoolsProcedure,
+		}
+	})
+	bitwindowdServiceUpdateNetworkSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods().ByName("UpdateNetwork"),
+			Procedure:  BitwindowdServiceUpdateNetworkProcedure,
+		}
+	})
+)
+
 // BitwindowdServiceClient is a client for the bitwindowd.v1.BitwindowdService service.
 type BitwindowdServiceClient interface {
-	// Window-close + clean exit. Relays to orchestratord.Shutdown (which is
-	// detached and drains bitcoind/enforcer over ~90s in the background), then
-	// tears down bitwindowd itself. Acks fast so the Flutter window can destroy
-	// immediately. Pass skip_downstream=true to leave the orchestratord stack
-	// running (only bitwindowd dies).
-	Stop(context.Context, *connect.Request[v1.BitwindowdServiceStopRequest]) (*connect.Response[emptypb.Empty], error)
-	// Deniability operations
-	CreateDenial(context.Context, *connect.Request[v1.CreateDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	CancelDenial(context.Context, *connect.Request[v1.CancelDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	PauseDenial(context.Context, *connect.Request[v1.PauseDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	ResumeDenial(context.Context, *connect.Request[v1.ResumeDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	// Wallet operations
-	CreateAddressBookEntry(context.Context, *connect.Request[v1.CreateAddressBookEntryRequest]) (*connect.Response[v1.CreateAddressBookEntryResponse], error)
-	ListAddressBook(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListAddressBookResponse], error)
-	UpdateAddressBookEntry(context.Context, *connect.Request[v1.UpdateAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error)
-	DeleteAddressBookEntry(context.Context, *connect.Request[v1.DeleteAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error)
-	GetSyncInfo(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetSyncInfoResponse], error)
-	SetTransactionNote(context.Context, *connect.Request[v1.SetTransactionNoteRequest]) (*connect.Response[emptypb.Empty], error)
-	// BIP329 label import/export. ExportLabels emits one JSONL object per
-	// labelled item (address book, tx note, UTXO label). ImportLabels parses
-	// BIP329 JSONL and writes into the matching store, skipping unknown or
-	// malformed lines.
-	ExportLabels(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ExportLabelsResponse], error)
-	ImportLabels(context.Context, *connect.Request[v1.ImportLabelsRequest]) (*connect.Response[v1.ImportLabelsResponse], error)
-	GetFireplaceStats(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetFireplaceStatsResponse], error)
-	// Lists the most recent transactions, both confirmed and unconfirmed.
-	ListRecentTransactions(context.Context, *connect.Request[v1.ListRecentTransactionsRequest]) (*connect.Response[v1.ListRecentTransactionsResponse], error)
-	// Lists blocks with pagination support
-	ListBlocks(context.Context, *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error)
-	// Get network statistics
-	GetNetworkStats(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetNetworkStatsResponse], error)
-	// Mempool watch: records every tx in the mempool and how long it has waited.
-	SetMempoolWatch(context.Context, *connect.Request[v1.SetMempoolWatchRequest]) (*connect.Response[emptypb.Empty], error)
-	// Forgets everything recorded and starts over from the current mempool.
-	ResetMempoolWatch(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	GetMempoolWatchStatus(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetMempoolWatchStatusResponse], error)
-	ListMempoolTransactions(context.Context, *connect.Request[v1.ListMempoolTransactionsRequest]) (*connect.Response[v1.ListMempoolTransactionsResponse], error)
-	ListBlockStats(context.Context, *connect.Request[v1.ListBlockStatsRequest]) (*connect.Response[v1.ListBlockStatsResponse], error)
-	// Mining pools: which pools mined the recent blocks.
-	ListMiningPools(context.Context, *connect.Request[v1.ListMiningPoolsRequest]) (*connect.Response[v1.ListMiningPoolsResponse], error)
-	// Swap bitcoind network. bitwindowd is the entry point so the DB swap
-	// (network-scoped folder) is co-located with the orchestrator update.
-	// Implementation: forward to orchestratord's SetBitcoinConfigNetwork
-	// (which rewrites bitcoin.conf and restarts bitcoind on the new chain),
-	// then exit so the launcher restarts bitwindowd with a fresh DB scoped
-	// to the new network. Returns once orchestratord acknowledges the swap;
-	// the bitwindowd process exit happens shortly after.
-	UpdateNetwork(context.Context, *connect.Request[v1.UpdateNetworkRequest]) (*connect.Response[v1.UpdateNetworkResponse], error)
+	Stop(context.Context, *v1.BitwindowdServiceStopRequest) (*emptypb.Empty, error)
+	CreateDenial(context.Context, *v1.CreateDenialRequest) (*emptypb.Empty, error)
+	CancelDenial(context.Context, *v1.CancelDenialRequest) (*emptypb.Empty, error)
+	PauseDenial(context.Context, *v1.PauseDenialRequest) (*emptypb.Empty, error)
+	ResumeDenial(context.Context, *v1.ResumeDenialRequest) (*emptypb.Empty, error)
+	CreateAddressBookEntry(context.Context, *v1.CreateAddressBookEntryRequest) (*v1.CreateAddressBookEntryResponse, error)
+	ListAddressBook(context.Context, *emptypb.Empty) (*v1.ListAddressBookResponse, error)
+	UpdateAddressBookEntry(context.Context, *v1.UpdateAddressBookEntryRequest) (*emptypb.Empty, error)
+	DeleteAddressBookEntry(context.Context, *v1.DeleteAddressBookEntryRequest) (*emptypb.Empty, error)
+	GetSyncInfo(context.Context, *emptypb.Empty) (*v1.GetSyncInfoResponse, error)
+	SetTransactionNote(context.Context, *v1.SetTransactionNoteRequest) (*emptypb.Empty, error)
+	ExportLabels(context.Context, *emptypb.Empty) (*v1.ExportLabelsResponse, error)
+	ImportLabels(context.Context, *v1.ImportLabelsRequest) (*v1.ImportLabelsResponse, error)
+	GetFireplaceStats(context.Context, *emptypb.Empty) (*v1.GetFireplaceStatsResponse, error)
+	ListRecentTransactions(context.Context, *v1.ListRecentTransactionsRequest) (*v1.ListRecentTransactionsResponse, error)
+	ListBlocks(context.Context, *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error)
+	GetNetworkStats(context.Context, *emptypb.Empty) (*v1.GetNetworkStatsResponse, error)
+	SetMempoolWatch(context.Context, *v1.SetMempoolWatchRequest) (*emptypb.Empty, error)
+	ResetMempoolWatch(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	GetMempoolWatchStatus(context.Context, *emptypb.Empty) (*v1.GetMempoolWatchStatusResponse, error)
+	ListMempoolTransactions(context.Context, *v1.ListMempoolTransactionsRequest) (*v1.ListMempoolTransactionsResponse, error)
+	ListBlockStats(context.Context, *v1.ListBlockStatsRequest) (*v1.ListBlockStatsResponse, error)
+	ListMiningPools(context.Context, *v1.ListMiningPoolsRequest) (*v1.ListMiningPoolsResponse, error)
+	UpdateNetwork(context.Context, *v1.UpdateNetworkRequest) (*v1.UpdateNetworkResponse, error)
 }
 
 // NewBitwindowdServiceClient constructs a client for the bitwindowd.v1.BitwindowdService service.
-// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped
-// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBitwindowdServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BitwindowdServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	bitwindowdServiceMethods := v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods()
-	return &bitwindowdServiceClient{
-		stop: connect.NewClient[v1.BitwindowdServiceStopRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceStopProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		createDenial: connect.NewClient[v1.CreateDenialRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceCreateDenialProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("CreateDenial")),
-			connect.WithClientOptions(opts...),
-		),
-		cancelDenial: connect.NewClient[v1.CancelDenialRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceCancelDenialProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("CancelDenial")),
-			connect.WithClientOptions(opts...),
-		),
-		pauseDenial: connect.NewClient[v1.PauseDenialRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServicePauseDenialProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("PauseDenial")),
-			connect.WithClientOptions(opts...),
-		),
-		resumeDenial: connect.NewClient[v1.ResumeDenialRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceResumeDenialProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ResumeDenial")),
-			connect.WithClientOptions(opts...),
-		),
-		createAddressBookEntry: connect.NewClient[v1.CreateAddressBookEntryRequest, v1.CreateAddressBookEntryResponse](
-			httpClient,
-			baseURL+BitwindowdServiceCreateAddressBookEntryProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("CreateAddressBookEntry")),
-			connect.WithClientOptions(opts...),
-		),
-		listAddressBook: connect.NewClient[emptypb.Empty, v1.ListAddressBookResponse](
-			httpClient,
-			baseURL+BitwindowdServiceListAddressBookProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ListAddressBook")),
-			connect.WithClientOptions(opts...),
-		),
-		updateAddressBookEntry: connect.NewClient[v1.UpdateAddressBookEntryRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceUpdateAddressBookEntryProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("UpdateAddressBookEntry")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteAddressBookEntry: connect.NewClient[v1.DeleteAddressBookEntryRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceDeleteAddressBookEntryProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("DeleteAddressBookEntry")),
-			connect.WithClientOptions(opts...),
-		),
-		getSyncInfo: connect.NewClient[emptypb.Empty, v1.GetSyncInfoResponse](
-			httpClient,
-			baseURL+BitwindowdServiceGetSyncInfoProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("GetSyncInfo")),
-			connect.WithClientOptions(opts...),
-		),
-		setTransactionNote: connect.NewClient[v1.SetTransactionNoteRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceSetTransactionNoteProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("SetTransactionNote")),
-			connect.WithClientOptions(opts...),
-		),
-		exportLabels: connect.NewClient[emptypb.Empty, v1.ExportLabelsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceExportLabelsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ExportLabels")),
-			connect.WithClientOptions(opts...),
-		),
-		importLabels: connect.NewClient[v1.ImportLabelsRequest, v1.ImportLabelsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceImportLabelsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ImportLabels")),
-			connect.WithClientOptions(opts...),
-		),
-		getFireplaceStats: connect.NewClient[emptypb.Empty, v1.GetFireplaceStatsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceGetFireplaceStatsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("GetFireplaceStats")),
-			connect.WithClientOptions(opts...),
-		),
-		listRecentTransactions: connect.NewClient[v1.ListRecentTransactionsRequest, v1.ListRecentTransactionsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceListRecentTransactionsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ListRecentTransactions")),
-			connect.WithClientOptions(opts...),
-		),
-		listBlocks: connect.NewClient[v1.ListBlocksRequest, v1.ListBlocksResponse](
-			httpClient,
-			baseURL+BitwindowdServiceListBlocksProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ListBlocks")),
-			connect.WithClientOptions(opts...),
-		),
-		getNetworkStats: connect.NewClient[emptypb.Empty, v1.GetNetworkStatsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceGetNetworkStatsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("GetNetworkStats")),
-			connect.WithClientOptions(opts...),
-		),
-		setMempoolWatch: connect.NewClient[v1.SetMempoolWatchRequest, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceSetMempoolWatchProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("SetMempoolWatch")),
-			connect.WithClientOptions(opts...),
-		),
-		resetMempoolWatch: connect.NewClient[emptypb.Empty, emptypb.Empty](
-			httpClient,
-			baseURL+BitwindowdServiceResetMempoolWatchProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ResetMempoolWatch")),
-			connect.WithClientOptions(opts...),
-		),
-		getMempoolWatchStatus: connect.NewClient[emptypb.Empty, v1.GetMempoolWatchStatusResponse](
-			httpClient,
-			baseURL+BitwindowdServiceGetMempoolWatchStatusProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("GetMempoolWatchStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		listMempoolTransactions: connect.NewClient[v1.ListMempoolTransactionsRequest, v1.ListMempoolTransactionsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceListMempoolTransactionsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ListMempoolTransactions")),
-			connect.WithClientOptions(opts...),
-		),
-		listBlockStats: connect.NewClient[v1.ListBlockStatsRequest, v1.ListBlockStatsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceListBlockStatsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ListBlockStats")),
-			connect.WithClientOptions(opts...),
-		),
-		listMiningPools: connect.NewClient[v1.ListMiningPoolsRequest, v1.ListMiningPoolsResponse](
-			httpClient,
-			baseURL+BitwindowdServiceListMiningPoolsProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("ListMiningPools")),
-			connect.WithClientOptions(opts...),
-		),
-		updateNetwork: connect.NewClient[v1.UpdateNetworkRequest, v1.UpdateNetworkResponse](
-			httpClient,
-			baseURL+BitwindowdServiceUpdateNetworkProcedure,
-			connect.WithSchema(bitwindowdServiceMethods.ByName("UpdateNetwork")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// bitwindowdServiceClient implements BitwindowdServiceClient.
-type bitwindowdServiceClient struct {
-	stop                    *connect.Client[v1.BitwindowdServiceStopRequest, emptypb.Empty]
-	createDenial            *connect.Client[v1.CreateDenialRequest, emptypb.Empty]
-	cancelDenial            *connect.Client[v1.CancelDenialRequest, emptypb.Empty]
-	pauseDenial             *connect.Client[v1.PauseDenialRequest, emptypb.Empty]
-	resumeDenial            *connect.Client[v1.ResumeDenialRequest, emptypb.Empty]
-	createAddressBookEntry  *connect.Client[v1.CreateAddressBookEntryRequest, v1.CreateAddressBookEntryResponse]
-	listAddressBook         *connect.Client[emptypb.Empty, v1.ListAddressBookResponse]
-	updateAddressBookEntry  *connect.Client[v1.UpdateAddressBookEntryRequest, emptypb.Empty]
-	deleteAddressBookEntry  *connect.Client[v1.DeleteAddressBookEntryRequest, emptypb.Empty]
-	getSyncInfo             *connect.Client[emptypb.Empty, v1.GetSyncInfoResponse]
-	setTransactionNote      *connect.Client[v1.SetTransactionNoteRequest, emptypb.Empty]
-	exportLabels            *connect.Client[emptypb.Empty, v1.ExportLabelsResponse]
-	importLabels            *connect.Client[v1.ImportLabelsRequest, v1.ImportLabelsResponse]
-	getFireplaceStats       *connect.Client[emptypb.Empty, v1.GetFireplaceStatsResponse]
-	listRecentTransactions  *connect.Client[v1.ListRecentTransactionsRequest, v1.ListRecentTransactionsResponse]
-	listBlocks              *connect.Client[v1.ListBlocksRequest, v1.ListBlocksResponse]
-	getNetworkStats         *connect.Client[emptypb.Empty, v1.GetNetworkStatsResponse]
-	setMempoolWatch         *connect.Client[v1.SetMempoolWatchRequest, emptypb.Empty]
-	resetMempoolWatch       *connect.Client[emptypb.Empty, emptypb.Empty]
-	getMempoolWatchStatus   *connect.Client[emptypb.Empty, v1.GetMempoolWatchStatusResponse]
-	listMempoolTransactions *connect.Client[v1.ListMempoolTransactionsRequest, v1.ListMempoolTransactionsResponse]
-	listBlockStats          *connect.Client[v1.ListBlockStatsRequest, v1.ListBlockStatsResponse]
-	listMiningPools         *connect.Client[v1.ListMiningPoolsRequest, v1.ListMiningPoolsResponse]
-	updateNetwork           *connect.Client[v1.UpdateNetworkRequest, v1.UpdateNetworkResponse]
+// Multiple service clients may share a single connect.Client.
+func NewBitwindowdServiceClient(client *connect.Client) BitwindowdServiceClient {
+	return &bitwindowdServiceClient{client: client}
 }
 
-// Stop calls bitwindowd.v1.BitwindowdService.Stop.
-func (c *bitwindowdServiceClient) Stop(ctx context.Context, req *connect.Request[v1.BitwindowdServiceStopRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.stop.CallUnary(ctx, req)
+// BitwindowdServiceHandler is an implementation of the bitwindowd.v1.BitwindowdService service.
+type BitwindowdServiceHandler interface {
+	Stop(context.Context, *v1.BitwindowdServiceStopRequest) (*emptypb.Empty, error)
+	CreateDenial(context.Context, *v1.CreateDenialRequest) (*emptypb.Empty, error)
+	CancelDenial(context.Context, *v1.CancelDenialRequest) (*emptypb.Empty, error)
+	PauseDenial(context.Context, *v1.PauseDenialRequest) (*emptypb.Empty, error)
+	ResumeDenial(context.Context, *v1.ResumeDenialRequest) (*emptypb.Empty, error)
+	CreateAddressBookEntry(context.Context, *v1.CreateAddressBookEntryRequest) (*v1.CreateAddressBookEntryResponse, error)
+	ListAddressBook(context.Context, *emptypb.Empty) (*v1.ListAddressBookResponse, error)
+	UpdateAddressBookEntry(context.Context, *v1.UpdateAddressBookEntryRequest) (*emptypb.Empty, error)
+	DeleteAddressBookEntry(context.Context, *v1.DeleteAddressBookEntryRequest) (*emptypb.Empty, error)
+	GetSyncInfo(context.Context, *emptypb.Empty) (*v1.GetSyncInfoResponse, error)
+	SetTransactionNote(context.Context, *v1.SetTransactionNoteRequest) (*emptypb.Empty, error)
+	ExportLabels(context.Context, *emptypb.Empty) (*v1.ExportLabelsResponse, error)
+	ImportLabels(context.Context, *v1.ImportLabelsRequest) (*v1.ImportLabelsResponse, error)
+	GetFireplaceStats(context.Context, *emptypb.Empty) (*v1.GetFireplaceStatsResponse, error)
+	ListRecentTransactions(context.Context, *v1.ListRecentTransactionsRequest) (*v1.ListRecentTransactionsResponse, error)
+	ListBlocks(context.Context, *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error)
+	GetNetworkStats(context.Context, *emptypb.Empty) (*v1.GetNetworkStatsResponse, error)
+	SetMempoolWatch(context.Context, *v1.SetMempoolWatchRequest) (*emptypb.Empty, error)
+	ResetMempoolWatch(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	GetMempoolWatchStatus(context.Context, *emptypb.Empty) (*v1.GetMempoolWatchStatusResponse, error)
+	ListMempoolTransactions(context.Context, *v1.ListMempoolTransactionsRequest) (*v1.ListMempoolTransactionsResponse, error)
+	ListBlockStats(context.Context, *v1.ListBlockStatsRequest) (*v1.ListBlockStatsResponse, error)
+	ListMiningPools(context.Context, *v1.ListMiningPoolsRequest) (*v1.ListMiningPoolsResponse, error)
+	UpdateNetwork(context.Context, *v1.UpdateNetworkRequest) (*v1.UpdateNetworkResponse, error)
+}
+
+// RegisterBitwindowdServiceHandler registers svc as the bitwindowd.v1.BitwindowdService
+// implementation on server.
+func RegisterBitwindowdServiceHandler(server *connect.Server, svc BitwindowdServiceHandler) {
+	adapter := bitwindowdServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: bitwindowdServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: bitwindowdServiceCreateDenialSpec(), Handler: adapter.createDenial},
+		connect.Method{Spec: bitwindowdServiceCancelDenialSpec(), Handler: adapter.cancelDenial},
+		connect.Method{Spec: bitwindowdServicePauseDenialSpec(), Handler: adapter.pauseDenial},
+		connect.Method{Spec: bitwindowdServiceResumeDenialSpec(), Handler: adapter.resumeDenial},
+		connect.Method{Spec: bitwindowdServiceCreateAddressBookEntrySpec(), Handler: adapter.createAddressBookEntry},
+		connect.Method{Spec: bitwindowdServiceListAddressBookSpec(), Handler: adapter.listAddressBook},
+		connect.Method{Spec: bitwindowdServiceUpdateAddressBookEntrySpec(), Handler: adapter.updateAddressBookEntry},
+		connect.Method{Spec: bitwindowdServiceDeleteAddressBookEntrySpec(), Handler: adapter.deleteAddressBookEntry},
+		connect.Method{Spec: bitwindowdServiceGetSyncInfoSpec(), Handler: adapter.getSyncInfo},
+		connect.Method{Spec: bitwindowdServiceSetTransactionNoteSpec(), Handler: adapter.setTransactionNote},
+		connect.Method{Spec: bitwindowdServiceExportLabelsSpec(), Handler: adapter.exportLabels},
+		connect.Method{Spec: bitwindowdServiceImportLabelsSpec(), Handler: adapter.importLabels},
+		connect.Method{Spec: bitwindowdServiceGetFireplaceStatsSpec(), Handler: adapter.getFireplaceStats},
+		connect.Method{Spec: bitwindowdServiceListRecentTransactionsSpec(), Handler: adapter.listRecentTransactions},
+		connect.Method{Spec: bitwindowdServiceListBlocksSpec(), Handler: adapter.listBlocks},
+		connect.Method{Spec: bitwindowdServiceGetNetworkStatsSpec(), Handler: adapter.getNetworkStats},
+		connect.Method{Spec: bitwindowdServiceSetMempoolWatchSpec(), Handler: adapter.setMempoolWatch},
+		connect.Method{Spec: bitwindowdServiceResetMempoolWatchSpec(), Handler: adapter.resetMempoolWatch},
+		connect.Method{Spec: bitwindowdServiceGetMempoolWatchStatusSpec(), Handler: adapter.getMempoolWatchStatus},
+		connect.Method{Spec: bitwindowdServiceListMempoolTransactionsSpec(), Handler: adapter.listMempoolTransactions},
+		connect.Method{Spec: bitwindowdServiceListBlockStatsSpec(), Handler: adapter.listBlockStats},
+		connect.Method{Spec: bitwindowdServiceListMiningPoolsSpec(), Handler: adapter.listMiningPools},
+		connect.Method{Spec: bitwindowdServiceUpdateNetworkSpec(), Handler: adapter.updateNetwork},
+	)
 }
 
-// CreateDenial calls bitwindowd.v1.BitwindowdService.CreateDenial.
-func (c *bitwindowdServiceClient) CreateDenial(ctx context.Context, req *connect.Request[v1.CreateDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.createDenial.CallUnary(ctx, req)
+// UnimplementedBitwindowdServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBitwindowdServiceHandler struct{}
+
+func (UnimplementedBitwindowdServiceHandler) Stop(context.Context, *v1.BitwindowdServiceStopRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.Stop is not implemented")
 }
 
-// CancelDenial calls bitwindowd.v1.BitwindowdService.CancelDenial.
-func (c *bitwindowdServiceClient) CancelDenial(ctx context.Context, req *connect.Request[v1.CancelDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.cancelDenial.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) CreateDenial(context.Context, *v1.CreateDenialRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.CreateDenial is not implemented")
 }
 
-// PauseDenial calls bitwindowd.v1.BitwindowdService.PauseDenial.
-func (c *bitwindowdServiceClient) PauseDenial(ctx context.Context, req *connect.Request[v1.PauseDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.pauseDenial.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) CancelDenial(context.Context, *v1.CancelDenialRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.CancelDenial is not implemented")
 }
 
-// ResumeDenial calls bitwindowd.v1.BitwindowdService.ResumeDenial.
-func (c *bitwindowdServiceClient) ResumeDenial(ctx context.Context, req *connect.Request[v1.ResumeDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.resumeDenial.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) PauseDenial(context.Context, *v1.PauseDenialRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.PauseDenial is not implemented")
 }
 
-// CreateAddressBookEntry calls bitwindowd.v1.BitwindowdService.CreateAddressBookEntry.
-func (c *bitwindowdServiceClient) CreateAddressBookEntry(ctx context.Context, req *connect.Request[v1.CreateAddressBookEntryRequest]) (*connect.Response[v1.CreateAddressBookEntryResponse], error) {
-	return c.createAddressBookEntry.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ResumeDenial(context.Context, *v1.ResumeDenialRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ResumeDenial is not implemented")
 }
 
-// ListAddressBook calls bitwindowd.v1.BitwindowdService.ListAddressBook.
-func (c *bitwindowdServiceClient) ListAddressBook(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListAddressBookResponse], error) {
-	return c.listAddressBook.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) CreateAddressBookEntry(context.Context, *v1.CreateAddressBookEntryRequest) (*v1.CreateAddressBookEntryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.CreateAddressBookEntry is not implemented")
 }
 
-// UpdateAddressBookEntry calls bitwindowd.v1.BitwindowdService.UpdateAddressBookEntry.
-func (c *bitwindowdServiceClient) UpdateAddressBookEntry(ctx context.Context, req *connect.Request[v1.UpdateAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.updateAddressBookEntry.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ListAddressBook(context.Context, *emptypb.Empty) (*v1.ListAddressBookResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ListAddressBook is not implemented")
 }
 
-// DeleteAddressBookEntry calls bitwindowd.v1.BitwindowdService.DeleteAddressBookEntry.
-func (c *bitwindowdServiceClient) DeleteAddressBookEntry(ctx context.Context, req *connect.Request[v1.DeleteAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.deleteAddressBookEntry.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) UpdateAddressBookEntry(context.Context, *v1.UpdateAddressBookEntryRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.UpdateAddressBookEntry is not implemented")
 }
 
-// GetSyncInfo calls bitwindowd.v1.BitwindowdService.GetSyncInfo.
-func (c *bitwindowdServiceClient) GetSyncInfo(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetSyncInfoResponse], error) {
-	return c.getSyncInfo.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) DeleteAddressBookEntry(context.Context, *v1.DeleteAddressBookEntryRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.DeleteAddressBookEntry is not implemented")
 }
 
-// SetTransactionNote calls bitwindowd.v1.BitwindowdService.SetTransactionNote.
-func (c *bitwindowdServiceClient) SetTransactionNote(ctx context.Context, req *connect.Request[v1.SetTransactionNoteRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.setTransactionNote.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) GetSyncInfo(context.Context, *emptypb.Empty) (*v1.GetSyncInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.GetSyncInfo is not implemented")
 }
 
-// ExportLabels calls bitwindowd.v1.BitwindowdService.ExportLabels.
-func (c *bitwindowdServiceClient) ExportLabels(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ExportLabelsResponse], error) {
-	return c.exportLabels.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) SetTransactionNote(context.Context, *v1.SetTransactionNoteRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.SetTransactionNote is not implemented")
 }
 
-// ImportLabels calls bitwindowd.v1.BitwindowdService.ImportLabels.
-func (c *bitwindowdServiceClient) ImportLabels(ctx context.Context, req *connect.Request[v1.ImportLabelsRequest]) (*connect.Response[v1.ImportLabelsResponse], error) {
-	return c.importLabels.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ExportLabels(context.Context, *emptypb.Empty) (*v1.ExportLabelsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ExportLabels is not implemented")
 }
 
-// GetFireplaceStats calls bitwindowd.v1.BitwindowdService.GetFireplaceStats.
-func (c *bitwindowdServiceClient) GetFireplaceStats(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetFireplaceStatsResponse], error) {
-	return c.getFireplaceStats.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ImportLabels(context.Context, *v1.ImportLabelsRequest) (*v1.ImportLabelsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ImportLabels is not implemented")
 }
 
-// ListRecentTransactions calls bitwindowd.v1.BitwindowdService.ListRecentTransactions.
-func (c *bitwindowdServiceClient) ListRecentTransactions(ctx context.Context, req *connect.Request[v1.ListRecentTransactionsRequest]) (*connect.Response[v1.ListRecentTransactionsResponse], error) {
-	return c.listRecentTransactions.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) GetFireplaceStats(context.Context, *emptypb.Empty) (*v1.GetFireplaceStatsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.GetFireplaceStats is not implemented")
 }
 
-// ListBlocks calls bitwindowd.v1.BitwindowdService.ListBlocks.
-func (c *bitwindowdServiceClient) ListBlocks(ctx context.Context, req *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error) {
-	return c.listBlocks.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ListRecentTransactions(context.Context, *v1.ListRecentTransactionsRequest) (*v1.ListRecentTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ListRecentTransactions is not implemented")
 }
 
-// GetNetworkStats calls bitwindowd.v1.BitwindowdService.GetNetworkStats.
-func (c *bitwindowdServiceClient) GetNetworkStats(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetNetworkStatsResponse], error) {
-	return c.getNetworkStats.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ListBlocks(context.Context, *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ListBlocks is not implemented")
 }
 
-// SetMempoolWatch calls bitwindowd.v1.BitwindowdService.SetMempoolWatch.
-func (c *bitwindowdServiceClient) SetMempoolWatch(ctx context.Context, req *connect.Request[v1.SetMempoolWatchRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.setMempoolWatch.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) GetNetworkStats(context.Context, *emptypb.Empty) (*v1.GetNetworkStatsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.GetNetworkStats is not implemented")
 }
 
-// ResetMempoolWatch calls bitwindowd.v1.BitwindowdService.ResetMempoolWatch.
-func (c *bitwindowdServiceClient) ResetMempoolWatch(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return c.resetMempoolWatch.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) SetMempoolWatch(context.Context, *v1.SetMempoolWatchRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.SetMempoolWatch is not implemented")
 }
 
-// GetMempoolWatchStatus calls bitwindowd.v1.BitwindowdService.GetMempoolWatchStatus.
-func (c *bitwindowdServiceClient) GetMempoolWatchStatus(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetMempoolWatchStatusResponse], error) {
-	return c.getMempoolWatchStatus.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ResetMempoolWatch(context.Context, *emptypb.Empty) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ResetMempoolWatch is not implemented")
 }
 
-// ListMempoolTransactions calls bitwindowd.v1.BitwindowdService.ListMempoolTransactions.
-func (c *bitwindowdServiceClient) ListMempoolTransactions(ctx context.Context, req *connect.Request[v1.ListMempoolTransactionsRequest]) (*connect.Response[v1.ListMempoolTransactionsResponse], error) {
-	return c.listMempoolTransactions.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) GetMempoolWatchStatus(context.Context, *emptypb.Empty) (*v1.GetMempoolWatchStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.GetMempoolWatchStatus is not implemented")
 }
 
-// ListBlockStats calls bitwindowd.v1.BitwindowdService.ListBlockStats.
-func (c *bitwindowdServiceClient) ListBlockStats(ctx context.Context, req *connect.Request[v1.ListBlockStatsRequest]) (*connect.Response[v1.ListBlockStatsResponse], error) {
-	return c.listBlockStats.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ListMempoolTransactions(context.Context, *v1.ListMempoolTransactionsRequest) (*v1.ListMempoolTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ListMempoolTransactions is not implemented")
 }
 
-// ListMiningPools calls bitwindowd.v1.BitwindowdService.ListMiningPools.
-func (c *bitwindowdServiceClient) ListMiningPools(ctx context.Context, req *connect.Request[v1.ListMiningPoolsRequest]) (*connect.Response[v1.ListMiningPoolsResponse], error) {
-	return c.listMiningPools.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ListBlockStats(context.Context, *v1.ListBlockStatsRequest) (*v1.ListBlockStatsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ListBlockStats is not implemented")
 }
 
-// UpdateNetwork calls bitwindowd.v1.BitwindowdService.UpdateNetwork.
-func (c *bitwindowdServiceClient) UpdateNetwork(ctx context.Context, req *connect.Request[v1.UpdateNetworkRequest]) (*connect.Response[v1.UpdateNetworkResponse], error) {
-	return c.updateNetwork.CallUnary(ctx, req)
+func (UnimplementedBitwindowdServiceHandler) ListMiningPools(context.Context, *v1.ListMiningPoolsRequest) (*v1.ListMiningPoolsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.ListMiningPools is not implemented")
 }
 
-// BitwindowdServiceHandler is an implementation of the bitwindowd.v1.BitwindowdService service.
-type BitwindowdServiceHandler interface {
-	// Window-close + clean exit. Relays to orchestratord.Shutdown (which is
-	// detached and drains bitcoind/enforcer over ~90s in the background), then
-	// tears down bitwindowd itself. Acks fast so the Flutter window can destroy
-	// immediately. Pass skip_downstream=true to leave the orchestratord stack
-	// running (only bitwindowd dies).
-	Stop(context.Context, *connect.Request[v1.BitwindowdServiceStopRequest]) (*connect.Response[emptypb.Empty], error)
-	// Deniability operations
-	CreateDenial(context.Context, *connect.Request[v1.CreateDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	CancelDenial(context.Context, *connect.Request[v1.CancelDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	PauseDenial(context.Context, *connect.Request[v1.PauseDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	ResumeDenial(context.Context, *connect.Request[v1.ResumeDenialRequest]) (*connect.Response[emptypb.Empty], error)
-	// Wallet operations
-	CreateAddressBookEntry(context.Context, *connect.Request[v1.CreateAddressBookEntryRequest]) (*connect.Response[v1.CreateAddressBookEntryResponse], error)
-	ListAddressBook(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListAddressBookResponse], error)
-	UpdateAddressBookEntry(context.Context, *connect.Request[v1.UpdateAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error)
-	DeleteAddressBookEntry(context.Context, *connect.Request[v1.DeleteAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error)
-	GetSyncInfo(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetSyncInfoResponse], error)
-	SetTransactionNote(context.Context, *connect.Request[v1.SetTransactionNoteRequest]) (*connect.Response[emptypb.Empty], error)
-	// BIP329 label import/export. ExportLabels emits one JSONL object per
-	// labelled item (address book, tx note, UTXO label). ImportLabels parses
-	// BIP329 JSONL and writes into the matching store, skipping unknown or
-	// malformed lines.
-	ExportLabels(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ExportLabelsResponse], error)
-	ImportLabels(context.Context, *connect.Request[v1.ImportLabelsRequest]) (*connect.Response[v1.ImportLabelsResponse], error)
-	GetFireplaceStats(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetFireplaceStatsResponse], error)
-	// Lists the most recent transactions, both confirmed and unconfirmed.
-	ListRecentTransactions(context.Context, *connect.Request[v1.ListRecentTransactionsRequest]) (*connect.Response[v1.ListRecentTransactionsResponse], error)
-	// Lists blocks with pagination support
-	ListBlocks(context.Context, *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error)
-	// Get network statistics
-	GetNetworkStats(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetNetworkStatsResponse], error)
-	// Mempool watch: records every tx in the mempool and how long it has waited.
-	SetMempoolWatch(context.Context, *connect.Request[v1.SetMempoolWatchRequest]) (*connect.Response[emptypb.Empty], error)
-	// Forgets everything recorded and starts over from the current mempool.
-	ResetMempoolWatch(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	GetMempoolWatchStatus(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetMempoolWatchStatusResponse], error)
-	ListMempoolTransactions(context.Context, *connect.Request[v1.ListMempoolTransactionsRequest]) (*connect.Response[v1.ListMempoolTransactionsResponse], error)
-	ListBlockStats(context.Context, *connect.Request[v1.ListBlockStatsRequest]) (*connect.Response[v1.ListBlockStatsResponse], error)
-	// Mining pools: which pools mined the recent blocks.
-	ListMiningPools(context.Context, *connect.Request[v1.ListMiningPoolsRequest]) (*connect.Response[v1.ListMiningPoolsResponse], error)
-	// Swap bitcoind network. bitwindowd is the entry point so the DB swap
-	// (network-scoped folder) is co-located with the orchestrator update.
-	// Implementation: forward to orchestratord's SetBitcoinConfigNetwork
-	// (which rewrites bitcoin.conf and restarts bitcoind on the new chain),
-	// then exit so the launcher restarts bitwindowd with a fresh DB scoped
-	// to the new network. Returns once orchestratord acknowledges the swap;
-	// the bitwindowd process exit happens shortly after.
-	UpdateNetwork(context.Context, *connect.Request[v1.UpdateNetworkRequest]) (*connect.Response[v1.UpdateNetworkResponse], error)
-}
-
-// NewBitwindowdServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBitwindowdServiceHandler(svc BitwindowdServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	bitwindowdServiceMethods := v1.File_bitwindowd_v1_bitwindowd_proto.Services().ByName("BitwindowdService").Methods()
-	bitwindowdServiceStopHandler := connect.NewUnaryHandler(
-		BitwindowdServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceCreateDenialHandler := connect.NewUnaryHandler(
-		BitwindowdServiceCreateDenialProcedure,
-		svc.CreateDenial,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("CreateDenial")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceCancelDenialHandler := connect.NewUnaryHandler(
-		BitwindowdServiceCancelDenialProcedure,
-		svc.CancelDenial,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("CancelDenial")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServicePauseDenialHandler := connect.NewUnaryHandler(
-		BitwindowdServicePauseDenialProcedure,
-		svc.PauseDenial,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("PauseDenial")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceResumeDenialHandler := connect.NewUnaryHandler(
-		BitwindowdServiceResumeDenialProcedure,
-		svc.ResumeDenial,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ResumeDenial")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceCreateAddressBookEntryHandler := connect.NewUnaryHandler(
-		BitwindowdServiceCreateAddressBookEntryProcedure,
-		svc.CreateAddressBookEntry,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("CreateAddressBookEntry")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceListAddressBookHandler := connect.NewUnaryHandler(
-		BitwindowdServiceListAddressBookProcedure,
-		svc.ListAddressBook,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ListAddressBook")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceUpdateAddressBookEntryHandler := connect.NewUnaryHandler(
-		BitwindowdServiceUpdateAddressBookEntryProcedure,
-		svc.UpdateAddressBookEntry,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("UpdateAddressBookEntry")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceDeleteAddressBookEntryHandler := connect.NewUnaryHandler(
-		BitwindowdServiceDeleteAddressBookEntryProcedure,
-		svc.DeleteAddressBookEntry,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("DeleteAddressBookEntry")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceGetSyncInfoHandler := connect.NewUnaryHandler(
-		BitwindowdServiceGetSyncInfoProcedure,
-		svc.GetSyncInfo,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("GetSyncInfo")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceSetTransactionNoteHandler := connect.NewUnaryHandler(
-		BitwindowdServiceSetTransactionNoteProcedure,
-		svc.SetTransactionNote,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("SetTransactionNote")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceExportLabelsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceExportLabelsProcedure,
-		svc.ExportLabels,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ExportLabels")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceImportLabelsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceImportLabelsProcedure,
-		svc.ImportLabels,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ImportLabels")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceGetFireplaceStatsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceGetFireplaceStatsProcedure,
-		svc.GetFireplaceStats,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("GetFireplaceStats")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceListRecentTransactionsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceListRecentTransactionsProcedure,
-		svc.ListRecentTransactions,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ListRecentTransactions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceListBlocksHandler := connect.NewUnaryHandler(
-		BitwindowdServiceListBlocksProcedure,
-		svc.ListBlocks,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ListBlocks")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceGetNetworkStatsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceGetNetworkStatsProcedure,
-		svc.GetNetworkStats,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("GetNetworkStats")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceSetMempoolWatchHandler := connect.NewUnaryHandler(
-		BitwindowdServiceSetMempoolWatchProcedure,
-		svc.SetMempoolWatch,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("SetMempoolWatch")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceResetMempoolWatchHandler := connect.NewUnaryHandler(
-		BitwindowdServiceResetMempoolWatchProcedure,
-		svc.ResetMempoolWatch,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ResetMempoolWatch")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceGetMempoolWatchStatusHandler := connect.NewUnaryHandler(
-		BitwindowdServiceGetMempoolWatchStatusProcedure,
-		svc.GetMempoolWatchStatus,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("GetMempoolWatchStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceListMempoolTransactionsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceListMempoolTransactionsProcedure,
-		svc.ListMempoolTransactions,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ListMempoolTransactions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceListBlockStatsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceListBlockStatsProcedure,
-		svc.ListBlockStats,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ListBlockStats")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceListMiningPoolsHandler := connect.NewUnaryHandler(
-		BitwindowdServiceListMiningPoolsProcedure,
-		svc.ListMiningPools,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("ListMiningPools")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitwindowdServiceUpdateNetworkHandler := connect.NewUnaryHandler(
-		BitwindowdServiceUpdateNetworkProcedure,
-		svc.UpdateNetwork,
-		connect.WithSchema(bitwindowdServiceMethods.ByName("UpdateNetwork")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/bitwindowd.v1.BitwindowdService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BitwindowdServiceStopProcedure:
-			bitwindowdServiceStopHandler.ServeHTTP(w, r)
-		case BitwindowdServiceCreateDenialProcedure:
-			bitwindowdServiceCreateDenialHandler.ServeHTTP(w, r)
-		case BitwindowdServiceCancelDenialProcedure:
-			bitwindowdServiceCancelDenialHandler.ServeHTTP(w, r)
-		case BitwindowdServicePauseDenialProcedure:
-			bitwindowdServicePauseDenialHandler.ServeHTTP(w, r)
-		case BitwindowdServiceResumeDenialProcedure:
-			bitwindowdServiceResumeDenialHandler.ServeHTTP(w, r)
-		case BitwindowdServiceCreateAddressBookEntryProcedure:
-			bitwindowdServiceCreateAddressBookEntryHandler.ServeHTTP(w, r)
-		case BitwindowdServiceListAddressBookProcedure:
-			bitwindowdServiceListAddressBookHandler.ServeHTTP(w, r)
-		case BitwindowdServiceUpdateAddressBookEntryProcedure:
-			bitwindowdServiceUpdateAddressBookEntryHandler.ServeHTTP(w, r)
-		case BitwindowdServiceDeleteAddressBookEntryProcedure:
-			bitwindowdServiceDeleteAddressBookEntryHandler.ServeHTTP(w, r)
-		case BitwindowdServiceGetSyncInfoProcedure:
-			bitwindowdServiceGetSyncInfoHandler.ServeHTTP(w, r)
-		case BitwindowdServiceSetTransactionNoteProcedure:
-			bitwindowdServiceSetTransactionNoteHandler.ServeHTTP(w, r)
-		case BitwindowdServiceExportLabelsProcedure:
-			bitwindowdServiceExportLabelsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceImportLabelsProcedure:
-			bitwindowdServiceImportLabelsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceGetFireplaceStatsProcedure:
-			bitwindowdServiceGetFireplaceStatsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceListRecentTransactionsProcedure:
-			bitwindowdServiceListRecentTransactionsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceListBlocksProcedure:
-			bitwindowdServiceListBlocksHandler.ServeHTTP(w, r)
-		case BitwindowdServiceGetNetworkStatsProcedure:
-			bitwindowdServiceGetNetworkStatsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceSetMempoolWatchProcedure:
-			bitwindowdServiceSetMempoolWatchHandler.ServeHTTP(w, r)
-		case BitwindowdServiceResetMempoolWatchProcedure:
-			bitwindowdServiceResetMempoolWatchHandler.ServeHTTP(w, r)
-		case BitwindowdServiceGetMempoolWatchStatusProcedure:
-			bitwindowdServiceGetMempoolWatchStatusHandler.ServeHTTP(w, r)
-		case BitwindowdServiceListMempoolTransactionsProcedure:
-			bitwindowdServiceListMempoolTransactionsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceListBlockStatsProcedure:
-			bitwindowdServiceListBlockStatsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceListMiningPoolsProcedure:
-			bitwindowdServiceListMiningPoolsHandler.ServeHTTP(w, r)
-		case BitwindowdServiceUpdateNetworkProcedure:
-			bitwindowdServiceUpdateNetworkHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedBitwindowdServiceHandler) UpdateNetwork(context.Context, *v1.UpdateNetworkRequest) (*v1.UpdateNetworkResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitwindowd.v1.BitwindowdService.UpdateNetwork is not implemented")
 }
 
-// UnimplementedBitwindowdServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBitwindowdServiceHandler struct{}
+type bitwindowdServiceClient struct {
+	client *connect.Client
+}
 
-func (UnimplementedBitwindowdServiceHandler) Stop(context.Context, *connect.Request[v1.BitwindowdServiceStopRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.Stop is not implemented"))
+func (c *bitwindowdServiceClient) Stop(ctx context.Context, req *v1.BitwindowdServiceStopRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) CreateDenial(context.Context, *connect.Request[v1.CreateDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.CreateDenial is not implemented"))
+func (c *bitwindowdServiceClient) CreateDenial(ctx context.Context, req *v1.CreateDenialRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceCreateDenialSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) CancelDenial(context.Context, *connect.Request[v1.CancelDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.CancelDenial is not implemented"))
+func (c *bitwindowdServiceClient) CancelDenial(ctx context.Context, req *v1.CancelDenialRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceCancelDenialSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) PauseDenial(context.Context, *connect.Request[v1.PauseDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.PauseDenial is not implemented"))
+func (c *bitwindowdServiceClient) PauseDenial(ctx context.Context, req *v1.PauseDenialRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServicePauseDenialSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) ResumeDenial(context.Context, *connect.Request[v1.ResumeDenialRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ResumeDenial is not implemented"))
+func (c *bitwindowdServiceClient) ResumeDenial(ctx context.Context, req *v1.ResumeDenialRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceResumeDenialSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) CreateAddressBookEntry(context.Context, *connect.Request[v1.CreateAddressBookEntryRequest]) (*connect.Response[v1.CreateAddressBookEntryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.CreateAddressBookEntry is not implemented"))
+func (c *bitwindowdServiceClient) CreateAddressBookEntry(ctx context.Context, req *v1.CreateAddressBookEntryRequest) (*v1.CreateAddressBookEntryResponse, error) {
+	var res v1.CreateAddressBookEntryResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceCreateAddressBookEntrySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) ListAddressBook(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListAddressBookResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ListAddressBook is not implemented"))
+func (c *bitwindowdServiceClient) ListAddressBook(ctx context.Context, req *emptypb.Empty) (*v1.ListAddressBookResponse, error) {
+	var res v1.ListAddressBookResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceListAddressBookSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) UpdateAddressBookEntry(context.Context, *connect.Request[v1.UpdateAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.UpdateAddressBookEntry is not implemented"))
+func (c *bitwindowdServiceClient) UpdateAddressBookEntry(ctx context.Context, req *v1.UpdateAddressBookEntryRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceUpdateAddressBookEntrySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) DeleteAddressBookEntry(context.Context, *connect.Request[v1.DeleteAddressBookEntryRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.DeleteAddressBookEntry is not implemented"))
+func (c *bitwindowdServiceClient) DeleteAddressBookEntry(ctx context.Context, req *v1.DeleteAddressBookEntryRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceDeleteAddressBookEntrySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) GetSyncInfo(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetSyncInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.GetSyncInfo is not implemented"))
+func (c *bitwindowdServiceClient) GetSyncInfo(ctx context.Context, req *emptypb.Empty) (*v1.GetSyncInfoResponse, error) {
+	var res v1.GetSyncInfoResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceGetSyncInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) SetTransactionNote(context.Context, *connect.Request[v1.SetTransactionNoteRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.SetTransactionNote is not implemented"))
+func (c *bitwindowdServiceClient) SetTransactionNote(ctx context.Context, req *v1.SetTransactionNoteRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceSetTransactionNoteSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) ExportLabels(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ExportLabelsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ExportLabels is not implemented"))
+func (c *bitwindowdServiceClient) ExportLabels(ctx context.Context, req *emptypb.Empty) (*v1.ExportLabelsResponse, error) {
+	var res v1.ExportLabelsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceExportLabelsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) ImportLabels(context.Context, *connect.Request[v1.ImportLabelsRequest]) (*connect.Response[v1.ImportLabelsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ImportLabels is not implemented"))
+func (c *bitwindowdServiceClient) ImportLabels(ctx context.Context, req *v1.ImportLabelsRequest) (*v1.ImportLabelsResponse, error) {
+	var res v1.ImportLabelsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceImportLabelsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) GetFireplaceStats(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetFireplaceStatsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.GetFireplaceStats is not implemented"))
+func (c *bitwindowdServiceClient) GetFireplaceStats(ctx context.Context, req *emptypb.Empty) (*v1.GetFireplaceStatsResponse, error) {
+	var res v1.GetFireplaceStatsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceGetFireplaceStatsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) ListRecentTransactions(context.Context, *connect.Request[v1.ListRecentTransactionsRequest]) (*connect.Response[v1.ListRecentTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ListRecentTransactions is not implemented"))
+func (c *bitwindowdServiceClient) ListRecentTransactions(ctx context.Context, req *v1.ListRecentTransactionsRequest) (*v1.ListRecentTransactionsResponse, error) {
+	var res v1.ListRecentTransactionsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceListRecentTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitwindowdServiceHandler) ListBlocks(context.Context, *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ListBlocks is not implemented"))
+func (c *bitwindowdServiceClient) ListBlocks(ctx context.Context, req *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error) {
+	var res v1.ListBlocksResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceListBlocksSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) GetNetworkStats(ctx context.Context, req *emptypb.Empty) (*v1.GetNetworkStatsResponse, error) {
+	var res v1.GetNetworkStatsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceGetNetworkStatsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) SetMempoolWatch(ctx context.Context, req *v1.SetMempoolWatchRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceSetMempoolWatchSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) ResetMempoolWatch(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, bitwindowdServiceResetMempoolWatchSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) GetMempoolWatchStatus(ctx context.Context, req *emptypb.Empty) (*v1.GetMempoolWatchStatusResponse, error) {
+	var res v1.GetMempoolWatchStatusResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceGetMempoolWatchStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) ListMempoolTransactions(ctx context.Context, req *v1.ListMempoolTransactionsRequest) (*v1.ListMempoolTransactionsResponse, error) {
+	var res v1.ListMempoolTransactionsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceListMempoolTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) ListBlockStats(ctx context.Context, req *v1.ListBlockStatsRequest) (*v1.ListBlockStatsResponse, error) {
+	var res v1.ListBlockStatsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceListBlockStatsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) ListMiningPools(ctx context.Context, req *v1.ListMiningPoolsRequest) (*v1.ListMiningPoolsResponse, error) {
+	var res v1.ListMiningPoolsResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceListMiningPoolsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitwindowdServiceClient) UpdateNetwork(ctx context.Context, req *v1.UpdateNetworkRequest) (*v1.UpdateNetworkResponse, error) {
+	var res v1.UpdateNetworkResponse
+	if err := c.client.CallUnary(ctx, bitwindowdServiceUpdateNetworkSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type bitwindowdServiceHandler struct{ svc BitwindowdServiceHandler }
+
+func (h bitwindowdServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BitwindowdServiceStopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) createDenial(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDenialRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDenial(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) cancelDenial(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CancelDenialRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CancelDenial(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) pauseDenial(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PauseDenialRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PauseDenial(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) resumeDenial(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ResumeDenialRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ResumeDenial(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) createAddressBookEntry(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateAddressBookEntryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateAddressBookEntry(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) listAddressBook(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListAddressBook(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) GetNetworkStats(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetNetworkStatsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.GetNetworkStats is not implemented"))
+func (h bitwindowdServiceHandler) updateAddressBookEntry(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UpdateAddressBookEntryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UpdateAddressBookEntry(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) SetMempoolWatch(context.Context, *connect.Request[v1.SetMempoolWatchRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.SetMempoolWatch is not implemented"))
+func (h bitwindowdServiceHandler) deleteAddressBookEntry(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteAddressBookEntryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeleteAddressBookEntry(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) ResetMempoolWatch(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ResetMempoolWatch is not implemented"))
+func (h bitwindowdServiceHandler) getSyncInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSyncInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) GetMempoolWatchStatus(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetMempoolWatchStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.GetMempoolWatchStatus is not implemented"))
+func (h bitwindowdServiceHandler) setTransactionNote(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetTransactionNoteRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetTransactionNote(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) ListMempoolTransactions(context.Context, *connect.Request[v1.ListMempoolTransactionsRequest]) (*connect.Response[v1.ListMempoolTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ListMempoolTransactions is not implemented"))
+func (h bitwindowdServiceHandler) exportLabels(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ExportLabels(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) ListBlockStats(context.Context, *connect.Request[v1.ListBlockStatsRequest]) (*connect.Response[v1.ListBlockStatsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ListBlockStats is not implemented"))
+func (h bitwindowdServiceHandler) importLabels(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ImportLabelsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ImportLabels(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) ListMiningPools(context.Context, *connect.Request[v1.ListMiningPoolsRequest]) (*connect.Response[v1.ListMiningPoolsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.ListMiningPools is not implemented"))
+func (h bitwindowdServiceHandler) getFireplaceStats(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetFireplaceStats(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) listRecentTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListRecentTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListRecentTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) listBlocks(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListBlocksRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListBlocks(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) getNetworkStats(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNetworkStats(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitwindowdServiceHandler) UpdateNetwork(context.Context, *connect.Request[v1.UpdateNetworkRequest]) (*connect.Response[v1.UpdateNetworkResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitwindowd.v1.BitwindowdService.UpdateNetwork is not implemented"))
+func (h bitwindowdServiceHandler) setMempoolWatch(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetMempoolWatchRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetMempoolWatch(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) resetMempoolWatch(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ResetMempoolWatch(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) getMempoolWatchStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetMempoolWatchStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) listMempoolTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListMempoolTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListMempoolTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) listBlockStats(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListBlockStatsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListBlockStats(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) listMiningPools(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListMiningPoolsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListMiningPools(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitwindowdServiceHandler) updateNetwork(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UpdateNetworkRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UpdateNetwork(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/drivechain/v1/drivechainv1connect/drivechain.connect.go b/bitwindow/server/gen/drivechain/v1/drivechainv1connect/drivechain.connect.go
index 9021f8bdac..176a8edfbc 100644
--- a/bitwindow/server/gen/drivechain/v1/drivechainv1connect/drivechain.connect.go
+++ b/bitwindow/server/gen/drivechain/v1/drivechainv1connect/drivechain.connect.go
@@ -5,221 +5,242 @@
 package drivechainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/drivechain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// DrivechainServiceName is the fully-qualified name of the DrivechainService service.
 	DrivechainServiceName = "drivechain.v1.DrivechainService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// DrivechainServiceListSidechainsProcedure is the fully-qualified name of the DrivechainService's
+	// DrivechainServiceListSidechainsProcedure is the procedure name of the DrivechainService's
 	// ListSidechains RPC.
 	DrivechainServiceListSidechainsProcedure = "/drivechain.v1.DrivechainService/ListSidechains"
-	// DrivechainServiceListSidechainProposalsProcedure is the fully-qualified name of the
-	// DrivechainService's ListSidechainProposals RPC.
+	// DrivechainServiceListSidechainProposalsProcedure is the procedure name of the DrivechainService's
+	// ListSidechainProposals RPC.
 	DrivechainServiceListSidechainProposalsProcedure = "/drivechain.v1.DrivechainService/ListSidechainProposals"
-	// DrivechainServiceProposeSidechainProcedure is the fully-qualified name of the DrivechainService's
+	// DrivechainServiceProposeSidechainProcedure is the procedure name of the DrivechainService's
 	// ProposeSidechain RPC.
 	DrivechainServiceProposeSidechainProcedure = "/drivechain.v1.DrivechainService/ProposeSidechain"
-	// DrivechainServiceListWithdrawalsProcedure is the fully-qualified name of the DrivechainService's
+	// DrivechainServiceListWithdrawalsProcedure is the procedure name of the DrivechainService's
 	// ListWithdrawals RPC.
 	DrivechainServiceListWithdrawalsProcedure = "/drivechain.v1.DrivechainService/ListWithdrawals"
-	// DrivechainServiceListRecentActionsProcedure is the fully-qualified name of the
-	// DrivechainService's ListRecentActions RPC.
+	// DrivechainServiceListRecentActionsProcedure is the procedure name of the DrivechainService's
+	// ListRecentActions RPC.
 	DrivechainServiceListRecentActionsProcedure = "/drivechain.v1.DrivechainService/ListRecentActions"
 )
 
+var (
+	drivechainServiceListSidechainsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_drivechain_v1_drivechain_proto.Services().ByName("DrivechainService").Methods().ByName("ListSidechains"),
+			Procedure:  DrivechainServiceListSidechainsProcedure,
+		}
+	})
+	drivechainServiceListSidechainProposalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_drivechain_v1_drivechain_proto.Services().ByName("DrivechainService").Methods().ByName("ListSidechainProposals"),
+			Procedure:  DrivechainServiceListSidechainProposalsProcedure,
+		}
+	})
+	drivechainServiceProposeSidechainSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_drivechain_v1_drivechain_proto.Services().ByName("DrivechainService").Methods().ByName("ProposeSidechain"),
+			Procedure:  DrivechainServiceProposeSidechainProcedure,
+		}
+	})
+	drivechainServiceListWithdrawalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_drivechain_v1_drivechain_proto.Services().ByName("DrivechainService").Methods().ByName("ListWithdrawals"),
+			Procedure:  DrivechainServiceListWithdrawalsProcedure,
+		}
+	})
+	drivechainServiceListRecentActionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_drivechain_v1_drivechain_proto.Services().ByName("DrivechainService").Methods().ByName("ListRecentActions"),
+			Procedure:  DrivechainServiceListRecentActionsProcedure,
+		}
+	})
+)
+
 // DrivechainServiceClient is a client for the drivechain.v1.DrivechainService service.
 type DrivechainServiceClient interface {
-	ListSidechains(context.Context, *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error)
-	ListSidechainProposals(context.Context, *connect.Request[v1.ListSidechainProposalsRequest]) (*connect.Response[v1.ListSidechainProposalsResponse], error)
-	ProposeSidechain(context.Context, *connect.Request[v1.ProposeSidechainRequest]) (*connect.Response[v1.ProposeSidechainResponse], error)
-	ListWithdrawals(context.Context, *connect.Request[v1.ListWithdrawalsRequest]) (*connect.Response[v1.ListWithdrawalsResponse], error)
-	ListRecentActions(context.Context, *connect.Request[v1.ListRecentActionsRequest]) (*connect.Response[v1.ListRecentActionsResponse], error)
+	ListSidechains(context.Context, *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error)
+	ListSidechainProposals(context.Context, *v1.ListSidechainProposalsRequest) (*v1.ListSidechainProposalsResponse, error)
+	ProposeSidechain(context.Context, *v1.ProposeSidechainRequest) (*v1.ProposeSidechainResponse, error)
+	ListWithdrawals(context.Context, *v1.ListWithdrawalsRequest) (*v1.ListWithdrawalsResponse, error)
+	ListRecentActions(context.Context, *v1.ListRecentActionsRequest) (*v1.ListRecentActionsResponse, error)
 }
 
 // NewDrivechainServiceClient constructs a client for the drivechain.v1.DrivechainService service.
-// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped
-// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewDrivechainServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) DrivechainServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	drivechainServiceMethods := v1.File_drivechain_v1_drivechain_proto.Services().ByName("DrivechainService").Methods()
-	return &drivechainServiceClient{
-		listSidechains: connect.NewClient[v1.ListSidechainsRequest, v1.ListSidechainsResponse](
-			httpClient,
-			baseURL+DrivechainServiceListSidechainsProcedure,
-			connect.WithSchema(drivechainServiceMethods.ByName("ListSidechains")),
-			connect.WithClientOptions(opts...),
-		),
-		listSidechainProposals: connect.NewClient[v1.ListSidechainProposalsRequest, v1.ListSidechainProposalsResponse](
-			httpClient,
-			baseURL+DrivechainServiceListSidechainProposalsProcedure,
-			connect.WithSchema(drivechainServiceMethods.ByName("ListSidechainProposals")),
-			connect.WithClientOptions(opts...),
-		),
-		proposeSidechain: connect.NewClient[v1.ProposeSidechainRequest, v1.ProposeSidechainResponse](
-			httpClient,
-			baseURL+DrivechainServiceProposeSidechainProcedure,
-			connect.WithSchema(drivechainServiceMethods.ByName("ProposeSidechain")),
-			connect.WithClientOptions(opts...),
-		),
-		listWithdrawals: connect.NewClient[v1.ListWithdrawalsRequest, v1.ListWithdrawalsResponse](
-			httpClient,
-			baseURL+DrivechainServiceListWithdrawalsProcedure,
-			connect.WithSchema(drivechainServiceMethods.ByName("ListWithdrawals")),
-			connect.WithClientOptions(opts...),
-		),
-		listRecentActions: connect.NewClient[v1.ListRecentActionsRequest, v1.ListRecentActionsResponse](
-			httpClient,
-			baseURL+DrivechainServiceListRecentActionsProcedure,
-			connect.WithSchema(drivechainServiceMethods.ByName("ListRecentActions")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// Multiple service clients may share a single connect.Client.
+func NewDrivechainServiceClient(client *connect.Client) DrivechainServiceClient {
+	return &drivechainServiceClient{client: client}
 }
 
-// drivechainServiceClient implements DrivechainServiceClient.
-type drivechainServiceClient struct {
-	listSidechains         *connect.Client[v1.ListSidechainsRequest, v1.ListSidechainsResponse]
-	listSidechainProposals *connect.Client[v1.ListSidechainProposalsRequest, v1.ListSidechainProposalsResponse]
-	proposeSidechain       *connect.Client[v1.ProposeSidechainRequest, v1.ProposeSidechainResponse]
-	listWithdrawals        *connect.Client[v1.ListWithdrawalsRequest, v1.ListWithdrawalsResponse]
-	listRecentActions      *connect.Client[v1.ListRecentActionsRequest, v1.ListRecentActionsResponse]
+// DrivechainServiceHandler is an implementation of the drivechain.v1.DrivechainService service.
+type DrivechainServiceHandler interface {
+	ListSidechains(context.Context, *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error)
+	ListSidechainProposals(context.Context, *v1.ListSidechainProposalsRequest) (*v1.ListSidechainProposalsResponse, error)
+	ProposeSidechain(context.Context, *v1.ProposeSidechainRequest) (*v1.ProposeSidechainResponse, error)
+	ListWithdrawals(context.Context, *v1.ListWithdrawalsRequest) (*v1.ListWithdrawalsResponse, error)
+	ListRecentActions(context.Context, *v1.ListRecentActionsRequest) (*v1.ListRecentActionsResponse, error)
 }
 
-// ListSidechains calls drivechain.v1.DrivechainService.ListSidechains.
-func (c *drivechainServiceClient) ListSidechains(ctx context.Context, req *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error) {
-	return c.listSidechains.CallUnary(ctx, req)
+// RegisterDrivechainServiceHandler registers svc as the drivechain.v1.DrivechainService
+// implementation on server.
+func RegisterDrivechainServiceHandler(server *connect.Server, svc DrivechainServiceHandler) {
+	adapter := drivechainServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: drivechainServiceListSidechainsSpec(), Handler: adapter.listSidechains},
+		connect.Method{Spec: drivechainServiceListSidechainProposalsSpec(), Handler: adapter.listSidechainProposals},
+		connect.Method{Spec: drivechainServiceProposeSidechainSpec(), Handler: adapter.proposeSidechain},
+		connect.Method{Spec: drivechainServiceListWithdrawalsSpec(), Handler: adapter.listWithdrawals},
+		connect.Method{Spec: drivechainServiceListRecentActionsSpec(), Handler: adapter.listRecentActions},
+	)
 }
 
-// ListSidechainProposals calls drivechain.v1.DrivechainService.ListSidechainProposals.
-func (c *drivechainServiceClient) ListSidechainProposals(ctx context.Context, req *connect.Request[v1.ListSidechainProposalsRequest]) (*connect.Response[v1.ListSidechainProposalsResponse], error) {
-	return c.listSidechainProposals.CallUnary(ctx, req)
+// UnimplementedDrivechainServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedDrivechainServiceHandler struct{}
+
+func (UnimplementedDrivechainServiceHandler) ListSidechains(context.Context, *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "drivechain.v1.DrivechainService.ListSidechains is not implemented")
 }
 
-// ProposeSidechain calls drivechain.v1.DrivechainService.ProposeSidechain.
-func (c *drivechainServiceClient) ProposeSidechain(ctx context.Context, req *connect.Request[v1.ProposeSidechainRequest]) (*connect.Response[v1.ProposeSidechainResponse], error) {
-	return c.proposeSidechain.CallUnary(ctx, req)
+func (UnimplementedDrivechainServiceHandler) ListSidechainProposals(context.Context, *v1.ListSidechainProposalsRequest) (*v1.ListSidechainProposalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "drivechain.v1.DrivechainService.ListSidechainProposals is not implemented")
 }
 
-// ListWithdrawals calls drivechain.v1.DrivechainService.ListWithdrawals.
-func (c *drivechainServiceClient) ListWithdrawals(ctx context.Context, req *connect.Request[v1.ListWithdrawalsRequest]) (*connect.Response[v1.ListWithdrawalsResponse], error) {
-	return c.listWithdrawals.CallUnary(ctx, req)
+func (UnimplementedDrivechainServiceHandler) ProposeSidechain(context.Context, *v1.ProposeSidechainRequest) (*v1.ProposeSidechainResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "drivechain.v1.DrivechainService.ProposeSidechain is not implemented")
 }
 
-// ListRecentActions calls drivechain.v1.DrivechainService.ListRecentActions.
-func (c *drivechainServiceClient) ListRecentActions(ctx context.Context, req *connect.Request[v1.ListRecentActionsRequest]) (*connect.Response[v1.ListRecentActionsResponse], error) {
-	return c.listRecentActions.CallUnary(ctx, req)
+func (UnimplementedDrivechainServiceHandler) ListWithdrawals(context.Context, *v1.ListWithdrawalsRequest) (*v1.ListWithdrawalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "drivechain.v1.DrivechainService.ListWithdrawals is not implemented")
 }
 
-// DrivechainServiceHandler is an implementation of the drivechain.v1.DrivechainService service.
-type DrivechainServiceHandler interface {
-	ListSidechains(context.Context, *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error)
-	ListSidechainProposals(context.Context, *connect.Request[v1.ListSidechainProposalsRequest]) (*connect.Response[v1.ListSidechainProposalsResponse], error)
-	ProposeSidechain(context.Context, *connect.Request[v1.ProposeSidechainRequest]) (*connect.Response[v1.ProposeSidechainResponse], error)
-	ListWithdrawals(context.Context, *connect.Request[v1.ListWithdrawalsRequest]) (*connect.Response[v1.ListWithdrawalsResponse], error)
-	ListRecentActions(context.Context, *connect.Request[v1.ListRecentActionsRequest]) (*connect.Response[v1.ListRecentActionsResponse], error)
+func (UnimplementedDrivechainServiceHandler) ListRecentActions(context.Context, *v1.ListRecentActionsRequest) (*v1.ListRecentActionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "drivechain.v1.DrivechainService.ListRecentActions is not implemented")
 }
 
-// NewDrivechainServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewDrivechainServiceHandler(svc DrivechainServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	drivechainServiceMethods := v1.File_drivechain_v1_drivechain_proto.Services().ByName("DrivechainService").Methods()
-	drivechainServiceListSidechainsHandler := connect.NewUnaryHandler(
-		DrivechainServiceListSidechainsProcedure,
-		svc.ListSidechains,
-		connect.WithSchema(drivechainServiceMethods.ByName("ListSidechains")),
-		connect.WithHandlerOptions(opts...),
-	)
-	drivechainServiceListSidechainProposalsHandler := connect.NewUnaryHandler(
-		DrivechainServiceListSidechainProposalsProcedure,
-		svc.ListSidechainProposals,
-		connect.WithSchema(drivechainServiceMethods.ByName("ListSidechainProposals")),
-		connect.WithHandlerOptions(opts...),
-	)
-	drivechainServiceProposeSidechainHandler := connect.NewUnaryHandler(
-		DrivechainServiceProposeSidechainProcedure,
-		svc.ProposeSidechain,
-		connect.WithSchema(drivechainServiceMethods.ByName("ProposeSidechain")),
-		connect.WithHandlerOptions(opts...),
-	)
-	drivechainServiceListWithdrawalsHandler := connect.NewUnaryHandler(
-		DrivechainServiceListWithdrawalsProcedure,
-		svc.ListWithdrawals,
-		connect.WithSchema(drivechainServiceMethods.ByName("ListWithdrawals")),
-		connect.WithHandlerOptions(opts...),
-	)
-	drivechainServiceListRecentActionsHandler := connect.NewUnaryHandler(
-		DrivechainServiceListRecentActionsProcedure,
-		svc.ListRecentActions,
-		connect.WithSchema(drivechainServiceMethods.ByName("ListRecentActions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/drivechain.v1.DrivechainService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case DrivechainServiceListSidechainsProcedure:
-			drivechainServiceListSidechainsHandler.ServeHTTP(w, r)
-		case DrivechainServiceListSidechainProposalsProcedure:
-			drivechainServiceListSidechainProposalsHandler.ServeHTTP(w, r)
-		case DrivechainServiceProposeSidechainProcedure:
-			drivechainServiceProposeSidechainHandler.ServeHTTP(w, r)
-		case DrivechainServiceListWithdrawalsProcedure:
-			drivechainServiceListWithdrawalsHandler.ServeHTTP(w, r)
-		case DrivechainServiceListRecentActionsProcedure:
-			drivechainServiceListRecentActionsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type drivechainServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedDrivechainServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedDrivechainServiceHandler struct{}
+func (c *drivechainServiceClient) ListSidechains(ctx context.Context, req *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error) {
+	var res v1.ListSidechainsResponse
+	if err := c.client.CallUnary(ctx, drivechainServiceListSidechainsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *drivechainServiceClient) ListSidechainProposals(ctx context.Context, req *v1.ListSidechainProposalsRequest) (*v1.ListSidechainProposalsResponse, error) {
+	var res v1.ListSidechainProposalsResponse
+	if err := c.client.CallUnary(ctx, drivechainServiceListSidechainProposalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *drivechainServiceClient) ProposeSidechain(ctx context.Context, req *v1.ProposeSidechainRequest) (*v1.ProposeSidechainResponse, error) {
+	var res v1.ProposeSidechainResponse
+	if err := c.client.CallUnary(ctx, drivechainServiceProposeSidechainSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *drivechainServiceClient) ListWithdrawals(ctx context.Context, req *v1.ListWithdrawalsRequest) (*v1.ListWithdrawalsResponse, error) {
+	var res v1.ListWithdrawalsResponse
+	if err := c.client.CallUnary(ctx, drivechainServiceListWithdrawalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedDrivechainServiceHandler) ListSidechains(context.Context, *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("drivechain.v1.DrivechainService.ListSidechains is not implemented"))
+func (c *drivechainServiceClient) ListRecentActions(ctx context.Context, req *v1.ListRecentActionsRequest) (*v1.ListRecentActionsResponse, error) {
+	var res v1.ListRecentActionsResponse
+	if err := c.client.CallUnary(ctx, drivechainServiceListRecentActionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedDrivechainServiceHandler) ListSidechainProposals(context.Context, *connect.Request[v1.ListSidechainProposalsRequest]) (*connect.Response[v1.ListSidechainProposalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("drivechain.v1.DrivechainService.ListSidechainProposals is not implemented"))
+type drivechainServiceHandler struct{ svc DrivechainServiceHandler }
+
+func (h drivechainServiceHandler) listSidechains(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSidechainsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSidechains(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedDrivechainServiceHandler) ProposeSidechain(context.Context, *connect.Request[v1.ProposeSidechainRequest]) (*connect.Response[v1.ProposeSidechainResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("drivechain.v1.DrivechainService.ProposeSidechain is not implemented"))
+func (h drivechainServiceHandler) listSidechainProposals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSidechainProposalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSidechainProposals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedDrivechainServiceHandler) ListWithdrawals(context.Context, *connect.Request[v1.ListWithdrawalsRequest]) (*connect.Response[v1.ListWithdrawalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("drivechain.v1.DrivechainService.ListWithdrawals is not implemented"))
+func (h drivechainServiceHandler) proposeSidechain(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ProposeSidechainRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ProposeSidechain(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedDrivechainServiceHandler) ListRecentActions(context.Context, *connect.Request[v1.ListRecentActionsRequest]) (*connect.Response[v1.ListRecentActionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("drivechain.v1.DrivechainService.ListRecentActions is not implemented"))
+func (h drivechainServiceHandler) listWithdrawals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListWithdrawalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListWithdrawals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h drivechainServiceHandler) listRecentActions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListRecentActionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListRecentActions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/fast_withdrawal/v1/fast_withdrawalv1connect/fast_withdrawal.connect.go b/bitwindow/server/gen/fast_withdrawal/v1/fast_withdrawalv1connect/fast_withdrawal.connect.go
index fbc2d1ff69..1cbe1636b7 100644
--- a/bitwindow/server/gen/fast_withdrawal/v1/fast_withdrawalv1connect/fast_withdrawal.connect.go
+++ b/bitwindow/server/gen/fast_withdrawal/v1/fast_withdrawalv1connect/fast_withdrawal.connect.go
@@ -5,108 +5,129 @@
 package fast_withdrawalv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/fast_withdrawal/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// FastWithdrawalServiceName is the fully-qualified name of the FastWithdrawalService service.
 	FastWithdrawalServiceName = "fast_withdrawal.v1.FastWithdrawalService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// FastWithdrawalServiceInitiateFastWithdrawalProcedure is the fully-qualified name of the
+	// FastWithdrawalServiceInitiateFastWithdrawalProcedure is the procedure name of the
 	// FastWithdrawalService's InitiateFastWithdrawal RPC.
 	FastWithdrawalServiceInitiateFastWithdrawalProcedure = "/fast_withdrawal.v1.FastWithdrawalService/InitiateFastWithdrawal"
 )
 
+var (
+	fastWithdrawalServiceInitiateFastWithdrawalSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_fast_withdrawal_v1_fast_withdrawal_proto.Services().ByName("FastWithdrawalService").Methods().ByName("InitiateFastWithdrawal"),
+			Procedure:  FastWithdrawalServiceInitiateFastWithdrawalProcedure,
+		}
+	})
+)
+
 // FastWithdrawalServiceClient is a client for the fast_withdrawal.v1.FastWithdrawalService service.
 type FastWithdrawalServiceClient interface {
-	// InitiateFastWithdrawal starts a fast withdrawal and streams status updates
-	InitiateFastWithdrawal(context.Context, *connect.Request[v1.InitiateFastWithdrawalRequest]) (*connect.ServerStreamForClient[v1.FastWithdrawalUpdate], error)
+	InitiateFastWithdrawal(context.Context, *v1.InitiateFastWithdrawalRequest) (FastWithdrawalServiceInitiateFastWithdrawalClientStream, error)
 }
 
 // NewFastWithdrawalServiceClient constructs a client for the
-// fast_withdrawal.v1.FastWithdrawalService service. By default, it uses the Connect protocol with
-// the binary Protobuf Codec, asks for gzipped responses, and sends uncompressed requests. To use
-// the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewFastWithdrawalServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) FastWithdrawalServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	fastWithdrawalServiceMethods := v1.File_fast_withdrawal_v1_fast_withdrawal_proto.Services().ByName("FastWithdrawalService").Methods()
-	return &fastWithdrawalServiceClient{
-		initiateFastWithdrawal: connect.NewClient[v1.InitiateFastWithdrawalRequest, v1.FastWithdrawalUpdate](
-			httpClient,
-			baseURL+FastWithdrawalServiceInitiateFastWithdrawalProcedure,
-			connect.WithSchema(fastWithdrawalServiceMethods.ByName("InitiateFastWithdrawal")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// fast_withdrawal.v1.FastWithdrawalService service. Multiple service clients may share a single
+// connect.Client.
+func NewFastWithdrawalServiceClient(client *connect.Client) FastWithdrawalServiceClient {
+	return &fastWithdrawalServiceClient{client: client}
 }
 
-// fastWithdrawalServiceClient implements FastWithdrawalServiceClient.
-type fastWithdrawalServiceClient struct {
-	initiateFastWithdrawal *connect.Client[v1.InitiateFastWithdrawalRequest, v1.FastWithdrawalUpdate]
+// FastWithdrawalServiceInitiateFastWithdrawalClientStream is the client stream for the
+// FastWithdrawalService's InitiateFastWithdrawal RPC.
+type FastWithdrawalServiceInitiateFastWithdrawalClientStream struct {
+	stream connect.ClientStream
 }
 
-// InitiateFastWithdrawal calls fast_withdrawal.v1.FastWithdrawalService.InitiateFastWithdrawal.
-func (c *fastWithdrawalServiceClient) InitiateFastWithdrawal(ctx context.Context, req *connect.Request[v1.InitiateFastWithdrawalRequest]) (*connect.ServerStreamForClient[v1.FastWithdrawalUpdate], error) {
-	return c.initiateFastWithdrawal.CallServerStream(ctx, req)
+// Receive returns the next response message from the server.
+func (s FastWithdrawalServiceInitiateFastWithdrawalClientStream) Receive() (*v1.FastWithdrawalUpdate, error) {
+	var res v1.FastWithdrawalUpdate
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s FastWithdrawalServiceInitiateFastWithdrawalClientStream) Close() error {
+	return s.stream.Close()
 }
 
 // FastWithdrawalServiceHandler is an implementation of the fast_withdrawal.v1.FastWithdrawalService
 // service.
 type FastWithdrawalServiceHandler interface {
-	// InitiateFastWithdrawal starts a fast withdrawal and streams status updates
-	InitiateFastWithdrawal(context.Context, *connect.Request[v1.InitiateFastWithdrawalRequest], *connect.ServerStream[v1.FastWithdrawalUpdate]) error
+	InitiateFastWithdrawal(context.Context, *v1.InitiateFastWithdrawalRequest, FastWithdrawalServiceInitiateFastWithdrawalServerStream) error
 }
 
-// NewFastWithdrawalServiceHandler builds an HTTP handler from the service implementation. It
-// returns the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewFastWithdrawalServiceHandler(svc FastWithdrawalServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	fastWithdrawalServiceMethods := v1.File_fast_withdrawal_v1_fast_withdrawal_proto.Services().ByName("FastWithdrawalService").Methods()
-	fastWithdrawalServiceInitiateFastWithdrawalHandler := connect.NewServerStreamHandler(
-		FastWithdrawalServiceInitiateFastWithdrawalProcedure,
-		svc.InitiateFastWithdrawal,
-		connect.WithSchema(fastWithdrawalServiceMethods.ByName("InitiateFastWithdrawal")),
-		connect.WithHandlerOptions(opts...),
+// RegisterFastWithdrawalServiceHandler registers svc as the
+// fast_withdrawal.v1.FastWithdrawalService implementation on server.
+func RegisterFastWithdrawalServiceHandler(server *connect.Server, svc FastWithdrawalServiceHandler) {
+	adapter := fastWithdrawalServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: fastWithdrawalServiceInitiateFastWithdrawalSpec(), Handler: adapter.initiateFastWithdrawal},
 	)
-	return "/fast_withdrawal.v1.FastWithdrawalService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case FastWithdrawalServiceInitiateFastWithdrawalProcedure:
-			fastWithdrawalServiceInitiateFastWithdrawalHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+}
+
+// FastWithdrawalServiceInitiateFastWithdrawalServerStream is the server stream for the
+// FastWithdrawalService's InitiateFastWithdrawal RPC.
+type FastWithdrawalServiceInitiateFastWithdrawalServerStream struct {
+	stream connect.ServerStream
+}
+
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s FastWithdrawalServiceInitiateFastWithdrawalServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
+}
+
+// Send sends a response message to the client.
+func (s FastWithdrawalServiceInitiateFastWithdrawalServerStream) Send(res *v1.FastWithdrawalUpdate) error {
+	return s.stream.Send(res)
 }
 
 // UnimplementedFastWithdrawalServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedFastWithdrawalServiceHandler struct{}
 
-func (UnimplementedFastWithdrawalServiceHandler) InitiateFastWithdrawal(context.Context, *connect.Request[v1.InitiateFastWithdrawalRequest], *connect.ServerStream[v1.FastWithdrawalUpdate]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("fast_withdrawal.v1.FastWithdrawalService.InitiateFastWithdrawal is not implemented"))
+func (UnimplementedFastWithdrawalServiceHandler) InitiateFastWithdrawal(context.Context, *v1.InitiateFastWithdrawalRequest, FastWithdrawalServiceInitiateFastWithdrawalServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "fast_withdrawal.v1.FastWithdrawalService.InitiateFastWithdrawal is not implemented")
+}
+
+type fastWithdrawalServiceClient struct {
+	client *connect.Client
+}
+
+func (c *fastWithdrawalServiceClient) InitiateFastWithdrawal(ctx context.Context, req *v1.InitiateFastWithdrawalRequest) (FastWithdrawalServiceInitiateFastWithdrawalClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, fastWithdrawalServiceInitiateFastWithdrawalSpec(), req)
+	if err != nil {
+		return FastWithdrawalServiceInitiateFastWithdrawalClientStream{}, err
+	}
+	return FastWithdrawalServiceInitiateFastWithdrawalClientStream{stream: stream}, nil
+}
+
+type fastWithdrawalServiceHandler struct{ svc FastWithdrawalServiceHandler }
+
+func (h fastWithdrawalServiceHandler) initiateFastWithdrawal(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.InitiateFastWithdrawalRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.InitiateFastWithdrawal(ctx, &req, FastWithdrawalServiceInitiateFastWithdrawalServerStream{stream: stream})
 }
diff --git a/bitwindow/server/gen/health/v1/healthv1connect/health.connect.go b/bitwindow/server/gen/health/v1/healthv1connect/health.connect.go
index e039eb6bd6..19ba92fcc1 100644
--- a/bitwindow/server/gen/health/v1/healthv1connect/health.connect.go
+++ b/bitwindow/server/gen/health/v1/healthv1connect/health.connect.go
@@ -5,141 +5,161 @@
 package healthv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/health/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// HealthServiceName is the fully-qualified name of the HealthService service.
 	HealthServiceName = "health.v1.HealthService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// HealthServiceCheckProcedure is the fully-qualified name of the HealthService's Check RPC.
+	// HealthServiceCheckProcedure is the procedure name of the HealthService's Check RPC.
 	HealthServiceCheckProcedure = "/health.v1.HealthService/Check"
-	// HealthServiceWatchProcedure is the fully-qualified name of the HealthService's Watch RPC.
+	// HealthServiceWatchProcedure is the procedure name of the HealthService's Watch RPC.
 	HealthServiceWatchProcedure = "/health.v1.HealthService/Watch"
 )
 
+var (
+	healthServiceCheckSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_health_v1_health_proto.Services().ByName("HealthService").Methods().ByName("Check"),
+			Procedure:  HealthServiceCheckProcedure,
+		}
+	})
+	healthServiceWatchSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_health_v1_health_proto.Services().ByName("HealthService").Methods().ByName("Watch"),
+			Procedure:  HealthServiceWatchProcedure,
+		}
+	})
+)
+
 // HealthServiceClient is a client for the health.v1.HealthService service.
 type HealthServiceClient interface {
-	// Check status of requested services
-	// buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
-	Check(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.CheckResponse], error)
-	// buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
-	// buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
-	Watch(context.Context, *connect.Request[emptypb.Empty]) (*connect.ServerStreamForClient[v1.CheckResponse], error)
-}
-
-// NewHealthServiceClient constructs a client for the health.v1.HealthService service. By default,
-// it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and
-// sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC()
-// or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewHealthServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) HealthServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	healthServiceMethods := v1.File_health_v1_health_proto.Services().ByName("HealthService").Methods()
-	return &healthServiceClient{
-		check: connect.NewClient[emptypb.Empty, v1.CheckResponse](
-			httpClient,
-			baseURL+HealthServiceCheckProcedure,
-			connect.WithSchema(healthServiceMethods.ByName("Check")),
-			connect.WithClientOptions(opts...),
-		),
-		watch: connect.NewClient[emptypb.Empty, v1.CheckResponse](
-			httpClient,
-			baseURL+HealthServiceWatchProcedure,
-			connect.WithSchema(healthServiceMethods.ByName("Watch")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+	Check(context.Context, *emptypb.Empty) (*v1.CheckResponse, error)
+	Watch(context.Context, *emptypb.Empty) (HealthServiceWatchClientStream, error)
 }
 
-// healthServiceClient implements HealthServiceClient.
-type healthServiceClient struct {
-	check *connect.Client[emptypb.Empty, v1.CheckResponse]
-	watch *connect.Client[emptypb.Empty, v1.CheckResponse]
+// NewHealthServiceClient constructs a client for the health.v1.HealthService service. Multiple
+// service clients may share a single connect.Client.
+func NewHealthServiceClient(client *connect.Client) HealthServiceClient {
+	return &healthServiceClient{client: client}
 }
 
-// Check calls health.v1.HealthService.Check.
-func (c *healthServiceClient) Check(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.CheckResponse], error) {
-	return c.check.CallUnary(ctx, req)
+// HealthServiceWatchClientStream is the client stream for the HealthService's Watch RPC.
+type HealthServiceWatchClientStream struct {
+	stream connect.ClientStream
 }
 
-// Watch calls health.v1.HealthService.Watch.
-func (c *healthServiceClient) Watch(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.ServerStreamForClient[v1.CheckResponse], error) {
-	return c.watch.CallServerStream(ctx, req)
+// Receive returns the next response message from the server.
+func (s HealthServiceWatchClientStream) Receive() (*v1.CheckResponse, error) {
+	var res v1.CheckResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s HealthServiceWatchClientStream) Close() error {
+	return s.stream.Close()
 }
 
 // HealthServiceHandler is an implementation of the health.v1.HealthService service.
 type HealthServiceHandler interface {
-	// Check status of requested services
-	// buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
-	Check(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.CheckResponse], error)
-	// buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
-	// buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
-	Watch(context.Context, *connect.Request[emptypb.Empty], *connect.ServerStream[v1.CheckResponse]) error
+	Check(context.Context, *emptypb.Empty) (*v1.CheckResponse, error)
+	Watch(context.Context, *emptypb.Empty, HealthServiceWatchServerStream) error
 }
 
-// NewHealthServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewHealthServiceHandler(svc HealthServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	healthServiceMethods := v1.File_health_v1_health_proto.Services().ByName("HealthService").Methods()
-	healthServiceCheckHandler := connect.NewUnaryHandler(
-		HealthServiceCheckProcedure,
-		svc.Check,
-		connect.WithSchema(healthServiceMethods.ByName("Check")),
-		connect.WithHandlerOptions(opts...),
-	)
-	healthServiceWatchHandler := connect.NewServerStreamHandler(
-		HealthServiceWatchProcedure,
-		svc.Watch,
-		connect.WithSchema(healthServiceMethods.ByName("Watch")),
-		connect.WithHandlerOptions(opts...),
+// RegisterHealthServiceHandler registers svc as the health.v1.HealthService implementation on
+// server.
+func RegisterHealthServiceHandler(server *connect.Server, svc HealthServiceHandler) {
+	adapter := healthServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: healthServiceCheckSpec(), Handler: adapter.check},
+		connect.Method{Spec: healthServiceWatchSpec(), Handler: adapter.watch},
 	)
-	return "/health.v1.HealthService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case HealthServiceCheckProcedure:
-			healthServiceCheckHandler.ServeHTTP(w, r)
-		case HealthServiceWatchProcedure:
-			healthServiceWatchHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+}
+
+// HealthServiceWatchServerStream is the server stream for the HealthService's Watch RPC.
+type HealthServiceWatchServerStream struct {
+	stream connect.ServerStream
+}
+
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s HealthServiceWatchServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
+}
+
+// Send sends a response message to the client.
+func (s HealthServiceWatchServerStream) Send(res *v1.CheckResponse) error {
+	return s.stream.Send(res)
 }
 
 // UnimplementedHealthServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedHealthServiceHandler struct{}
 
-func (UnimplementedHealthServiceHandler) Check(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.CheckResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("health.v1.HealthService.Check is not implemented"))
+func (UnimplementedHealthServiceHandler) Check(context.Context, *emptypb.Empty) (*v1.CheckResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "health.v1.HealthService.Check is not implemented")
+}
+
+func (UnimplementedHealthServiceHandler) Watch(context.Context, *emptypb.Empty, HealthServiceWatchServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "health.v1.HealthService.Watch is not implemented")
+}
+
+type healthServiceClient struct {
+	client *connect.Client
+}
+
+func (c *healthServiceClient) Check(ctx context.Context, req *emptypb.Empty) (*v1.CheckResponse, error) {
+	var res v1.CheckResponse
+	if err := c.client.CallUnary(ctx, healthServiceCheckSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *healthServiceClient) Watch(ctx context.Context, req *emptypb.Empty) (HealthServiceWatchClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, healthServiceWatchSpec(), req)
+	if err != nil {
+		return HealthServiceWatchClientStream{}, err
+	}
+	return HealthServiceWatchClientStream{stream: stream}, nil
+}
+
+type healthServiceHandler struct{ svc HealthServiceHandler }
+
+func (h healthServiceHandler) check(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Check(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedHealthServiceHandler) Watch(context.Context, *connect.Request[emptypb.Empty], *connect.ServerStream[v1.CheckResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("health.v1.HealthService.Watch is not implemented"))
+func (h healthServiceHandler) watch(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.Watch(ctx, &req, HealthServiceWatchServerStream{stream: stream})
 }
diff --git a/bitwindow/server/gen/m4/v1/m4v1connect/m4.connect.go b/bitwindow/server/gen/m4/v1/m4v1connect/m4.connect.go
index 8463e059bc..1f05ca1111 100644
--- a/bitwindow/server/gen/m4/v1/m4v1connect/m4.connect.go
+++ b/bitwindow/server/gen/m4/v1/m4v1connect/m4.connect.go
@@ -5,197 +5,200 @@
 package m4v1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/m4/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// M4ServiceName is the fully-qualified name of the M4Service service.
 	M4ServiceName = "m4.v1.M4Service"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// M4ServiceGetM4HistoryProcedure is the fully-qualified name of the M4Service's GetM4History RPC.
+	// M4ServiceGetM4HistoryProcedure is the procedure name of the M4Service's GetM4History RPC.
 	M4ServiceGetM4HistoryProcedure = "/m4.v1.M4Service/GetM4History"
-	// M4ServiceGetVotesProcedure is the fully-qualified name of the M4Service's GetVotes RPC.
+	// M4ServiceGetVotesProcedure is the procedure name of the M4Service's GetVotes RPC.
 	M4ServiceGetVotesProcedure = "/m4.v1.M4Service/GetVotes"
-	// M4ServiceSetBundleUpvoteProcedure is the fully-qualified name of the M4Service's SetBundleUpvote
-	// RPC.
+	// M4ServiceSetBundleUpvoteProcedure is the procedure name of the M4Service's SetBundleUpvote RPC.
 	M4ServiceSetBundleUpvoteProcedure = "/m4.v1.M4Service/SetBundleUpvote"
-	// M4ServiceSetVotePolicyProcedure is the fully-qualified name of the M4Service's SetVotePolicy RPC.
+	// M4ServiceSetVotePolicyProcedure is the procedure name of the M4Service's SetVotePolicy RPC.
 	M4ServiceSetVotePolicyProcedure = "/m4.v1.M4Service/SetVotePolicy"
 )
 
+var (
+	m4ServiceGetM4HistorySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_m4_v1_m4_proto.Services().ByName("M4Service").Methods().ByName("GetM4History"),
+			Procedure:  M4ServiceGetM4HistoryProcedure,
+		}
+	})
+	m4ServiceGetVotesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_m4_v1_m4_proto.Services().ByName("M4Service").Methods().ByName("GetVotes"),
+			Procedure:  M4ServiceGetVotesProcedure,
+		}
+	})
+	m4ServiceSetBundleUpvoteSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_m4_v1_m4_proto.Services().ByName("M4Service").Methods().ByName("SetBundleUpvote"),
+			Procedure:  M4ServiceSetBundleUpvoteProcedure,
+		}
+	})
+	m4ServiceSetVotePolicySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_m4_v1_m4_proto.Services().ByName("M4Service").Methods().ByName("SetVotePolicy"),
+			Procedure:  M4ServiceSetVotePolicyProcedure,
+		}
+	})
+)
+
 // M4ServiceClient is a client for the m4.v1.M4Service service.
 type M4ServiceClient interface {
-	// Get M4 voting history
-	GetM4History(context.Context, *connect.Request[v1.GetM4HistoryRequest]) (*connect.Response[v1.GetM4HistoryResponse], error)
-	// Get the votes the enforcer puts in the next block it builds.
-	GetVotes(context.Context, *connect.Request[v1.GetVotesRequest]) (*connect.Response[v1.GetVotesResponse], error)
-	// Upvote one pending bundle of a sidechain, or clear the upvote.
-	SetBundleUpvote(context.Context, *connect.Request[v1.SetBundleUpvoteRequest]) (*connect.Response[v1.SetBundleUpvoteResponse], error)
-	// Set the vote for a sidechain that has no upvote.
-	SetVotePolicy(context.Context, *connect.Request[v1.SetVotePolicyRequest]) (*connect.Response[v1.SetVotePolicyResponse], error)
-}
-
-// NewM4ServiceClient constructs a client for the m4.v1.M4Service service. By default, it uses the
-// Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewM4ServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) M4ServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	m4ServiceMethods := v1.File_m4_v1_m4_proto.Services().ByName("M4Service").Methods()
-	return &m4ServiceClient{
-		getM4History: connect.NewClient[v1.GetM4HistoryRequest, v1.GetM4HistoryResponse](
-			httpClient,
-			baseURL+M4ServiceGetM4HistoryProcedure,
-			connect.WithSchema(m4ServiceMethods.ByName("GetM4History")),
-			connect.WithClientOptions(opts...),
-		),
-		getVotes: connect.NewClient[v1.GetVotesRequest, v1.GetVotesResponse](
-			httpClient,
-			baseURL+M4ServiceGetVotesProcedure,
-			connect.WithSchema(m4ServiceMethods.ByName("GetVotes")),
-			connect.WithClientOptions(opts...),
-		),
-		setBundleUpvote: connect.NewClient[v1.SetBundleUpvoteRequest, v1.SetBundleUpvoteResponse](
-			httpClient,
-			baseURL+M4ServiceSetBundleUpvoteProcedure,
-			connect.WithSchema(m4ServiceMethods.ByName("SetBundleUpvote")),
-			connect.WithClientOptions(opts...),
-		),
-		setVotePolicy: connect.NewClient[v1.SetVotePolicyRequest, v1.SetVotePolicyResponse](
-			httpClient,
-			baseURL+M4ServiceSetVotePolicyProcedure,
-			connect.WithSchema(m4ServiceMethods.ByName("SetVotePolicy")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+	GetM4History(context.Context, *v1.GetM4HistoryRequest) (*v1.GetM4HistoryResponse, error)
+	GetVotes(context.Context, *v1.GetVotesRequest) (*v1.GetVotesResponse, error)
+	SetBundleUpvote(context.Context, *v1.SetBundleUpvoteRequest) (*v1.SetBundleUpvoteResponse, error)
+	SetVotePolicy(context.Context, *v1.SetVotePolicyRequest) (*v1.SetVotePolicyResponse, error)
 }
 
-// m4ServiceClient implements M4ServiceClient.
-type m4ServiceClient struct {
-	getM4History    *connect.Client[v1.GetM4HistoryRequest, v1.GetM4HistoryResponse]
-	getVotes        *connect.Client[v1.GetVotesRequest, v1.GetVotesResponse]
-	setBundleUpvote *connect.Client[v1.SetBundleUpvoteRequest, v1.SetBundleUpvoteResponse]
-	setVotePolicy   *connect.Client[v1.SetVotePolicyRequest, v1.SetVotePolicyResponse]
+// NewM4ServiceClient constructs a client for the m4.v1.M4Service service. Multiple service clients
+// may share a single connect.Client.
+func NewM4ServiceClient(client *connect.Client) M4ServiceClient {
+	return &m4ServiceClient{client: client}
 }
 
-// GetM4History calls m4.v1.M4Service.GetM4History.
-func (c *m4ServiceClient) GetM4History(ctx context.Context, req *connect.Request[v1.GetM4HistoryRequest]) (*connect.Response[v1.GetM4HistoryResponse], error) {
-	return c.getM4History.CallUnary(ctx, req)
+// M4ServiceHandler is an implementation of the m4.v1.M4Service service.
+type M4ServiceHandler interface {
+	GetM4History(context.Context, *v1.GetM4HistoryRequest) (*v1.GetM4HistoryResponse, error)
+	GetVotes(context.Context, *v1.GetVotesRequest) (*v1.GetVotesResponse, error)
+	SetBundleUpvote(context.Context, *v1.SetBundleUpvoteRequest) (*v1.SetBundleUpvoteResponse, error)
+	SetVotePolicy(context.Context, *v1.SetVotePolicyRequest) (*v1.SetVotePolicyResponse, error)
 }
 
-// GetVotes calls m4.v1.M4Service.GetVotes.
-func (c *m4ServiceClient) GetVotes(ctx context.Context, req *connect.Request[v1.GetVotesRequest]) (*connect.Response[v1.GetVotesResponse], error) {
-	return c.getVotes.CallUnary(ctx, req)
+// RegisterM4ServiceHandler registers svc as the m4.v1.M4Service implementation on server.
+func RegisterM4ServiceHandler(server *connect.Server, svc M4ServiceHandler) {
+	adapter := m4ServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: m4ServiceGetM4HistorySpec(), Handler: adapter.getM4History},
+		connect.Method{Spec: m4ServiceGetVotesSpec(), Handler: adapter.getVotes},
+		connect.Method{Spec: m4ServiceSetBundleUpvoteSpec(), Handler: adapter.setBundleUpvote},
+		connect.Method{Spec: m4ServiceSetVotePolicySpec(), Handler: adapter.setVotePolicy},
+	)
 }
 
-// SetBundleUpvote calls m4.v1.M4Service.SetBundleUpvote.
-func (c *m4ServiceClient) SetBundleUpvote(ctx context.Context, req *connect.Request[v1.SetBundleUpvoteRequest]) (*connect.Response[v1.SetBundleUpvoteResponse], error) {
-	return c.setBundleUpvote.CallUnary(ctx, req)
+// UnimplementedM4ServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedM4ServiceHandler struct{}
+
+func (UnimplementedM4ServiceHandler) GetM4History(context.Context, *v1.GetM4HistoryRequest) (*v1.GetM4HistoryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "m4.v1.M4Service.GetM4History is not implemented")
 }
 
-// SetVotePolicy calls m4.v1.M4Service.SetVotePolicy.
-func (c *m4ServiceClient) SetVotePolicy(ctx context.Context, req *connect.Request[v1.SetVotePolicyRequest]) (*connect.Response[v1.SetVotePolicyResponse], error) {
-	return c.setVotePolicy.CallUnary(ctx, req)
+func (UnimplementedM4ServiceHandler) GetVotes(context.Context, *v1.GetVotesRequest) (*v1.GetVotesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "m4.v1.M4Service.GetVotes is not implemented")
 }
 
-// M4ServiceHandler is an implementation of the m4.v1.M4Service service.
-type M4ServiceHandler interface {
-	// Get M4 voting history
-	GetM4History(context.Context, *connect.Request[v1.GetM4HistoryRequest]) (*connect.Response[v1.GetM4HistoryResponse], error)
-	// Get the votes the enforcer puts in the next block it builds.
-	GetVotes(context.Context, *connect.Request[v1.GetVotesRequest]) (*connect.Response[v1.GetVotesResponse], error)
-	// Upvote one pending bundle of a sidechain, or clear the upvote.
-	SetBundleUpvote(context.Context, *connect.Request[v1.SetBundleUpvoteRequest]) (*connect.Response[v1.SetBundleUpvoteResponse], error)
-	// Set the vote for a sidechain that has no upvote.
-	SetVotePolicy(context.Context, *connect.Request[v1.SetVotePolicyRequest]) (*connect.Response[v1.SetVotePolicyResponse], error)
-}
-
-// NewM4ServiceHandler builds an HTTP handler from the service implementation. It returns the path
-// on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewM4ServiceHandler(svc M4ServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	m4ServiceMethods := v1.File_m4_v1_m4_proto.Services().ByName("M4Service").Methods()
-	m4ServiceGetM4HistoryHandler := connect.NewUnaryHandler(
-		M4ServiceGetM4HistoryProcedure,
-		svc.GetM4History,
-		connect.WithSchema(m4ServiceMethods.ByName("GetM4History")),
-		connect.WithHandlerOptions(opts...),
-	)
-	m4ServiceGetVotesHandler := connect.NewUnaryHandler(
-		M4ServiceGetVotesProcedure,
-		svc.GetVotes,
-		connect.WithSchema(m4ServiceMethods.ByName("GetVotes")),
-		connect.WithHandlerOptions(opts...),
-	)
-	m4ServiceSetBundleUpvoteHandler := connect.NewUnaryHandler(
-		M4ServiceSetBundleUpvoteProcedure,
-		svc.SetBundleUpvote,
-		connect.WithSchema(m4ServiceMethods.ByName("SetBundleUpvote")),
-		connect.WithHandlerOptions(opts...),
-	)
-	m4ServiceSetVotePolicyHandler := connect.NewUnaryHandler(
-		M4ServiceSetVotePolicyProcedure,
-		svc.SetVotePolicy,
-		connect.WithSchema(m4ServiceMethods.ByName("SetVotePolicy")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/m4.v1.M4Service/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case M4ServiceGetM4HistoryProcedure:
-			m4ServiceGetM4HistoryHandler.ServeHTTP(w, r)
-		case M4ServiceGetVotesProcedure:
-			m4ServiceGetVotesHandler.ServeHTTP(w, r)
-		case M4ServiceSetBundleUpvoteProcedure:
-			m4ServiceSetBundleUpvoteHandler.ServeHTTP(w, r)
-		case M4ServiceSetVotePolicyProcedure:
-			m4ServiceSetVotePolicyHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedM4ServiceHandler) SetBundleUpvote(context.Context, *v1.SetBundleUpvoteRequest) (*v1.SetBundleUpvoteResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "m4.v1.M4Service.SetBundleUpvote is not implemented")
 }
 
-// UnimplementedM4ServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedM4ServiceHandler struct{}
+func (UnimplementedM4ServiceHandler) SetVotePolicy(context.Context, *v1.SetVotePolicyRequest) (*v1.SetVotePolicyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "m4.v1.M4Service.SetVotePolicy is not implemented")
+}
+
+type m4ServiceClient struct {
+	client *connect.Client
+}
+
+func (c *m4ServiceClient) GetM4History(ctx context.Context, req *v1.GetM4HistoryRequest) (*v1.GetM4HistoryResponse, error) {
+	var res v1.GetM4HistoryResponse
+	if err := c.client.CallUnary(ctx, m4ServiceGetM4HistorySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *m4ServiceClient) GetVotes(ctx context.Context, req *v1.GetVotesRequest) (*v1.GetVotesResponse, error) {
+	var res v1.GetVotesResponse
+	if err := c.client.CallUnary(ctx, m4ServiceGetVotesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *m4ServiceClient) SetBundleUpvote(ctx context.Context, req *v1.SetBundleUpvoteRequest) (*v1.SetBundleUpvoteResponse, error) {
+	var res v1.SetBundleUpvoteResponse
+	if err := c.client.CallUnary(ctx, m4ServiceSetBundleUpvoteSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedM4ServiceHandler) GetM4History(context.Context, *connect.Request[v1.GetM4HistoryRequest]) (*connect.Response[v1.GetM4HistoryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("m4.v1.M4Service.GetM4History is not implemented"))
+func (c *m4ServiceClient) SetVotePolicy(ctx context.Context, req *v1.SetVotePolicyRequest) (*v1.SetVotePolicyResponse, error) {
+	var res v1.SetVotePolicyResponse
+	if err := c.client.CallUnary(ctx, m4ServiceSetVotePolicySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type m4ServiceHandler struct{ svc M4ServiceHandler }
+
+func (h m4ServiceHandler) getM4History(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetM4HistoryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetM4History(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedM4ServiceHandler) GetVotes(context.Context, *connect.Request[v1.GetVotesRequest]) (*connect.Response[v1.GetVotesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("m4.v1.M4Service.GetVotes is not implemented"))
+func (h m4ServiceHandler) getVotes(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetVotesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetVotes(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedM4ServiceHandler) SetBundleUpvote(context.Context, *connect.Request[v1.SetBundleUpvoteRequest]) (*connect.Response[v1.SetBundleUpvoteResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("m4.v1.M4Service.SetBundleUpvote is not implemented"))
+func (h m4ServiceHandler) setBundleUpvote(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetBundleUpvoteRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetBundleUpvote(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedM4ServiceHandler) SetVotePolicy(context.Context, *connect.Request[v1.SetVotePolicyRequest]) (*connect.Response[v1.SetVotePolicyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("m4.v1.M4Service.SetVotePolicy is not implemented"))
+func (h m4ServiceHandler) setVotePolicy(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetVotePolicyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetVotePolicy(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/misc/v1/miscv1connect/misc.connect.go b/bitwindow/server/gen/misc/v1/miscv1connect/misc.connect.go
index e64da6e526..078c013e2f 100644
--- a/bitwindow/server/gen/misc/v1/miscv1connect/misc.connect.go
+++ b/bitwindow/server/gen/misc/v1/miscv1connect/misc.connect.go
@@ -5,462 +5,527 @@
 package miscv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/misc/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// MiscServiceName is the fully-qualified name of the MiscService service.
 	MiscServiceName = "misc.v1.MiscService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// MiscServiceListOPReturnProcedure is the fully-qualified name of the MiscService's ListOPReturn
-	// RPC.
+	// MiscServiceListOPReturnProcedure is the procedure name of the MiscService's ListOPReturn RPC.
 	MiscServiceListOPReturnProcedure = "/misc.v1.MiscService/ListOPReturn"
-	// MiscServiceBroadcastNewsProcedure is the fully-qualified name of the MiscService's BroadcastNews
-	// RPC.
+	// MiscServiceBroadcastNewsProcedure is the procedure name of the MiscService's BroadcastNews RPC.
 	MiscServiceBroadcastNewsProcedure = "/misc.v1.MiscService/BroadcastNews"
-	// MiscServiceUpvoteNewsProcedure is the fully-qualified name of the MiscService's UpvoteNews RPC.
+	// MiscServiceUpvoteNewsProcedure is the procedure name of the MiscService's UpvoteNews RPC.
 	MiscServiceUpvoteNewsProcedure = "/misc.v1.MiscService/UpvoteNews"
-	// MiscServiceDownvoteNewsProcedure is the fully-qualified name of the MiscService's DownvoteNews
-	// RPC.
+	// MiscServiceDownvoteNewsProcedure is the procedure name of the MiscService's DownvoteNews RPC.
 	MiscServiceDownvoteNewsProcedure = "/misc.v1.MiscService/DownvoteNews"
-	// MiscServiceCreateTopicProcedure is the fully-qualified name of the MiscService's CreateTopic RPC.
+	// MiscServiceCreateTopicProcedure is the procedure name of the MiscService's CreateTopic RPC.
 	MiscServiceCreateTopicProcedure = "/misc.v1.MiscService/CreateTopic"
-	// MiscServiceListTopicsProcedure is the fully-qualified name of the MiscService's ListTopics RPC.
+	// MiscServiceListTopicsProcedure is the procedure name of the MiscService's ListTopics RPC.
 	MiscServiceListTopicsProcedure = "/misc.v1.MiscService/ListTopics"
-	// MiscServiceListCoinNewsProcedure is the fully-qualified name of the MiscService's ListCoinNews
-	// RPC.
+	// MiscServiceListCoinNewsProcedure is the procedure name of the MiscService's ListCoinNews RPC.
 	MiscServiceListCoinNewsProcedure = "/misc.v1.MiscService/ListCoinNews"
-	// MiscServiceCommentNewsProcedure is the fully-qualified name of the MiscService's CommentNews RPC.
+	// MiscServiceCommentNewsProcedure is the procedure name of the MiscService's CommentNews RPC.
 	MiscServiceCommentNewsProcedure = "/misc.v1.MiscService/CommentNews"
-	// MiscServiceListCommentsProcedure is the fully-qualified name of the MiscService's ListComments
-	// RPC.
+	// MiscServiceListCommentsProcedure is the procedure name of the MiscService's ListComments RPC.
 	MiscServiceListCommentsProcedure = "/misc.v1.MiscService/ListComments"
-	// MiscServiceEstimateNewsFeeProcedure is the fully-qualified name of the MiscService's
-	// EstimateNewsFee RPC.
-	MiscServiceEstimateNewsFeeProcedure = "/misc.v1.MiscService/EstimateNewsFee"
-	// MiscServiceTimestampFileProcedure is the fully-qualified name of the MiscService's TimestampFile
+	// MiscServiceEstimateNewsFeeProcedure is the procedure name of the MiscService's EstimateNewsFee
 	// RPC.
+	MiscServiceEstimateNewsFeeProcedure = "/misc.v1.MiscService/EstimateNewsFee"
+	// MiscServiceTimestampFileProcedure is the procedure name of the MiscService's TimestampFile RPC.
 	MiscServiceTimestampFileProcedure = "/misc.v1.MiscService/TimestampFile"
-	// MiscServiceListTimestampsProcedure is the fully-qualified name of the MiscService's
-	// ListTimestamps RPC.
+	// MiscServiceListTimestampsProcedure is the procedure name of the MiscService's ListTimestamps RPC.
 	MiscServiceListTimestampsProcedure = "/misc.v1.MiscService/ListTimestamps"
-	// MiscServiceVerifyTimestampProcedure is the fully-qualified name of the MiscService's
-	// VerifyTimestamp RPC.
+	// MiscServiceVerifyTimestampProcedure is the procedure name of the MiscService's VerifyTimestamp
+	// RPC.
 	MiscServiceVerifyTimestampProcedure = "/misc.v1.MiscService/VerifyTimestamp"
 )
 
+var (
+	miscServiceListOPReturnSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("ListOPReturn"),
+			Procedure:  MiscServiceListOPReturnProcedure,
+		}
+	})
+	miscServiceBroadcastNewsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("BroadcastNews"),
+			Procedure:  MiscServiceBroadcastNewsProcedure,
+		}
+	})
+	miscServiceUpvoteNewsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("UpvoteNews"),
+			Procedure:  MiscServiceUpvoteNewsProcedure,
+		}
+	})
+	miscServiceDownvoteNewsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("DownvoteNews"),
+			Procedure:  MiscServiceDownvoteNewsProcedure,
+		}
+	})
+	miscServiceCreateTopicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("CreateTopic"),
+			Procedure:  MiscServiceCreateTopicProcedure,
+		}
+	})
+	miscServiceListTopicsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("ListTopics"),
+			Procedure:  MiscServiceListTopicsProcedure,
+		}
+	})
+	miscServiceListCoinNewsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("ListCoinNews"),
+			Procedure:  MiscServiceListCoinNewsProcedure,
+		}
+	})
+	miscServiceCommentNewsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("CommentNews"),
+			Procedure:  MiscServiceCommentNewsProcedure,
+		}
+	})
+	miscServiceListCommentsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("ListComments"),
+			Procedure:  MiscServiceListCommentsProcedure,
+		}
+	})
+	miscServiceEstimateNewsFeeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("EstimateNewsFee"),
+			Procedure:  MiscServiceEstimateNewsFeeProcedure,
+		}
+	})
+	miscServiceTimestampFileSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("TimestampFile"),
+			Procedure:  MiscServiceTimestampFileProcedure,
+		}
+	})
+	miscServiceListTimestampsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("ListTimestamps"),
+			Procedure:  MiscServiceListTimestampsProcedure,
+		}
+	})
+	miscServiceVerifyTimestampSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods().ByName("VerifyTimestamp"),
+			Procedure:  MiscServiceVerifyTimestampProcedure,
+		}
+	})
+)
+
 // MiscServiceClient is a client for the misc.v1.MiscService service.
 type MiscServiceClient interface {
-	ListOPReturn(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListOPReturnResponse], error)
-	BroadcastNews(context.Context, *connect.Request[v1.BroadcastNewsRequest]) (*connect.Response[v1.BroadcastNewsResponse], error)
-	// Broadcasts a signed upvote (CoinNews Vote, kind=0x04) targeting a story.
-	UpvoteNews(context.Context, *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error)
-	// Broadcasts a signed downvote (CoinNews Vote, kind=0x05) targeting a story.
-	DownvoteNews(context.Context, *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error)
-	CreateTopic(context.Context, *connect.Request[v1.CreateTopicRequest]) (*connect.Response[v1.CreateTopicResponse], error)
-	ListTopics(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error)
-	ListCoinNews(context.Context, *connect.Request[v1.ListCoinNewsRequest]) (*connect.Response[v1.ListCoinNewsResponse], error)
-	// Broadcasts a signed Comment (CoinNews Comment, 0x03) on an Item.
-	CommentNews(context.Context, *connect.Request[v1.CommentNewsRequest]) (*connect.Response[v1.CommentNewsResponse], error)
-	// Returns the full reply thread rooted at an Item, ranked per §13.
-	ListComments(context.Context, *connect.Request[v1.ListCommentsRequest]) (*connect.Response[v1.ListCommentsResponse], error)
-	// What a vote or comment would cost to broadcast. Builds nothing.
-	EstimateNewsFee(context.Context, *connect.Request[v1.EstimateNewsFeeRequest]) (*connect.Response[v1.EstimateNewsFeeResponse], error)
-	// File timestamping
-	TimestampFile(context.Context, *connect.Request[v1.TimestampFileRequest]) (*connect.Response[v1.TimestampFileResponse], error)
-	ListTimestamps(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTimestampsResponse], error)
-	VerifyTimestamp(context.Context, *connect.Request[v1.VerifyTimestampRequest]) (*connect.Response[v1.VerifyTimestampResponse], error)
-}
-
-// NewMiscServiceClient constructs a client for the misc.v1.MiscService service. By default, it uses
-// the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewMiscServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) MiscServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	miscServiceMethods := v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods()
-	return &miscServiceClient{
-		listOPReturn: connect.NewClient[emptypb.Empty, v1.ListOPReturnResponse](
-			httpClient,
-			baseURL+MiscServiceListOPReturnProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("ListOPReturn")),
-			connect.WithClientOptions(opts...),
-		),
-		broadcastNews: connect.NewClient[v1.BroadcastNewsRequest, v1.BroadcastNewsResponse](
-			httpClient,
-			baseURL+MiscServiceBroadcastNewsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("BroadcastNews")),
-			connect.WithClientOptions(opts...),
-		),
-		upvoteNews: connect.NewClient[v1.UpvoteNewsRequest, v1.UpvoteNewsResponse](
-			httpClient,
-			baseURL+MiscServiceUpvoteNewsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("UpvoteNews")),
-			connect.WithClientOptions(opts...),
-		),
-		downvoteNews: connect.NewClient[v1.UpvoteNewsRequest, v1.UpvoteNewsResponse](
-			httpClient,
-			baseURL+MiscServiceDownvoteNewsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("DownvoteNews")),
-			connect.WithClientOptions(opts...),
-		),
-		createTopic: connect.NewClient[v1.CreateTopicRequest, v1.CreateTopicResponse](
-			httpClient,
-			baseURL+MiscServiceCreateTopicProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("CreateTopic")),
-			connect.WithClientOptions(opts...),
-		),
-		listTopics: connect.NewClient[emptypb.Empty, v1.ListTopicsResponse](
-			httpClient,
-			baseURL+MiscServiceListTopicsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("ListTopics")),
-			connect.WithClientOptions(opts...),
-		),
-		listCoinNews: connect.NewClient[v1.ListCoinNewsRequest, v1.ListCoinNewsResponse](
-			httpClient,
-			baseURL+MiscServiceListCoinNewsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("ListCoinNews")),
-			connect.WithClientOptions(opts...),
-		),
-		commentNews: connect.NewClient[v1.CommentNewsRequest, v1.CommentNewsResponse](
-			httpClient,
-			baseURL+MiscServiceCommentNewsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("CommentNews")),
-			connect.WithClientOptions(opts...),
-		),
-		listComments: connect.NewClient[v1.ListCommentsRequest, v1.ListCommentsResponse](
-			httpClient,
-			baseURL+MiscServiceListCommentsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("ListComments")),
-			connect.WithClientOptions(opts...),
-		),
-		estimateNewsFee: connect.NewClient[v1.EstimateNewsFeeRequest, v1.EstimateNewsFeeResponse](
-			httpClient,
-			baseURL+MiscServiceEstimateNewsFeeProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("EstimateNewsFee")),
-			connect.WithClientOptions(opts...),
-		),
-		timestampFile: connect.NewClient[v1.TimestampFileRequest, v1.TimestampFileResponse](
-			httpClient,
-			baseURL+MiscServiceTimestampFileProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("TimestampFile")),
-			connect.WithClientOptions(opts...),
-		),
-		listTimestamps: connect.NewClient[emptypb.Empty, v1.ListTimestampsResponse](
-			httpClient,
-			baseURL+MiscServiceListTimestampsProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("ListTimestamps")),
-			connect.WithClientOptions(opts...),
-		),
-		verifyTimestamp: connect.NewClient[v1.VerifyTimestampRequest, v1.VerifyTimestampResponse](
-			httpClient,
-			baseURL+MiscServiceVerifyTimestampProcedure,
-			connect.WithSchema(miscServiceMethods.ByName("VerifyTimestamp")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// miscServiceClient implements MiscServiceClient.
-type miscServiceClient struct {
-	listOPReturn    *connect.Client[emptypb.Empty, v1.ListOPReturnResponse]
-	broadcastNews   *connect.Client[v1.BroadcastNewsRequest, v1.BroadcastNewsResponse]
-	upvoteNews      *connect.Client[v1.UpvoteNewsRequest, v1.UpvoteNewsResponse]
-	downvoteNews    *connect.Client[v1.UpvoteNewsRequest, v1.UpvoteNewsResponse]
-	createTopic     *connect.Client[v1.CreateTopicRequest, v1.CreateTopicResponse]
-	listTopics      *connect.Client[emptypb.Empty, v1.ListTopicsResponse]
-	listCoinNews    *connect.Client[v1.ListCoinNewsRequest, v1.ListCoinNewsResponse]
-	commentNews     *connect.Client[v1.CommentNewsRequest, v1.CommentNewsResponse]
-	listComments    *connect.Client[v1.ListCommentsRequest, v1.ListCommentsResponse]
-	estimateNewsFee *connect.Client[v1.EstimateNewsFeeRequest, v1.EstimateNewsFeeResponse]
-	timestampFile   *connect.Client[v1.TimestampFileRequest, v1.TimestampFileResponse]
-	listTimestamps  *connect.Client[emptypb.Empty, v1.ListTimestampsResponse]
-	verifyTimestamp *connect.Client[v1.VerifyTimestampRequest, v1.VerifyTimestampResponse]
+	ListOPReturn(context.Context, *emptypb.Empty) (*v1.ListOPReturnResponse, error)
+	BroadcastNews(context.Context, *v1.BroadcastNewsRequest) (*v1.BroadcastNewsResponse, error)
+	UpvoteNews(context.Context, *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error)
+	DownvoteNews(context.Context, *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error)
+	CreateTopic(context.Context, *v1.CreateTopicRequest) (*v1.CreateTopicResponse, error)
+	ListTopics(context.Context, *emptypb.Empty) (*v1.ListTopicsResponse, error)
+	ListCoinNews(context.Context, *v1.ListCoinNewsRequest) (*v1.ListCoinNewsResponse, error)
+	CommentNews(context.Context, *v1.CommentNewsRequest) (*v1.CommentNewsResponse, error)
+	ListComments(context.Context, *v1.ListCommentsRequest) (*v1.ListCommentsResponse, error)
+	EstimateNewsFee(context.Context, *v1.EstimateNewsFeeRequest) (*v1.EstimateNewsFeeResponse, error)
+	TimestampFile(context.Context, *v1.TimestampFileRequest) (*v1.TimestampFileResponse, error)
+	ListTimestamps(context.Context, *emptypb.Empty) (*v1.ListTimestampsResponse, error)
+	VerifyTimestamp(context.Context, *v1.VerifyTimestampRequest) (*v1.VerifyTimestampResponse, error)
 }
 
-// ListOPReturn calls misc.v1.MiscService.ListOPReturn.
-func (c *miscServiceClient) ListOPReturn(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListOPReturnResponse], error) {
-	return c.listOPReturn.CallUnary(ctx, req)
+// NewMiscServiceClient constructs a client for the misc.v1.MiscService service. Multiple service
+// clients may share a single connect.Client.
+func NewMiscServiceClient(client *connect.Client) MiscServiceClient {
+	return &miscServiceClient{client: client}
 }
 
-// BroadcastNews calls misc.v1.MiscService.BroadcastNews.
-func (c *miscServiceClient) BroadcastNews(ctx context.Context, req *connect.Request[v1.BroadcastNewsRequest]) (*connect.Response[v1.BroadcastNewsResponse], error) {
-	return c.broadcastNews.CallUnary(ctx, req)
+// MiscServiceHandler is an implementation of the misc.v1.MiscService service.
+type MiscServiceHandler interface {
+	ListOPReturn(context.Context, *emptypb.Empty) (*v1.ListOPReturnResponse, error)
+	BroadcastNews(context.Context, *v1.BroadcastNewsRequest) (*v1.BroadcastNewsResponse, error)
+	UpvoteNews(context.Context, *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error)
+	DownvoteNews(context.Context, *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error)
+	CreateTopic(context.Context, *v1.CreateTopicRequest) (*v1.CreateTopicResponse, error)
+	ListTopics(context.Context, *emptypb.Empty) (*v1.ListTopicsResponse, error)
+	ListCoinNews(context.Context, *v1.ListCoinNewsRequest) (*v1.ListCoinNewsResponse, error)
+	CommentNews(context.Context, *v1.CommentNewsRequest) (*v1.CommentNewsResponse, error)
+	ListComments(context.Context, *v1.ListCommentsRequest) (*v1.ListCommentsResponse, error)
+	EstimateNewsFee(context.Context, *v1.EstimateNewsFeeRequest) (*v1.EstimateNewsFeeResponse, error)
+	TimestampFile(context.Context, *v1.TimestampFileRequest) (*v1.TimestampFileResponse, error)
+	ListTimestamps(context.Context, *emptypb.Empty) (*v1.ListTimestampsResponse, error)
+	VerifyTimestamp(context.Context, *v1.VerifyTimestampRequest) (*v1.VerifyTimestampResponse, error)
 }
 
-// UpvoteNews calls misc.v1.MiscService.UpvoteNews.
-func (c *miscServiceClient) UpvoteNews(ctx context.Context, req *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error) {
-	return c.upvoteNews.CallUnary(ctx, req)
+// RegisterMiscServiceHandler registers svc as the misc.v1.MiscService implementation on server.
+func RegisterMiscServiceHandler(server *connect.Server, svc MiscServiceHandler) {
+	adapter := miscServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: miscServiceListOPReturnSpec(), Handler: adapter.listOPReturn},
+		connect.Method{Spec: miscServiceBroadcastNewsSpec(), Handler: adapter.broadcastNews},
+		connect.Method{Spec: miscServiceUpvoteNewsSpec(), Handler: adapter.upvoteNews},
+		connect.Method{Spec: miscServiceDownvoteNewsSpec(), Handler: adapter.downvoteNews},
+		connect.Method{Spec: miscServiceCreateTopicSpec(), Handler: adapter.createTopic},
+		connect.Method{Spec: miscServiceListTopicsSpec(), Handler: adapter.listTopics},
+		connect.Method{Spec: miscServiceListCoinNewsSpec(), Handler: adapter.listCoinNews},
+		connect.Method{Spec: miscServiceCommentNewsSpec(), Handler: adapter.commentNews},
+		connect.Method{Spec: miscServiceListCommentsSpec(), Handler: adapter.listComments},
+		connect.Method{Spec: miscServiceEstimateNewsFeeSpec(), Handler: adapter.estimateNewsFee},
+		connect.Method{Spec: miscServiceTimestampFileSpec(), Handler: adapter.timestampFile},
+		connect.Method{Spec: miscServiceListTimestampsSpec(), Handler: adapter.listTimestamps},
+		connect.Method{Spec: miscServiceVerifyTimestampSpec(), Handler: adapter.verifyTimestamp},
+	)
 }
 
-// DownvoteNews calls misc.v1.MiscService.DownvoteNews.
-func (c *miscServiceClient) DownvoteNews(ctx context.Context, req *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error) {
-	return c.downvoteNews.CallUnary(ctx, req)
+// UnimplementedMiscServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedMiscServiceHandler struct{}
+
+func (UnimplementedMiscServiceHandler) ListOPReturn(context.Context, *emptypb.Empty) (*v1.ListOPReturnResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.ListOPReturn is not implemented")
 }
 
-// CreateTopic calls misc.v1.MiscService.CreateTopic.
-func (c *miscServiceClient) CreateTopic(ctx context.Context, req *connect.Request[v1.CreateTopicRequest]) (*connect.Response[v1.CreateTopicResponse], error) {
-	return c.createTopic.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) BroadcastNews(context.Context, *v1.BroadcastNewsRequest) (*v1.BroadcastNewsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.BroadcastNews is not implemented")
 }
 
-// ListTopics calls misc.v1.MiscService.ListTopics.
-func (c *miscServiceClient) ListTopics(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error) {
-	return c.listTopics.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) UpvoteNews(context.Context, *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.UpvoteNews is not implemented")
 }
 
-// ListCoinNews calls misc.v1.MiscService.ListCoinNews.
-func (c *miscServiceClient) ListCoinNews(ctx context.Context, req *connect.Request[v1.ListCoinNewsRequest]) (*connect.Response[v1.ListCoinNewsResponse], error) {
-	return c.listCoinNews.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) DownvoteNews(context.Context, *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.DownvoteNews is not implemented")
 }
 
-// CommentNews calls misc.v1.MiscService.CommentNews.
-func (c *miscServiceClient) CommentNews(ctx context.Context, req *connect.Request[v1.CommentNewsRequest]) (*connect.Response[v1.CommentNewsResponse], error) {
-	return c.commentNews.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) CreateTopic(context.Context, *v1.CreateTopicRequest) (*v1.CreateTopicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.CreateTopic is not implemented")
 }
 
-// ListComments calls misc.v1.MiscService.ListComments.
-func (c *miscServiceClient) ListComments(ctx context.Context, req *connect.Request[v1.ListCommentsRequest]) (*connect.Response[v1.ListCommentsResponse], error) {
-	return c.listComments.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) ListTopics(context.Context, *emptypb.Empty) (*v1.ListTopicsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.ListTopics is not implemented")
 }
 
-// EstimateNewsFee calls misc.v1.MiscService.EstimateNewsFee.
-func (c *miscServiceClient) EstimateNewsFee(ctx context.Context, req *connect.Request[v1.EstimateNewsFeeRequest]) (*connect.Response[v1.EstimateNewsFeeResponse], error) {
-	return c.estimateNewsFee.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) ListCoinNews(context.Context, *v1.ListCoinNewsRequest) (*v1.ListCoinNewsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.ListCoinNews is not implemented")
 }
 
-// TimestampFile calls misc.v1.MiscService.TimestampFile.
-func (c *miscServiceClient) TimestampFile(ctx context.Context, req *connect.Request[v1.TimestampFileRequest]) (*connect.Response[v1.TimestampFileResponse], error) {
-	return c.timestampFile.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) CommentNews(context.Context, *v1.CommentNewsRequest) (*v1.CommentNewsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.CommentNews is not implemented")
 }
 
-// ListTimestamps calls misc.v1.MiscService.ListTimestamps.
-func (c *miscServiceClient) ListTimestamps(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTimestampsResponse], error) {
-	return c.listTimestamps.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) ListComments(context.Context, *v1.ListCommentsRequest) (*v1.ListCommentsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.ListComments is not implemented")
 }
 
-// VerifyTimestamp calls misc.v1.MiscService.VerifyTimestamp.
-func (c *miscServiceClient) VerifyTimestamp(ctx context.Context, req *connect.Request[v1.VerifyTimestampRequest]) (*connect.Response[v1.VerifyTimestampResponse], error) {
-	return c.verifyTimestamp.CallUnary(ctx, req)
+func (UnimplementedMiscServiceHandler) EstimateNewsFee(context.Context, *v1.EstimateNewsFeeRequest) (*v1.EstimateNewsFeeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.EstimateNewsFee is not implemented")
 }
 
-// MiscServiceHandler is an implementation of the misc.v1.MiscService service.
-type MiscServiceHandler interface {
-	ListOPReturn(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListOPReturnResponse], error)
-	BroadcastNews(context.Context, *connect.Request[v1.BroadcastNewsRequest]) (*connect.Response[v1.BroadcastNewsResponse], error)
-	// Broadcasts a signed upvote (CoinNews Vote, kind=0x04) targeting a story.
-	UpvoteNews(context.Context, *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error)
-	// Broadcasts a signed downvote (CoinNews Vote, kind=0x05) targeting a story.
-	DownvoteNews(context.Context, *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error)
-	CreateTopic(context.Context, *connect.Request[v1.CreateTopicRequest]) (*connect.Response[v1.CreateTopicResponse], error)
-	ListTopics(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error)
-	ListCoinNews(context.Context, *connect.Request[v1.ListCoinNewsRequest]) (*connect.Response[v1.ListCoinNewsResponse], error)
-	// Broadcasts a signed Comment (CoinNews Comment, 0x03) on an Item.
-	CommentNews(context.Context, *connect.Request[v1.CommentNewsRequest]) (*connect.Response[v1.CommentNewsResponse], error)
-	// Returns the full reply thread rooted at an Item, ranked per §13.
-	ListComments(context.Context, *connect.Request[v1.ListCommentsRequest]) (*connect.Response[v1.ListCommentsResponse], error)
-	// What a vote or comment would cost to broadcast. Builds nothing.
-	EstimateNewsFee(context.Context, *connect.Request[v1.EstimateNewsFeeRequest]) (*connect.Response[v1.EstimateNewsFeeResponse], error)
-	// File timestamping
-	TimestampFile(context.Context, *connect.Request[v1.TimestampFileRequest]) (*connect.Response[v1.TimestampFileResponse], error)
-	ListTimestamps(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTimestampsResponse], error)
-	VerifyTimestamp(context.Context, *connect.Request[v1.VerifyTimestampRequest]) (*connect.Response[v1.VerifyTimestampResponse], error)
-}
-
-// NewMiscServiceHandler builds an HTTP handler from the service implementation. It returns the path
-// on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewMiscServiceHandler(svc MiscServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	miscServiceMethods := v1.File_misc_v1_misc_proto.Services().ByName("MiscService").Methods()
-	miscServiceListOPReturnHandler := connect.NewUnaryHandler(
-		MiscServiceListOPReturnProcedure,
-		svc.ListOPReturn,
-		connect.WithSchema(miscServiceMethods.ByName("ListOPReturn")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceBroadcastNewsHandler := connect.NewUnaryHandler(
-		MiscServiceBroadcastNewsProcedure,
-		svc.BroadcastNews,
-		connect.WithSchema(miscServiceMethods.ByName("BroadcastNews")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceUpvoteNewsHandler := connect.NewUnaryHandler(
-		MiscServiceUpvoteNewsProcedure,
-		svc.UpvoteNews,
-		connect.WithSchema(miscServiceMethods.ByName("UpvoteNews")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceDownvoteNewsHandler := connect.NewUnaryHandler(
-		MiscServiceDownvoteNewsProcedure,
-		svc.DownvoteNews,
-		connect.WithSchema(miscServiceMethods.ByName("DownvoteNews")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceCreateTopicHandler := connect.NewUnaryHandler(
-		MiscServiceCreateTopicProcedure,
-		svc.CreateTopic,
-		connect.WithSchema(miscServiceMethods.ByName("CreateTopic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceListTopicsHandler := connect.NewUnaryHandler(
-		MiscServiceListTopicsProcedure,
-		svc.ListTopics,
-		connect.WithSchema(miscServiceMethods.ByName("ListTopics")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceListCoinNewsHandler := connect.NewUnaryHandler(
-		MiscServiceListCoinNewsProcedure,
-		svc.ListCoinNews,
-		connect.WithSchema(miscServiceMethods.ByName("ListCoinNews")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceCommentNewsHandler := connect.NewUnaryHandler(
-		MiscServiceCommentNewsProcedure,
-		svc.CommentNews,
-		connect.WithSchema(miscServiceMethods.ByName("CommentNews")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceListCommentsHandler := connect.NewUnaryHandler(
-		MiscServiceListCommentsProcedure,
-		svc.ListComments,
-		connect.WithSchema(miscServiceMethods.ByName("ListComments")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceEstimateNewsFeeHandler := connect.NewUnaryHandler(
-		MiscServiceEstimateNewsFeeProcedure,
-		svc.EstimateNewsFee,
-		connect.WithSchema(miscServiceMethods.ByName("EstimateNewsFee")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceTimestampFileHandler := connect.NewUnaryHandler(
-		MiscServiceTimestampFileProcedure,
-		svc.TimestampFile,
-		connect.WithSchema(miscServiceMethods.ByName("TimestampFile")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceListTimestampsHandler := connect.NewUnaryHandler(
-		MiscServiceListTimestampsProcedure,
-		svc.ListTimestamps,
-		connect.WithSchema(miscServiceMethods.ByName("ListTimestamps")),
-		connect.WithHandlerOptions(opts...),
-	)
-	miscServiceVerifyTimestampHandler := connect.NewUnaryHandler(
-		MiscServiceVerifyTimestampProcedure,
-		svc.VerifyTimestamp,
-		connect.WithSchema(miscServiceMethods.ByName("VerifyTimestamp")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/misc.v1.MiscService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case MiscServiceListOPReturnProcedure:
-			miscServiceListOPReturnHandler.ServeHTTP(w, r)
-		case MiscServiceBroadcastNewsProcedure:
-			miscServiceBroadcastNewsHandler.ServeHTTP(w, r)
-		case MiscServiceUpvoteNewsProcedure:
-			miscServiceUpvoteNewsHandler.ServeHTTP(w, r)
-		case MiscServiceDownvoteNewsProcedure:
-			miscServiceDownvoteNewsHandler.ServeHTTP(w, r)
-		case MiscServiceCreateTopicProcedure:
-			miscServiceCreateTopicHandler.ServeHTTP(w, r)
-		case MiscServiceListTopicsProcedure:
-			miscServiceListTopicsHandler.ServeHTTP(w, r)
-		case MiscServiceListCoinNewsProcedure:
-			miscServiceListCoinNewsHandler.ServeHTTP(w, r)
-		case MiscServiceCommentNewsProcedure:
-			miscServiceCommentNewsHandler.ServeHTTP(w, r)
-		case MiscServiceListCommentsProcedure:
-			miscServiceListCommentsHandler.ServeHTTP(w, r)
-		case MiscServiceEstimateNewsFeeProcedure:
-			miscServiceEstimateNewsFeeHandler.ServeHTTP(w, r)
-		case MiscServiceTimestampFileProcedure:
-			miscServiceTimestampFileHandler.ServeHTTP(w, r)
-		case MiscServiceListTimestampsProcedure:
-			miscServiceListTimestampsHandler.ServeHTTP(w, r)
-		case MiscServiceVerifyTimestampProcedure:
-			miscServiceVerifyTimestampHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedMiscServiceHandler) TimestampFile(context.Context, *v1.TimestampFileRequest) (*v1.TimestampFileResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.TimestampFile is not implemented")
 }
 
-// UnimplementedMiscServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedMiscServiceHandler struct{}
+func (UnimplementedMiscServiceHandler) ListTimestamps(context.Context, *emptypb.Empty) (*v1.ListTimestampsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.ListTimestamps is not implemented")
+}
 
-func (UnimplementedMiscServiceHandler) ListOPReturn(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListOPReturnResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.ListOPReturn is not implemented"))
+func (UnimplementedMiscServiceHandler) VerifyTimestamp(context.Context, *v1.VerifyTimestampRequest) (*v1.VerifyTimestampResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "misc.v1.MiscService.VerifyTimestamp is not implemented")
 }
 
-func (UnimplementedMiscServiceHandler) BroadcastNews(context.Context, *connect.Request[v1.BroadcastNewsRequest]) (*connect.Response[v1.BroadcastNewsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.BroadcastNews is not implemented"))
+type miscServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedMiscServiceHandler) UpvoteNews(context.Context, *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.UpvoteNews is not implemented"))
+func (c *miscServiceClient) ListOPReturn(ctx context.Context, req *emptypb.Empty) (*v1.ListOPReturnResponse, error) {
+	var res v1.ListOPReturnResponse
+	if err := c.client.CallUnary(ctx, miscServiceListOPReturnSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMiscServiceHandler) DownvoteNews(context.Context, *connect.Request[v1.UpvoteNewsRequest]) (*connect.Response[v1.UpvoteNewsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.DownvoteNews is not implemented"))
+func (c *miscServiceClient) BroadcastNews(ctx context.Context, req *v1.BroadcastNewsRequest) (*v1.BroadcastNewsResponse, error) {
+	var res v1.BroadcastNewsResponse
+	if err := c.client.CallUnary(ctx, miscServiceBroadcastNewsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMiscServiceHandler) CreateTopic(context.Context, *connect.Request[v1.CreateTopicRequest]) (*connect.Response[v1.CreateTopicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.CreateTopic is not implemented"))
+func (c *miscServiceClient) UpvoteNews(ctx context.Context, req *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error) {
+	var res v1.UpvoteNewsResponse
+	if err := c.client.CallUnary(ctx, miscServiceUpvoteNewsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) DownvoteNews(ctx context.Context, req *v1.UpvoteNewsRequest) (*v1.UpvoteNewsResponse, error) {
+	var res v1.UpvoteNewsResponse
+	if err := c.client.CallUnary(ctx, miscServiceDownvoteNewsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) CreateTopic(ctx context.Context, req *v1.CreateTopicRequest) (*v1.CreateTopicResponse, error) {
+	var res v1.CreateTopicResponse
+	if err := c.client.CallUnary(ctx, miscServiceCreateTopicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) ListTopics(ctx context.Context, req *emptypb.Empty) (*v1.ListTopicsResponse, error) {
+	var res v1.ListTopicsResponse
+	if err := c.client.CallUnary(ctx, miscServiceListTopicsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) ListCoinNews(ctx context.Context, req *v1.ListCoinNewsRequest) (*v1.ListCoinNewsResponse, error) {
+	var res v1.ListCoinNewsResponse
+	if err := c.client.CallUnary(ctx, miscServiceListCoinNewsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) CommentNews(ctx context.Context, req *v1.CommentNewsRequest) (*v1.CommentNewsResponse, error) {
+	var res v1.CommentNewsResponse
+	if err := c.client.CallUnary(ctx, miscServiceCommentNewsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) ListComments(ctx context.Context, req *v1.ListCommentsRequest) (*v1.ListCommentsResponse, error) {
+	var res v1.ListCommentsResponse
+	if err := c.client.CallUnary(ctx, miscServiceListCommentsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) EstimateNewsFee(ctx context.Context, req *v1.EstimateNewsFeeRequest) (*v1.EstimateNewsFeeResponse, error) {
+	var res v1.EstimateNewsFeeResponse
+	if err := c.client.CallUnary(ctx, miscServiceEstimateNewsFeeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) TimestampFile(ctx context.Context, req *v1.TimestampFileRequest) (*v1.TimestampFileResponse, error) {
+	var res v1.TimestampFileResponse
+	if err := c.client.CallUnary(ctx, miscServiceTimestampFileSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) ListTimestamps(ctx context.Context, req *emptypb.Empty) (*v1.ListTimestampsResponse, error) {
+	var res v1.ListTimestampsResponse
+	if err := c.client.CallUnary(ctx, miscServiceListTimestampsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *miscServiceClient) VerifyTimestamp(ctx context.Context, req *v1.VerifyTimestampRequest) (*v1.VerifyTimestampResponse, error) {
+	var res v1.VerifyTimestampResponse
+	if err := c.client.CallUnary(ctx, miscServiceVerifyTimestampSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type miscServiceHandler struct{ svc MiscServiceHandler }
+
+func (h miscServiceHandler) listOPReturn(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListOPReturn(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h miscServiceHandler) broadcastNews(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BroadcastNewsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BroadcastNews(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h miscServiceHandler) upvoteNews(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UpvoteNewsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UpvoteNews(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h miscServiceHandler) downvoteNews(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UpvoteNewsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DownvoteNews(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h miscServiceHandler) createTopic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateTopicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateTopic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) ListTopics(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.ListTopics is not implemented"))
+func (h miscServiceHandler) listTopics(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTopics(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) ListCoinNews(context.Context, *connect.Request[v1.ListCoinNewsRequest]) (*connect.Response[v1.ListCoinNewsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.ListCoinNews is not implemented"))
+func (h miscServiceHandler) listCoinNews(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListCoinNewsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListCoinNews(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) CommentNews(context.Context, *connect.Request[v1.CommentNewsRequest]) (*connect.Response[v1.CommentNewsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.CommentNews is not implemented"))
+func (h miscServiceHandler) commentNews(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CommentNewsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CommentNews(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) ListComments(context.Context, *connect.Request[v1.ListCommentsRequest]) (*connect.Response[v1.ListCommentsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.ListComments is not implemented"))
+func (h miscServiceHandler) listComments(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListCommentsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListComments(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) EstimateNewsFee(context.Context, *connect.Request[v1.EstimateNewsFeeRequest]) (*connect.Response[v1.EstimateNewsFeeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.EstimateNewsFee is not implemented"))
+func (h miscServiceHandler) estimateNewsFee(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EstimateNewsFeeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EstimateNewsFee(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) TimestampFile(context.Context, *connect.Request[v1.TimestampFileRequest]) (*connect.Response[v1.TimestampFileResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.TimestampFile is not implemented"))
+func (h miscServiceHandler) timestampFile(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TimestampFileRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.TimestampFile(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) ListTimestamps(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTimestampsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.ListTimestamps is not implemented"))
+func (h miscServiceHandler) listTimestamps(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTimestamps(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMiscServiceHandler) VerifyTimestamp(context.Context, *connect.Request[v1.VerifyTimestampRequest]) (*connect.Response[v1.VerifyTimestampResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("misc.v1.MiscService.VerifyTimestamp is not implemented"))
+func (h miscServiceHandler) verifyTimestamp(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VerifyTimestampRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VerifyTimestamp(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/multisig/v1/multisigv1connect/multisig.connect.go b/bitwindow/server/gen/multisig/v1/multisigv1connect/multisig.connect.go
index 7aa6ab905a..22d11730fc 100644
--- a/bitwindow/server/gen/multisig/v1/multisigv1connect/multisig.connect.go
+++ b/bitwindow/server/gen/multisig/v1/multisigv1connect/multisig.connect.go
@@ -5,375 +5,425 @@
 package multisigv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/multisig/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// MultisigServiceName is the fully-qualified name of the MultisigService service.
 	MultisigServiceName = "multisig.v1.MultisigService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// MultisigServiceListGroupsProcedure is the fully-qualified name of the MultisigService's
-	// ListGroups RPC.
+	// MultisigServiceListGroupsProcedure is the procedure name of the MultisigService's ListGroups RPC.
 	MultisigServiceListGroupsProcedure = "/multisig.v1.MultisigService/ListGroups"
-	// MultisigServiceSaveGroupProcedure is the fully-qualified name of the MultisigService's SaveGroup
-	// RPC.
+	// MultisigServiceSaveGroupProcedure is the procedure name of the MultisigService's SaveGroup RPC.
 	MultisigServiceSaveGroupProcedure = "/multisig.v1.MultisigService/SaveGroup"
-	// MultisigServiceDeleteGroupProcedure is the fully-qualified name of the MultisigService's
-	// DeleteGroup RPC.
+	// MultisigServiceDeleteGroupProcedure is the procedure name of the MultisigService's DeleteGroup
+	// RPC.
 	MultisigServiceDeleteGroupProcedure = "/multisig.v1.MultisigService/DeleteGroup"
-	// MultisigServiceListTransactionsProcedure is the fully-qualified name of the MultisigService's
+	// MultisigServiceListTransactionsProcedure is the procedure name of the MultisigService's
 	// ListTransactions RPC.
 	MultisigServiceListTransactionsProcedure = "/multisig.v1.MultisigService/ListTransactions"
-	// MultisigServiceGetTransactionProcedure is the fully-qualified name of the MultisigService's
+	// MultisigServiceGetTransactionProcedure is the procedure name of the MultisigService's
 	// GetTransaction RPC.
 	MultisigServiceGetTransactionProcedure = "/multisig.v1.MultisigService/GetTransaction"
-	// MultisigServiceGetTransactionByTxidProcedure is the fully-qualified name of the MultisigService's
+	// MultisigServiceGetTransactionByTxidProcedure is the procedure name of the MultisigService's
 	// GetTransactionByTxid RPC.
 	MultisigServiceGetTransactionByTxidProcedure = "/multisig.v1.MultisigService/GetTransactionByTxid"
-	// MultisigServiceSaveTransactionProcedure is the fully-qualified name of the MultisigService's
+	// MultisigServiceSaveTransactionProcedure is the procedure name of the MultisigService's
 	// SaveTransaction RPC.
 	MultisigServiceSaveTransactionProcedure = "/multisig.v1.MultisigService/SaveTransaction"
-	// MultisigServiceListSoloKeysProcedure is the fully-qualified name of the MultisigService's
-	// ListSoloKeys RPC.
+	// MultisigServiceListSoloKeysProcedure is the procedure name of the MultisigService's ListSoloKeys
+	// RPC.
 	MultisigServiceListSoloKeysProcedure = "/multisig.v1.MultisigService/ListSoloKeys"
-	// MultisigServiceAddSoloKeyProcedure is the fully-qualified name of the MultisigService's
-	// AddSoloKey RPC.
+	// MultisigServiceAddSoloKeyProcedure is the procedure name of the MultisigService's AddSoloKey RPC.
 	MultisigServiceAddSoloKeyProcedure = "/multisig.v1.MultisigService/AddSoloKey"
-	// MultisigServiceGetNextAccountIndexProcedure is the fully-qualified name of the MultisigService's
+	// MultisigServiceGetNextAccountIndexProcedure is the procedure name of the MultisigService's
 	// GetNextAccountIndex RPC.
 	MultisigServiceGetNextAccountIndexProcedure = "/multisig.v1.MultisigService/GetNextAccountIndex"
 )
 
+var (
+	multisigServiceListGroupsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("ListGroups"),
+			Procedure:  MultisigServiceListGroupsProcedure,
+		}
+	})
+	multisigServiceSaveGroupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("SaveGroup"),
+			Procedure:  MultisigServiceSaveGroupProcedure,
+		}
+	})
+	multisigServiceDeleteGroupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("DeleteGroup"),
+			Procedure:  MultisigServiceDeleteGroupProcedure,
+		}
+	})
+	multisigServiceListTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("ListTransactions"),
+			Procedure:  MultisigServiceListTransactionsProcedure,
+		}
+	})
+	multisigServiceGetTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("GetTransaction"),
+			Procedure:  MultisigServiceGetTransactionProcedure,
+		}
+	})
+	multisigServiceGetTransactionByTxidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("GetTransactionByTxid"),
+			Procedure:  MultisigServiceGetTransactionByTxidProcedure,
+		}
+	})
+	multisigServiceSaveTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("SaveTransaction"),
+			Procedure:  MultisigServiceSaveTransactionProcedure,
+		}
+	})
+	multisigServiceListSoloKeysSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("ListSoloKeys"),
+			Procedure:  MultisigServiceListSoloKeysProcedure,
+		}
+	})
+	multisigServiceAddSoloKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("AddSoloKey"),
+			Procedure:  MultisigServiceAddSoloKeyProcedure,
+		}
+	})
+	multisigServiceGetNextAccountIndexSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods().ByName("GetNextAccountIndex"),
+			Procedure:  MultisigServiceGetNextAccountIndexProcedure,
+		}
+	})
+)
+
 // MultisigServiceClient is a client for the multisig.v1.MultisigService service.
 type MultisigServiceClient interface {
-	// Group CRUD
-	ListGroups(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListGroupsResponse], error)
-	SaveGroup(context.Context, *connect.Request[v1.SaveGroupRequest]) (*connect.Response[v1.SaveGroupResponse], error)
-	DeleteGroup(context.Context, *connect.Request[v1.DeleteGroupRequest]) (*connect.Response[emptypb.Empty], error)
-	// Transaction CRUD
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.MultisigTransaction], error)
-	GetTransactionByTxid(context.Context, *connect.Request[v1.GetTransactionByTxidRequest]) (*connect.Response[v1.MultisigTransaction], error)
-	SaveTransaction(context.Context, *connect.Request[v1.SaveTransactionRequest]) (*connect.Response[v1.SaveTransactionResponse], error)
-	// Solo key management
-	ListSoloKeys(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListSoloKeysResponse], error)
-	AddSoloKey(context.Context, *connect.Request[v1.AddSoloKeyRequest]) (*connect.Response[emptypb.Empty], error)
-	// Account index
-	GetNextAccountIndex(context.Context, *connect.Request[v1.GetNextAccountIndexRequest]) (*connect.Response[v1.GetNextAccountIndexResponse], error)
-}
-
-// NewMultisigServiceClient constructs a client for the multisig.v1.MultisigService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewMultisigServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) MultisigServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	multisigServiceMethods := v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods()
-	return &multisigServiceClient{
-		listGroups: connect.NewClient[emptypb.Empty, v1.ListGroupsResponse](
-			httpClient,
-			baseURL+MultisigServiceListGroupsProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("ListGroups")),
-			connect.WithClientOptions(opts...),
-		),
-		saveGroup: connect.NewClient[v1.SaveGroupRequest, v1.SaveGroupResponse](
-			httpClient,
-			baseURL+MultisigServiceSaveGroupProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("SaveGroup")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteGroup: connect.NewClient[v1.DeleteGroupRequest, emptypb.Empty](
-			httpClient,
-			baseURL+MultisigServiceDeleteGroupProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("DeleteGroup")),
-			connect.WithClientOptions(opts...),
-		),
-		listTransactions: connect.NewClient[v1.ListTransactionsRequest, v1.ListTransactionsResponse](
-			httpClient,
-			baseURL+MultisigServiceListTransactionsProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("ListTransactions")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransaction: connect.NewClient[v1.GetTransactionRequest, v1.MultisigTransaction](
-			httpClient,
-			baseURL+MultisigServiceGetTransactionProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("GetTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransactionByTxid: connect.NewClient[v1.GetTransactionByTxidRequest, v1.MultisigTransaction](
-			httpClient,
-			baseURL+MultisigServiceGetTransactionByTxidProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("GetTransactionByTxid")),
-			connect.WithClientOptions(opts...),
-		),
-		saveTransaction: connect.NewClient[v1.SaveTransactionRequest, v1.SaveTransactionResponse](
-			httpClient,
-			baseURL+MultisigServiceSaveTransactionProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("SaveTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		listSoloKeys: connect.NewClient[emptypb.Empty, v1.ListSoloKeysResponse](
-			httpClient,
-			baseURL+MultisigServiceListSoloKeysProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("ListSoloKeys")),
-			connect.WithClientOptions(opts...),
-		),
-		addSoloKey: connect.NewClient[v1.AddSoloKeyRequest, emptypb.Empty](
-			httpClient,
-			baseURL+MultisigServiceAddSoloKeyProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("AddSoloKey")),
-			connect.WithClientOptions(opts...),
-		),
-		getNextAccountIndex: connect.NewClient[v1.GetNextAccountIndexRequest, v1.GetNextAccountIndexResponse](
-			httpClient,
-			baseURL+MultisigServiceGetNextAccountIndexProcedure,
-			connect.WithSchema(multisigServiceMethods.ByName("GetNextAccountIndex")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+	ListGroups(context.Context, *emptypb.Empty) (*v1.ListGroupsResponse, error)
+	SaveGroup(context.Context, *v1.SaveGroupRequest) (*v1.SaveGroupResponse, error)
+	DeleteGroup(context.Context, *v1.DeleteGroupRequest) (*emptypb.Empty, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.MultisigTransaction, error)
+	GetTransactionByTxid(context.Context, *v1.GetTransactionByTxidRequest) (*v1.MultisigTransaction, error)
+	SaveTransaction(context.Context, *v1.SaveTransactionRequest) (*v1.SaveTransactionResponse, error)
+	ListSoloKeys(context.Context, *emptypb.Empty) (*v1.ListSoloKeysResponse, error)
+	AddSoloKey(context.Context, *v1.AddSoloKeyRequest) (*emptypb.Empty, error)
+	GetNextAccountIndex(context.Context, *v1.GetNextAccountIndexRequest) (*v1.GetNextAccountIndexResponse, error)
 }
 
-// multisigServiceClient implements MultisigServiceClient.
-type multisigServiceClient struct {
-	listGroups           *connect.Client[emptypb.Empty, v1.ListGroupsResponse]
-	saveGroup            *connect.Client[v1.SaveGroupRequest, v1.SaveGroupResponse]
-	deleteGroup          *connect.Client[v1.DeleteGroupRequest, emptypb.Empty]
-	listTransactions     *connect.Client[v1.ListTransactionsRequest, v1.ListTransactionsResponse]
-	getTransaction       *connect.Client[v1.GetTransactionRequest, v1.MultisigTransaction]
-	getTransactionByTxid *connect.Client[v1.GetTransactionByTxidRequest, v1.MultisigTransaction]
-	saveTransaction      *connect.Client[v1.SaveTransactionRequest, v1.SaveTransactionResponse]
-	listSoloKeys         *connect.Client[emptypb.Empty, v1.ListSoloKeysResponse]
-	addSoloKey           *connect.Client[v1.AddSoloKeyRequest, emptypb.Empty]
-	getNextAccountIndex  *connect.Client[v1.GetNextAccountIndexRequest, v1.GetNextAccountIndexResponse]
+// NewMultisigServiceClient constructs a client for the multisig.v1.MultisigService service.
+// Multiple service clients may share a single connect.Client.
+func NewMultisigServiceClient(client *connect.Client) MultisigServiceClient {
+	return &multisigServiceClient{client: client}
 }
 
-// ListGroups calls multisig.v1.MultisigService.ListGroups.
-func (c *multisigServiceClient) ListGroups(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListGroupsResponse], error) {
-	return c.listGroups.CallUnary(ctx, req)
+// MultisigServiceHandler is an implementation of the multisig.v1.MultisigService service.
+type MultisigServiceHandler interface {
+	ListGroups(context.Context, *emptypb.Empty) (*v1.ListGroupsResponse, error)
+	SaveGroup(context.Context, *v1.SaveGroupRequest) (*v1.SaveGroupResponse, error)
+	DeleteGroup(context.Context, *v1.DeleteGroupRequest) (*emptypb.Empty, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.MultisigTransaction, error)
+	GetTransactionByTxid(context.Context, *v1.GetTransactionByTxidRequest) (*v1.MultisigTransaction, error)
+	SaveTransaction(context.Context, *v1.SaveTransactionRequest) (*v1.SaveTransactionResponse, error)
+	ListSoloKeys(context.Context, *emptypb.Empty) (*v1.ListSoloKeysResponse, error)
+	AddSoloKey(context.Context, *v1.AddSoloKeyRequest) (*emptypb.Empty, error)
+	GetNextAccountIndex(context.Context, *v1.GetNextAccountIndexRequest) (*v1.GetNextAccountIndexResponse, error)
 }
 
-// SaveGroup calls multisig.v1.MultisigService.SaveGroup.
-func (c *multisigServiceClient) SaveGroup(ctx context.Context, req *connect.Request[v1.SaveGroupRequest]) (*connect.Response[v1.SaveGroupResponse], error) {
-	return c.saveGroup.CallUnary(ctx, req)
+// RegisterMultisigServiceHandler registers svc as the multisig.v1.MultisigService implementation on
+// server.
+func RegisterMultisigServiceHandler(server *connect.Server, svc MultisigServiceHandler) {
+	adapter := multisigServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: multisigServiceListGroupsSpec(), Handler: adapter.listGroups},
+		connect.Method{Spec: multisigServiceSaveGroupSpec(), Handler: adapter.saveGroup},
+		connect.Method{Spec: multisigServiceDeleteGroupSpec(), Handler: adapter.deleteGroup},
+		connect.Method{Spec: multisigServiceListTransactionsSpec(), Handler: adapter.listTransactions},
+		connect.Method{Spec: multisigServiceGetTransactionSpec(), Handler: adapter.getTransaction},
+		connect.Method{Spec: multisigServiceGetTransactionByTxidSpec(), Handler: adapter.getTransactionByTxid},
+		connect.Method{Spec: multisigServiceSaveTransactionSpec(), Handler: adapter.saveTransaction},
+		connect.Method{Spec: multisigServiceListSoloKeysSpec(), Handler: adapter.listSoloKeys},
+		connect.Method{Spec: multisigServiceAddSoloKeySpec(), Handler: adapter.addSoloKey},
+		connect.Method{Spec: multisigServiceGetNextAccountIndexSpec(), Handler: adapter.getNextAccountIndex},
+	)
 }
 
-// DeleteGroup calls multisig.v1.MultisigService.DeleteGroup.
-func (c *multisigServiceClient) DeleteGroup(ctx context.Context, req *connect.Request[v1.DeleteGroupRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.deleteGroup.CallUnary(ctx, req)
+// UnimplementedMultisigServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedMultisigServiceHandler struct{}
+
+func (UnimplementedMultisigServiceHandler) ListGroups(context.Context, *emptypb.Empty) (*v1.ListGroupsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.ListGroups is not implemented")
 }
 
-// ListTransactions calls multisig.v1.MultisigService.ListTransactions.
-func (c *multisigServiceClient) ListTransactions(ctx context.Context, req *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return c.listTransactions.CallUnary(ctx, req)
+func (UnimplementedMultisigServiceHandler) SaveGroup(context.Context, *v1.SaveGroupRequest) (*v1.SaveGroupResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.SaveGroup is not implemented")
 }
 
-// GetTransaction calls multisig.v1.MultisigService.GetTransaction.
-func (c *multisigServiceClient) GetTransaction(ctx context.Context, req *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.MultisigTransaction], error) {
-	return c.getTransaction.CallUnary(ctx, req)
+func (UnimplementedMultisigServiceHandler) DeleteGroup(context.Context, *v1.DeleteGroupRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.DeleteGroup is not implemented")
 }
 
-// GetTransactionByTxid calls multisig.v1.MultisigService.GetTransactionByTxid.
-func (c *multisigServiceClient) GetTransactionByTxid(ctx context.Context, req *connect.Request[v1.GetTransactionByTxidRequest]) (*connect.Response[v1.MultisigTransaction], error) {
-	return c.getTransactionByTxid.CallUnary(ctx, req)
+func (UnimplementedMultisigServiceHandler) ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.ListTransactions is not implemented")
 }
 
-// SaveTransaction calls multisig.v1.MultisigService.SaveTransaction.
-func (c *multisigServiceClient) SaveTransaction(ctx context.Context, req *connect.Request[v1.SaveTransactionRequest]) (*connect.Response[v1.SaveTransactionResponse], error) {
-	return c.saveTransaction.CallUnary(ctx, req)
+func (UnimplementedMultisigServiceHandler) GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.MultisigTransaction, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.GetTransaction is not implemented")
 }
 
-// ListSoloKeys calls multisig.v1.MultisigService.ListSoloKeys.
-func (c *multisigServiceClient) ListSoloKeys(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListSoloKeysResponse], error) {
-	return c.listSoloKeys.CallUnary(ctx, req)
+func (UnimplementedMultisigServiceHandler) GetTransactionByTxid(context.Context, *v1.GetTransactionByTxidRequest) (*v1.MultisigTransaction, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.GetTransactionByTxid is not implemented")
 }
 
-// AddSoloKey calls multisig.v1.MultisigService.AddSoloKey.
-func (c *multisigServiceClient) AddSoloKey(ctx context.Context, req *connect.Request[v1.AddSoloKeyRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.addSoloKey.CallUnary(ctx, req)
+func (UnimplementedMultisigServiceHandler) SaveTransaction(context.Context, *v1.SaveTransactionRequest) (*v1.SaveTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.SaveTransaction is not implemented")
 }
 
-// GetNextAccountIndex calls multisig.v1.MultisigService.GetNextAccountIndex.
-func (c *multisigServiceClient) GetNextAccountIndex(ctx context.Context, req *connect.Request[v1.GetNextAccountIndexRequest]) (*connect.Response[v1.GetNextAccountIndexResponse], error) {
-	return c.getNextAccountIndex.CallUnary(ctx, req)
+func (UnimplementedMultisigServiceHandler) ListSoloKeys(context.Context, *emptypb.Empty) (*v1.ListSoloKeysResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.ListSoloKeys is not implemented")
 }
 
-// MultisigServiceHandler is an implementation of the multisig.v1.MultisigService service.
-type MultisigServiceHandler interface {
-	// Group CRUD
-	ListGroups(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListGroupsResponse], error)
-	SaveGroup(context.Context, *connect.Request[v1.SaveGroupRequest]) (*connect.Response[v1.SaveGroupResponse], error)
-	DeleteGroup(context.Context, *connect.Request[v1.DeleteGroupRequest]) (*connect.Response[emptypb.Empty], error)
-	// Transaction CRUD
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.MultisigTransaction], error)
-	GetTransactionByTxid(context.Context, *connect.Request[v1.GetTransactionByTxidRequest]) (*connect.Response[v1.MultisigTransaction], error)
-	SaveTransaction(context.Context, *connect.Request[v1.SaveTransactionRequest]) (*connect.Response[v1.SaveTransactionResponse], error)
-	// Solo key management
-	ListSoloKeys(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListSoloKeysResponse], error)
-	AddSoloKey(context.Context, *connect.Request[v1.AddSoloKeyRequest]) (*connect.Response[emptypb.Empty], error)
-	// Account index
-	GetNextAccountIndex(context.Context, *connect.Request[v1.GetNextAccountIndexRequest]) (*connect.Response[v1.GetNextAccountIndexResponse], error)
-}
-
-// NewMultisigServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewMultisigServiceHandler(svc MultisigServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	multisigServiceMethods := v1.File_multisig_v1_multisig_proto.Services().ByName("MultisigService").Methods()
-	multisigServiceListGroupsHandler := connect.NewUnaryHandler(
-		MultisigServiceListGroupsProcedure,
-		svc.ListGroups,
-		connect.WithSchema(multisigServiceMethods.ByName("ListGroups")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceSaveGroupHandler := connect.NewUnaryHandler(
-		MultisigServiceSaveGroupProcedure,
-		svc.SaveGroup,
-		connect.WithSchema(multisigServiceMethods.ByName("SaveGroup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceDeleteGroupHandler := connect.NewUnaryHandler(
-		MultisigServiceDeleteGroupProcedure,
-		svc.DeleteGroup,
-		connect.WithSchema(multisigServiceMethods.ByName("DeleteGroup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceListTransactionsHandler := connect.NewUnaryHandler(
-		MultisigServiceListTransactionsProcedure,
-		svc.ListTransactions,
-		connect.WithSchema(multisigServiceMethods.ByName("ListTransactions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceGetTransactionHandler := connect.NewUnaryHandler(
-		MultisigServiceGetTransactionProcedure,
-		svc.GetTransaction,
-		connect.WithSchema(multisigServiceMethods.ByName("GetTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceGetTransactionByTxidHandler := connect.NewUnaryHandler(
-		MultisigServiceGetTransactionByTxidProcedure,
-		svc.GetTransactionByTxid,
-		connect.WithSchema(multisigServiceMethods.ByName("GetTransactionByTxid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceSaveTransactionHandler := connect.NewUnaryHandler(
-		MultisigServiceSaveTransactionProcedure,
-		svc.SaveTransaction,
-		connect.WithSchema(multisigServiceMethods.ByName("SaveTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceListSoloKeysHandler := connect.NewUnaryHandler(
-		MultisigServiceListSoloKeysProcedure,
-		svc.ListSoloKeys,
-		connect.WithSchema(multisigServiceMethods.ByName("ListSoloKeys")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceAddSoloKeyHandler := connect.NewUnaryHandler(
-		MultisigServiceAddSoloKeyProcedure,
-		svc.AddSoloKey,
-		connect.WithSchema(multisigServiceMethods.ByName("AddSoloKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigServiceGetNextAccountIndexHandler := connect.NewUnaryHandler(
-		MultisigServiceGetNextAccountIndexProcedure,
-		svc.GetNextAccountIndex,
-		connect.WithSchema(multisigServiceMethods.ByName("GetNextAccountIndex")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/multisig.v1.MultisigService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case MultisigServiceListGroupsProcedure:
-			multisigServiceListGroupsHandler.ServeHTTP(w, r)
-		case MultisigServiceSaveGroupProcedure:
-			multisigServiceSaveGroupHandler.ServeHTTP(w, r)
-		case MultisigServiceDeleteGroupProcedure:
-			multisigServiceDeleteGroupHandler.ServeHTTP(w, r)
-		case MultisigServiceListTransactionsProcedure:
-			multisigServiceListTransactionsHandler.ServeHTTP(w, r)
-		case MultisigServiceGetTransactionProcedure:
-			multisigServiceGetTransactionHandler.ServeHTTP(w, r)
-		case MultisigServiceGetTransactionByTxidProcedure:
-			multisigServiceGetTransactionByTxidHandler.ServeHTTP(w, r)
-		case MultisigServiceSaveTransactionProcedure:
-			multisigServiceSaveTransactionHandler.ServeHTTP(w, r)
-		case MultisigServiceListSoloKeysProcedure:
-			multisigServiceListSoloKeysHandler.ServeHTTP(w, r)
-		case MultisigServiceAddSoloKeyProcedure:
-			multisigServiceAddSoloKeyHandler.ServeHTTP(w, r)
-		case MultisigServiceGetNextAccountIndexProcedure:
-			multisigServiceGetNextAccountIndexHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedMultisigServiceHandler) AddSoloKey(context.Context, *v1.AddSoloKeyRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.AddSoloKey is not implemented")
 }
 
-// UnimplementedMultisigServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedMultisigServiceHandler struct{}
+func (UnimplementedMultisigServiceHandler) GetNextAccountIndex(context.Context, *v1.GetNextAccountIndexRequest) (*v1.GetNextAccountIndexResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisig.v1.MultisigService.GetNextAccountIndex is not implemented")
+}
 
-func (UnimplementedMultisigServiceHandler) ListGroups(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListGroupsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.ListGroups is not implemented"))
+type multisigServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedMultisigServiceHandler) SaveGroup(context.Context, *connect.Request[v1.SaveGroupRequest]) (*connect.Response[v1.SaveGroupResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.SaveGroup is not implemented"))
+func (c *multisigServiceClient) ListGroups(ctx context.Context, req *emptypb.Empty) (*v1.ListGroupsResponse, error) {
+	var res v1.ListGroupsResponse
+	if err := c.client.CallUnary(ctx, multisigServiceListGroupsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigServiceClient) SaveGroup(ctx context.Context, req *v1.SaveGroupRequest) (*v1.SaveGroupResponse, error) {
+	var res v1.SaveGroupResponse
+	if err := c.client.CallUnary(ctx, multisigServiceSaveGroupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigServiceClient) DeleteGroup(ctx context.Context, req *v1.DeleteGroupRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, multisigServiceDeleteGroupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMultisigServiceHandler) DeleteGroup(context.Context, *connect.Request[v1.DeleteGroupRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.DeleteGroup is not implemented"))
+func (c *multisigServiceClient) ListTransactions(ctx context.Context, req *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	var res v1.ListTransactionsResponse
+	if err := c.client.CallUnary(ctx, multisigServiceListTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMultisigServiceHandler) ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.ListTransactions is not implemented"))
+func (c *multisigServiceClient) GetTransaction(ctx context.Context, req *v1.GetTransactionRequest) (*v1.MultisigTransaction, error) {
+	var res v1.MultisigTransaction
+	if err := c.client.CallUnary(ctx, multisigServiceGetTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMultisigServiceHandler) GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.MultisigTransaction], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.GetTransaction is not implemented"))
+func (c *multisigServiceClient) GetTransactionByTxid(ctx context.Context, req *v1.GetTransactionByTxidRequest) (*v1.MultisigTransaction, error) {
+	var res v1.MultisigTransaction
+	if err := c.client.CallUnary(ctx, multisigServiceGetTransactionByTxidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMultisigServiceHandler) GetTransactionByTxid(context.Context, *connect.Request[v1.GetTransactionByTxidRequest]) (*connect.Response[v1.MultisigTransaction], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.GetTransactionByTxid is not implemented"))
+func (c *multisigServiceClient) SaveTransaction(ctx context.Context, req *v1.SaveTransactionRequest) (*v1.SaveTransactionResponse, error) {
+	var res v1.SaveTransactionResponse
+	if err := c.client.CallUnary(ctx, multisigServiceSaveTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMultisigServiceHandler) SaveTransaction(context.Context, *connect.Request[v1.SaveTransactionRequest]) (*connect.Response[v1.SaveTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.SaveTransaction is not implemented"))
+func (c *multisigServiceClient) ListSoloKeys(ctx context.Context, req *emptypb.Empty) (*v1.ListSoloKeysResponse, error) {
+	var res v1.ListSoloKeysResponse
+	if err := c.client.CallUnary(ctx, multisigServiceListSoloKeysSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMultisigServiceHandler) ListSoloKeys(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListSoloKeysResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.ListSoloKeys is not implemented"))
+func (c *multisigServiceClient) AddSoloKey(ctx context.Context, req *v1.AddSoloKeyRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, multisigServiceAddSoloKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedMultisigServiceHandler) AddSoloKey(context.Context, *connect.Request[v1.AddSoloKeyRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.AddSoloKey is not implemented"))
+func (c *multisigServiceClient) GetNextAccountIndex(ctx context.Context, req *v1.GetNextAccountIndexRequest) (*v1.GetNextAccountIndexResponse, error) {
+	var res v1.GetNextAccountIndexResponse
+	if err := c.client.CallUnary(ctx, multisigServiceGetNextAccountIndexSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type multisigServiceHandler struct{ svc MultisigServiceHandler }
+
+func (h multisigServiceHandler) listGroups(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListGroups(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) saveGroup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SaveGroupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SaveGroup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) deleteGroup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteGroupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeleteGroup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigServiceHandler) GetNextAccountIndex(context.Context, *connect.Request[v1.GetNextAccountIndexRequest]) (*connect.Response[v1.GetNextAccountIndexResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisig.v1.MultisigService.GetNextAccountIndex is not implemented"))
+func (h multisigServiceHandler) listTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) getTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) getTransactionByTxid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransactionByTxidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransactionByTxid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) saveTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SaveTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SaveTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) listSoloKeys(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSoloKeys(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) addSoloKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.AddSoloKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.AddSoloKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h multisigServiceHandler) getNextAccountIndex(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNextAccountIndexRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNextAccountIndex(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/notification/v1/notificationv1connect/notification.connect.go b/bitwindow/server/gen/notification/v1/notificationv1connect/notification.connect.go
index 839f4380f4..a4886458d5 100644
--- a/bitwindow/server/gen/notification/v1/notificationv1connect/notification.connect.go
+++ b/bitwindow/server/gen/notification/v1/notificationv1connect/notification.connect.go
@@ -5,109 +5,128 @@
 package notificationv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/notification/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// NotificationServiceName is the fully-qualified name of the NotificationService service.
 	NotificationServiceName = "notification.v1.NotificationService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// NotificationServiceWatchProcedure is the fully-qualified name of the NotificationService's Watch
-	// RPC.
+	// NotificationServiceWatchProcedure is the procedure name of the NotificationService's Watch RPC.
 	NotificationServiceWatchProcedure = "/notification.v1.NotificationService/Watch"
 )
 
+var (
+	notificationServiceWatchSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_notification_v1_notification_proto.Services().ByName("NotificationService").Methods().ByName("Watch"),
+			Procedure:  NotificationServiceWatchProcedure,
+		}
+	})
+)
+
 // NotificationServiceClient is a client for the notification.v1.NotificationService service.
 type NotificationServiceClient interface {
-	// Watch returns a stream of notification events
-	Watch(context.Context, *connect.Request[emptypb.Empty]) (*connect.ServerStreamForClient[v1.WatchResponse], error)
+	Watch(context.Context, *emptypb.Empty) (NotificationServiceWatchClientStream, error)
 }
 
 // NewNotificationServiceClient constructs a client for the notification.v1.NotificationService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewNotificationServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) NotificationServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	notificationServiceMethods := v1.File_notification_v1_notification_proto.Services().ByName("NotificationService").Methods()
-	return &notificationServiceClient{
-		watch: connect.NewClient[emptypb.Empty, v1.WatchResponse](
-			httpClient,
-			baseURL+NotificationServiceWatchProcedure,
-			connect.WithSchema(notificationServiceMethods.ByName("Watch")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// service. Multiple service clients may share a single connect.Client.
+func NewNotificationServiceClient(client *connect.Client) NotificationServiceClient {
+	return &notificationServiceClient{client: client}
 }
 
-// notificationServiceClient implements NotificationServiceClient.
-type notificationServiceClient struct {
-	watch *connect.Client[emptypb.Empty, v1.WatchResponse]
+// NotificationServiceWatchClientStream is the client stream for the NotificationService's Watch
+// RPC.
+type NotificationServiceWatchClientStream struct {
+	stream connect.ClientStream
 }
 
-// Watch calls notification.v1.NotificationService.Watch.
-func (c *notificationServiceClient) Watch(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.ServerStreamForClient[v1.WatchResponse], error) {
-	return c.watch.CallServerStream(ctx, req)
+// Receive returns the next response message from the server.
+func (s NotificationServiceWatchClientStream) Receive() (*v1.WatchResponse, error) {
+	var res v1.WatchResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s NotificationServiceWatchClientStream) Close() error {
+	return s.stream.Close()
 }
 
 // NotificationServiceHandler is an implementation of the notification.v1.NotificationService
 // service.
 type NotificationServiceHandler interface {
-	// Watch returns a stream of notification events
-	Watch(context.Context, *connect.Request[emptypb.Empty], *connect.ServerStream[v1.WatchResponse]) error
+	Watch(context.Context, *emptypb.Empty, NotificationServiceWatchServerStream) error
 }
 
-// NewNotificationServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewNotificationServiceHandler(svc NotificationServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	notificationServiceMethods := v1.File_notification_v1_notification_proto.Services().ByName("NotificationService").Methods()
-	notificationServiceWatchHandler := connect.NewServerStreamHandler(
-		NotificationServiceWatchProcedure,
-		svc.Watch,
-		connect.WithSchema(notificationServiceMethods.ByName("Watch")),
-		connect.WithHandlerOptions(opts...),
+// RegisterNotificationServiceHandler registers svc as the notification.v1.NotificationService
+// implementation on server.
+func RegisterNotificationServiceHandler(server *connect.Server, svc NotificationServiceHandler) {
+	adapter := notificationServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: notificationServiceWatchSpec(), Handler: adapter.watch},
 	)
-	return "/notification.v1.NotificationService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case NotificationServiceWatchProcedure:
-			notificationServiceWatchHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+}
+
+// NotificationServiceWatchServerStream is the server stream for the NotificationService's Watch
+// RPC.
+type NotificationServiceWatchServerStream struct {
+	stream connect.ServerStream
+}
+
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s NotificationServiceWatchServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
+}
+
+// Send sends a response message to the client.
+func (s NotificationServiceWatchServerStream) Send(res *v1.WatchResponse) error {
+	return s.stream.Send(res)
 }
 
 // UnimplementedNotificationServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedNotificationServiceHandler struct{}
 
-func (UnimplementedNotificationServiceHandler) Watch(context.Context, *connect.Request[emptypb.Empty], *connect.ServerStream[v1.WatchResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("notification.v1.NotificationService.Watch is not implemented"))
+func (UnimplementedNotificationServiceHandler) Watch(context.Context, *emptypb.Empty, NotificationServiceWatchServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "notification.v1.NotificationService.Watch is not implemented")
+}
+
+type notificationServiceClient struct {
+	client *connect.Client
+}
+
+func (c *notificationServiceClient) Watch(ctx context.Context, req *emptypb.Empty) (NotificationServiceWatchClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, notificationServiceWatchSpec(), req)
+	if err != nil {
+		return NotificationServiceWatchClientStream{}, err
+	}
+	return NotificationServiceWatchClientStream{stream: stream}, nil
+}
+
+type notificationServiceHandler struct{ svc NotificationServiceHandler }
+
+func (h notificationServiceHandler) watch(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.Watch(ctx, &req, NotificationServiceWatchServerStream{stream: stream})
 }
diff --git a/bitwindow/server/gen/sidechain/v1/sidechainv1connect/sidechain.connect.go b/bitwindow/server/gen/sidechain/v1/sidechainv1connect/sidechain.connect.go
index f08e7e04a3..10e083c7bf 100644
--- a/bitwindow/server/gen/sidechain/v1/sidechainv1connect/sidechain.connect.go
+++ b/bitwindow/server/gen/sidechain/v1/sidechainv1connect/sidechain.connect.go
@@ -5,138 +5,131 @@
 package sidechainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/sidechain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// SidechainServiceName is the fully-qualified name of the SidechainService service.
 	SidechainServiceName = "sidechain.v1.SidechainService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// SidechainServiceGetDetectedWithdrawalsProcedure is the fully-qualified name of the
-	// SidechainService's GetDetectedWithdrawals RPC.
+	// SidechainServiceGetDetectedWithdrawalsProcedure is the procedure name of the SidechainService's
+	// GetDetectedWithdrawals RPC.
 	SidechainServiceGetDetectedWithdrawalsProcedure = "/sidechain.v1.SidechainService/GetDetectedWithdrawals"
-	// SidechainServiceGetWithdrawalByTxidProcedure is the fully-qualified name of the
-	// SidechainService's GetWithdrawalByTxid RPC.
+	// SidechainServiceGetWithdrawalByTxidProcedure is the procedure name of the SidechainService's
+	// GetWithdrawalByTxid RPC.
 	SidechainServiceGetWithdrawalByTxidProcedure = "/sidechain.v1.SidechainService/GetWithdrawalByTxid"
 )
 
+var (
+	sidechainServiceGetDetectedWithdrawalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods().ByName("GetDetectedWithdrawals"),
+			Procedure:  SidechainServiceGetDetectedWithdrawalsProcedure,
+		}
+	})
+	sidechainServiceGetWithdrawalByTxidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods().ByName("GetWithdrawalByTxid"),
+			Procedure:  SidechainServiceGetWithdrawalByTxidProcedure,
+		}
+	})
+)
+
 // SidechainServiceClient is a client for the sidechain.v1.SidechainService service.
 type SidechainServiceClient interface {
-	// GetDetectedWithdrawals returns all detected fast withdrawal transactions
-	GetDetectedWithdrawals(context.Context, *connect.Request[v1.GetDetectedWithdrawalsRequest]) (*connect.Response[v1.GetDetectedWithdrawalsResponse], error)
-	// GetWithdrawalByTxid returns a specific withdrawal by transaction ID
-	GetWithdrawalByTxid(context.Context, *connect.Request[v1.GetWithdrawalByTxidRequest]) (*connect.Response[v1.GetWithdrawalByTxidResponse], error)
+	GetDetectedWithdrawals(context.Context, *v1.GetDetectedWithdrawalsRequest) (*v1.GetDetectedWithdrawalsResponse, error)
+	GetWithdrawalByTxid(context.Context, *v1.GetWithdrawalByTxidRequest) (*v1.GetWithdrawalByTxidResponse, error)
 }
 
-// NewSidechainServiceClient constructs a client for the sidechain.v1.SidechainService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewSidechainServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) SidechainServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	sidechainServiceMethods := v1.File_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods()
-	return &sidechainServiceClient{
-		getDetectedWithdrawals: connect.NewClient[v1.GetDetectedWithdrawalsRequest, v1.GetDetectedWithdrawalsResponse](
-			httpClient,
-			baseURL+SidechainServiceGetDetectedWithdrawalsProcedure,
-			connect.WithSchema(sidechainServiceMethods.ByName("GetDetectedWithdrawals")),
-			connect.WithClientOptions(opts...),
-		),
-		getWithdrawalByTxid: connect.NewClient[v1.GetWithdrawalByTxidRequest, v1.GetWithdrawalByTxidResponse](
-			httpClient,
-			baseURL+SidechainServiceGetWithdrawalByTxidProcedure,
-			connect.WithSchema(sidechainServiceMethods.ByName("GetWithdrawalByTxid")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// NewSidechainServiceClient constructs a client for the sidechain.v1.SidechainService service.
+// Multiple service clients may share a single connect.Client.
+func NewSidechainServiceClient(client *connect.Client) SidechainServiceClient {
+	return &sidechainServiceClient{client: client}
 }
 
-// sidechainServiceClient implements SidechainServiceClient.
-type sidechainServiceClient struct {
-	getDetectedWithdrawals *connect.Client[v1.GetDetectedWithdrawalsRequest, v1.GetDetectedWithdrawalsResponse]
-	getWithdrawalByTxid    *connect.Client[v1.GetWithdrawalByTxidRequest, v1.GetWithdrawalByTxidResponse]
+// SidechainServiceHandler is an implementation of the sidechain.v1.SidechainService service.
+type SidechainServiceHandler interface {
+	GetDetectedWithdrawals(context.Context, *v1.GetDetectedWithdrawalsRequest) (*v1.GetDetectedWithdrawalsResponse, error)
+	GetWithdrawalByTxid(context.Context, *v1.GetWithdrawalByTxidRequest) (*v1.GetWithdrawalByTxidResponse, error)
 }
 
-// GetDetectedWithdrawals calls sidechain.v1.SidechainService.GetDetectedWithdrawals.
-func (c *sidechainServiceClient) GetDetectedWithdrawals(ctx context.Context, req *connect.Request[v1.GetDetectedWithdrawalsRequest]) (*connect.Response[v1.GetDetectedWithdrawalsResponse], error) {
-	return c.getDetectedWithdrawals.CallUnary(ctx, req)
+// RegisterSidechainServiceHandler registers svc as the sidechain.v1.SidechainService implementation
+// on server.
+func RegisterSidechainServiceHandler(server *connect.Server, svc SidechainServiceHandler) {
+	adapter := sidechainServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: sidechainServiceGetDetectedWithdrawalsSpec(), Handler: adapter.getDetectedWithdrawals},
+		connect.Method{Spec: sidechainServiceGetWithdrawalByTxidSpec(), Handler: adapter.getWithdrawalByTxid},
+	)
 }
 
-// GetWithdrawalByTxid calls sidechain.v1.SidechainService.GetWithdrawalByTxid.
-func (c *sidechainServiceClient) GetWithdrawalByTxid(ctx context.Context, req *connect.Request[v1.GetWithdrawalByTxidRequest]) (*connect.Response[v1.GetWithdrawalByTxidResponse], error) {
-	return c.getWithdrawalByTxid.CallUnary(ctx, req)
+// UnimplementedSidechainServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedSidechainServiceHandler struct{}
+
+func (UnimplementedSidechainServiceHandler) GetDetectedWithdrawals(context.Context, *v1.GetDetectedWithdrawalsRequest) (*v1.GetDetectedWithdrawalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "sidechain.v1.SidechainService.GetDetectedWithdrawals is not implemented")
 }
 
-// SidechainServiceHandler is an implementation of the sidechain.v1.SidechainService service.
-type SidechainServiceHandler interface {
-	// GetDetectedWithdrawals returns all detected fast withdrawal transactions
-	GetDetectedWithdrawals(context.Context, *connect.Request[v1.GetDetectedWithdrawalsRequest]) (*connect.Response[v1.GetDetectedWithdrawalsResponse], error)
-	// GetWithdrawalByTxid returns a specific withdrawal by transaction ID
-	GetWithdrawalByTxid(context.Context, *connect.Request[v1.GetWithdrawalByTxidRequest]) (*connect.Response[v1.GetWithdrawalByTxidResponse], error)
+func (UnimplementedSidechainServiceHandler) GetWithdrawalByTxid(context.Context, *v1.GetWithdrawalByTxidRequest) (*v1.GetWithdrawalByTxidResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "sidechain.v1.SidechainService.GetWithdrawalByTxid is not implemented")
 }
 
-// NewSidechainServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewSidechainServiceHandler(svc SidechainServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	sidechainServiceMethods := v1.File_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods()
-	sidechainServiceGetDetectedWithdrawalsHandler := connect.NewUnaryHandler(
-		SidechainServiceGetDetectedWithdrawalsProcedure,
-		svc.GetDetectedWithdrawals,
-		connect.WithSchema(sidechainServiceMethods.ByName("GetDetectedWithdrawals")),
-		connect.WithHandlerOptions(opts...),
-	)
-	sidechainServiceGetWithdrawalByTxidHandler := connect.NewUnaryHandler(
-		SidechainServiceGetWithdrawalByTxidProcedure,
-		svc.GetWithdrawalByTxid,
-		connect.WithSchema(sidechainServiceMethods.ByName("GetWithdrawalByTxid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/sidechain.v1.SidechainService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case SidechainServiceGetDetectedWithdrawalsProcedure:
-			sidechainServiceGetDetectedWithdrawalsHandler.ServeHTTP(w, r)
-		case SidechainServiceGetWithdrawalByTxidProcedure:
-			sidechainServiceGetWithdrawalByTxidHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type sidechainServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedSidechainServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedSidechainServiceHandler struct{}
+func (c *sidechainServiceClient) GetDetectedWithdrawals(ctx context.Context, req *v1.GetDetectedWithdrawalsRequest) (*v1.GetDetectedWithdrawalsResponse, error) {
+	var res v1.GetDetectedWithdrawalsResponse
+	if err := c.client.CallUnary(ctx, sidechainServiceGetDetectedWithdrawalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedSidechainServiceHandler) GetDetectedWithdrawals(context.Context, *connect.Request[v1.GetDetectedWithdrawalsRequest]) (*connect.Response[v1.GetDetectedWithdrawalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("sidechain.v1.SidechainService.GetDetectedWithdrawals is not implemented"))
+func (c *sidechainServiceClient) GetWithdrawalByTxid(ctx context.Context, req *v1.GetWithdrawalByTxidRequest) (*v1.GetWithdrawalByTxidResponse, error) {
+	var res v1.GetWithdrawalByTxidResponse
+	if err := c.client.CallUnary(ctx, sidechainServiceGetWithdrawalByTxidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedSidechainServiceHandler) GetWithdrawalByTxid(context.Context, *connect.Request[v1.GetWithdrawalByTxidRequest]) (*connect.Response[v1.GetWithdrawalByTxidResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("sidechain.v1.SidechainService.GetWithdrawalByTxid is not implemented"))
+type sidechainServiceHandler struct{ svc SidechainServiceHandler }
+
+func (h sidechainServiceHandler) getDetectedWithdrawals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetDetectedWithdrawalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetDetectedWithdrawals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h sidechainServiceHandler) getWithdrawalByTxid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWithdrawalByTxidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWithdrawalByTxid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/utils/v1/utilsv1connect/utils.connect.go b/bitwindow/server/gen/utils/v1/utilsv1connect/utils.connect.go
index 3cb81e6291..44769e8dd3 100644
--- a/bitwindow/server/gen/utils/v1/utilsv1connect/utils.connect.go
+++ b/bitwindow/server/gen/utils/v1/utilsv1connect/utils.connect.go
@@ -5,317 +5,351 @@
 package utilsv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/utils/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// UtilsServiceName is the fully-qualified name of the UtilsService service.
 	UtilsServiceName = "utils.v1.UtilsService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// UtilsServiceParseBitcoinURIProcedure is the fully-qualified name of the UtilsService's
-	// ParseBitcoinURI RPC.
+	// UtilsServiceParseBitcoinURIProcedure is the procedure name of the UtilsService's ParseBitcoinURI
+	// RPC.
 	UtilsServiceParseBitcoinURIProcedure = "/utils.v1.UtilsService/ParseBitcoinURI"
-	// UtilsServiceValidateBitcoinURIProcedure is the fully-qualified name of the UtilsService's
+	// UtilsServiceValidateBitcoinURIProcedure is the procedure name of the UtilsService's
 	// ValidateBitcoinURI RPC.
 	UtilsServiceValidateBitcoinURIProcedure = "/utils.v1.UtilsService/ValidateBitcoinURI"
-	// UtilsServiceDecodeBase58CheckProcedure is the fully-qualified name of the UtilsService's
+	// UtilsServiceDecodeBase58CheckProcedure is the procedure name of the UtilsService's
 	// DecodeBase58Check RPC.
 	UtilsServiceDecodeBase58CheckProcedure = "/utils.v1.UtilsService/DecodeBase58Check"
-	// UtilsServiceEncodeBase58CheckProcedure is the fully-qualified name of the UtilsService's
+	// UtilsServiceEncodeBase58CheckProcedure is the procedure name of the UtilsService's
 	// EncodeBase58Check RPC.
 	UtilsServiceEncodeBase58CheckProcedure = "/utils.v1.UtilsService/EncodeBase58Check"
-	// UtilsServiceCalculateMerkleTreeProcedure is the fully-qualified name of the UtilsService's
+	// UtilsServiceCalculateMerkleTreeProcedure is the procedure name of the UtilsService's
 	// CalculateMerkleTree RPC.
 	UtilsServiceCalculateMerkleTreeProcedure = "/utils.v1.UtilsService/CalculateMerkleTree"
-	// UtilsServiceGeneratePaperWalletProcedure is the fully-qualified name of the UtilsService's
+	// UtilsServiceGeneratePaperWalletProcedure is the procedure name of the UtilsService's
 	// GeneratePaperWallet RPC.
 	UtilsServiceGeneratePaperWalletProcedure = "/utils.v1.UtilsService/GeneratePaperWallet"
-	// UtilsServiceValidateWIFProcedure is the fully-qualified name of the UtilsService's ValidateWIF
-	// RPC.
+	// UtilsServiceValidateWIFProcedure is the procedure name of the UtilsService's ValidateWIF RPC.
 	UtilsServiceValidateWIFProcedure = "/utils.v1.UtilsService/ValidateWIF"
-	// UtilsServiceWIFToAddressProcedure is the fully-qualified name of the UtilsService's WIFToAddress
-	// RPC.
+	// UtilsServiceWIFToAddressProcedure is the procedure name of the UtilsService's WIFToAddress RPC.
 	UtilsServiceWIFToAddressProcedure = "/utils.v1.UtilsService/WIFToAddress"
 )
 
+var (
+	utilsServiceParseBitcoinURISpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("ParseBitcoinURI"),
+			Procedure:  UtilsServiceParseBitcoinURIProcedure,
+		}
+	})
+	utilsServiceValidateBitcoinURISpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("ValidateBitcoinURI"),
+			Procedure:  UtilsServiceValidateBitcoinURIProcedure,
+		}
+	})
+	utilsServiceDecodeBase58CheckSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("DecodeBase58Check"),
+			Procedure:  UtilsServiceDecodeBase58CheckProcedure,
+		}
+	})
+	utilsServiceEncodeBase58CheckSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("EncodeBase58Check"),
+			Procedure:  UtilsServiceEncodeBase58CheckProcedure,
+		}
+	})
+	utilsServiceCalculateMerkleTreeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("CalculateMerkleTree"),
+			Procedure:  UtilsServiceCalculateMerkleTreeProcedure,
+		}
+	})
+	utilsServiceGeneratePaperWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("GeneratePaperWallet"),
+			Procedure:  UtilsServiceGeneratePaperWalletProcedure,
+		}
+	})
+	utilsServiceValidateWIFSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("ValidateWIF"),
+			Procedure:  UtilsServiceValidateWIFProcedure,
+		}
+	})
+	utilsServiceWIFToAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods().ByName("WIFToAddress"),
+			Procedure:  UtilsServiceWIFToAddressProcedure,
+		}
+	})
+)
+
 // UtilsServiceClient is a client for the utils.v1.UtilsService service.
 type UtilsServiceClient interface {
-	// Bitcoin URI parsing (BIP-0021)
-	ParseBitcoinURI(context.Context, *connect.Request[v1.ParseBitcoinURIRequest]) (*connect.Response[v1.ParseBitcoinURIResponse], error)
-	ValidateBitcoinURI(context.Context, *connect.Request[v1.ValidateBitcoinURIRequest]) (*connect.Response[v1.ValidateBitcoinURIResponse], error)
-	// Base58Check encoding/decoding
-	DecodeBase58Check(context.Context, *connect.Request[v1.DecodeBase58CheckRequest]) (*connect.Response[v1.DecodeBase58CheckResponse], error)
-	EncodeBase58Check(context.Context, *connect.Request[v1.EncodeBase58CheckRequest]) (*connect.Response[v1.EncodeBase58CheckResponse], error)
-	// Merkle Tree calculation
-	CalculateMerkleTree(context.Context, *connect.Request[v1.CalculateMerkleTreeRequest]) (*connect.Response[v1.CalculateMerkleTreeResponse], error)
-	// Paper Wallet generation
-	GeneratePaperWallet(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GeneratePaperWalletResponse], error)
-	ValidateWIF(context.Context, *connect.Request[v1.ValidateWIFRequest]) (*connect.Response[v1.ValidateWIFResponse], error)
-	WIFToAddress(context.Context, *connect.Request[v1.WIFToAddressRequest]) (*connect.Response[v1.WIFToAddressResponse], error)
+	ParseBitcoinURI(context.Context, *v1.ParseBitcoinURIRequest) (*v1.ParseBitcoinURIResponse, error)
+	ValidateBitcoinURI(context.Context, *v1.ValidateBitcoinURIRequest) (*v1.ValidateBitcoinURIResponse, error)
+	DecodeBase58Check(context.Context, *v1.DecodeBase58CheckRequest) (*v1.DecodeBase58CheckResponse, error)
+	EncodeBase58Check(context.Context, *v1.EncodeBase58CheckRequest) (*v1.EncodeBase58CheckResponse, error)
+	CalculateMerkleTree(context.Context, *v1.CalculateMerkleTreeRequest) (*v1.CalculateMerkleTreeResponse, error)
+	GeneratePaperWallet(context.Context, *emptypb.Empty) (*v1.GeneratePaperWalletResponse, error)
+	ValidateWIF(context.Context, *v1.ValidateWIFRequest) (*v1.ValidateWIFResponse, error)
+	WIFToAddress(context.Context, *v1.WIFToAddressRequest) (*v1.WIFToAddressResponse, error)
 }
 
-// NewUtilsServiceClient constructs a client for the utils.v1.UtilsService service. By default, it
-// uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewUtilsServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) UtilsServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	utilsServiceMethods := v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods()
-	return &utilsServiceClient{
-		parseBitcoinURI: connect.NewClient[v1.ParseBitcoinURIRequest, v1.ParseBitcoinURIResponse](
-			httpClient,
-			baseURL+UtilsServiceParseBitcoinURIProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("ParseBitcoinURI")),
-			connect.WithClientOptions(opts...),
-		),
-		validateBitcoinURI: connect.NewClient[v1.ValidateBitcoinURIRequest, v1.ValidateBitcoinURIResponse](
-			httpClient,
-			baseURL+UtilsServiceValidateBitcoinURIProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("ValidateBitcoinURI")),
-			connect.WithClientOptions(opts...),
-		),
-		decodeBase58Check: connect.NewClient[v1.DecodeBase58CheckRequest, v1.DecodeBase58CheckResponse](
-			httpClient,
-			baseURL+UtilsServiceDecodeBase58CheckProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("DecodeBase58Check")),
-			connect.WithClientOptions(opts...),
-		),
-		encodeBase58Check: connect.NewClient[v1.EncodeBase58CheckRequest, v1.EncodeBase58CheckResponse](
-			httpClient,
-			baseURL+UtilsServiceEncodeBase58CheckProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("EncodeBase58Check")),
-			connect.WithClientOptions(opts...),
-		),
-		calculateMerkleTree: connect.NewClient[v1.CalculateMerkleTreeRequest, v1.CalculateMerkleTreeResponse](
-			httpClient,
-			baseURL+UtilsServiceCalculateMerkleTreeProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("CalculateMerkleTree")),
-			connect.WithClientOptions(opts...),
-		),
-		generatePaperWallet: connect.NewClient[emptypb.Empty, v1.GeneratePaperWalletResponse](
-			httpClient,
-			baseURL+UtilsServiceGeneratePaperWalletProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("GeneratePaperWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		validateWIF: connect.NewClient[v1.ValidateWIFRequest, v1.ValidateWIFResponse](
-			httpClient,
-			baseURL+UtilsServiceValidateWIFProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("ValidateWIF")),
-			connect.WithClientOptions(opts...),
-		),
-		wIFToAddress: connect.NewClient[v1.WIFToAddressRequest, v1.WIFToAddressResponse](
-			httpClient,
-			baseURL+UtilsServiceWIFToAddressProcedure,
-			connect.WithSchema(utilsServiceMethods.ByName("WIFToAddress")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// NewUtilsServiceClient constructs a client for the utils.v1.UtilsService service. Multiple service
+// clients may share a single connect.Client.
+func NewUtilsServiceClient(client *connect.Client) UtilsServiceClient {
+	return &utilsServiceClient{client: client}
 }
 
-// utilsServiceClient implements UtilsServiceClient.
-type utilsServiceClient struct {
-	parseBitcoinURI     *connect.Client[v1.ParseBitcoinURIRequest, v1.ParseBitcoinURIResponse]
-	validateBitcoinURI  *connect.Client[v1.ValidateBitcoinURIRequest, v1.ValidateBitcoinURIResponse]
-	decodeBase58Check   *connect.Client[v1.DecodeBase58CheckRequest, v1.DecodeBase58CheckResponse]
-	encodeBase58Check   *connect.Client[v1.EncodeBase58CheckRequest, v1.EncodeBase58CheckResponse]
-	calculateMerkleTree *connect.Client[v1.CalculateMerkleTreeRequest, v1.CalculateMerkleTreeResponse]
-	generatePaperWallet *connect.Client[emptypb.Empty, v1.GeneratePaperWalletResponse]
-	validateWIF         *connect.Client[v1.ValidateWIFRequest, v1.ValidateWIFResponse]
-	wIFToAddress        *connect.Client[v1.WIFToAddressRequest, v1.WIFToAddressResponse]
+// UtilsServiceHandler is an implementation of the utils.v1.UtilsService service.
+type UtilsServiceHandler interface {
+	ParseBitcoinURI(context.Context, *v1.ParseBitcoinURIRequest) (*v1.ParseBitcoinURIResponse, error)
+	ValidateBitcoinURI(context.Context, *v1.ValidateBitcoinURIRequest) (*v1.ValidateBitcoinURIResponse, error)
+	DecodeBase58Check(context.Context, *v1.DecodeBase58CheckRequest) (*v1.DecodeBase58CheckResponse, error)
+	EncodeBase58Check(context.Context, *v1.EncodeBase58CheckRequest) (*v1.EncodeBase58CheckResponse, error)
+	CalculateMerkleTree(context.Context, *v1.CalculateMerkleTreeRequest) (*v1.CalculateMerkleTreeResponse, error)
+	GeneratePaperWallet(context.Context, *emptypb.Empty) (*v1.GeneratePaperWalletResponse, error)
+	ValidateWIF(context.Context, *v1.ValidateWIFRequest) (*v1.ValidateWIFResponse, error)
+	WIFToAddress(context.Context, *v1.WIFToAddressRequest) (*v1.WIFToAddressResponse, error)
 }
 
-// ParseBitcoinURI calls utils.v1.UtilsService.ParseBitcoinURI.
-func (c *utilsServiceClient) ParseBitcoinURI(ctx context.Context, req *connect.Request[v1.ParseBitcoinURIRequest]) (*connect.Response[v1.ParseBitcoinURIResponse], error) {
-	return c.parseBitcoinURI.CallUnary(ctx, req)
+// RegisterUtilsServiceHandler registers svc as the utils.v1.UtilsService implementation on server.
+func RegisterUtilsServiceHandler(server *connect.Server, svc UtilsServiceHandler) {
+	adapter := utilsServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: utilsServiceParseBitcoinURISpec(), Handler: adapter.parseBitcoinURI},
+		connect.Method{Spec: utilsServiceValidateBitcoinURISpec(), Handler: adapter.validateBitcoinURI},
+		connect.Method{Spec: utilsServiceDecodeBase58CheckSpec(), Handler: adapter.decodeBase58Check},
+		connect.Method{Spec: utilsServiceEncodeBase58CheckSpec(), Handler: adapter.encodeBase58Check},
+		connect.Method{Spec: utilsServiceCalculateMerkleTreeSpec(), Handler: adapter.calculateMerkleTree},
+		connect.Method{Spec: utilsServiceGeneratePaperWalletSpec(), Handler: adapter.generatePaperWallet},
+		connect.Method{Spec: utilsServiceValidateWIFSpec(), Handler: adapter.validateWIF},
+		connect.Method{Spec: utilsServiceWIFToAddressSpec(), Handler: adapter.wIFToAddress},
+	)
 }
 
-// ValidateBitcoinURI calls utils.v1.UtilsService.ValidateBitcoinURI.
-func (c *utilsServiceClient) ValidateBitcoinURI(ctx context.Context, req *connect.Request[v1.ValidateBitcoinURIRequest]) (*connect.Response[v1.ValidateBitcoinURIResponse], error) {
-	return c.validateBitcoinURI.CallUnary(ctx, req)
+// UnimplementedUtilsServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedUtilsServiceHandler struct{}
+
+func (UnimplementedUtilsServiceHandler) ParseBitcoinURI(context.Context, *v1.ParseBitcoinURIRequest) (*v1.ParseBitcoinURIResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.ParseBitcoinURI is not implemented")
 }
 
-// DecodeBase58Check calls utils.v1.UtilsService.DecodeBase58Check.
-func (c *utilsServiceClient) DecodeBase58Check(ctx context.Context, req *connect.Request[v1.DecodeBase58CheckRequest]) (*connect.Response[v1.DecodeBase58CheckResponse], error) {
-	return c.decodeBase58Check.CallUnary(ctx, req)
+func (UnimplementedUtilsServiceHandler) ValidateBitcoinURI(context.Context, *v1.ValidateBitcoinURIRequest) (*v1.ValidateBitcoinURIResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.ValidateBitcoinURI is not implemented")
 }
 
-// EncodeBase58Check calls utils.v1.UtilsService.EncodeBase58Check.
-func (c *utilsServiceClient) EncodeBase58Check(ctx context.Context, req *connect.Request[v1.EncodeBase58CheckRequest]) (*connect.Response[v1.EncodeBase58CheckResponse], error) {
-	return c.encodeBase58Check.CallUnary(ctx, req)
+func (UnimplementedUtilsServiceHandler) DecodeBase58Check(context.Context, *v1.DecodeBase58CheckRequest) (*v1.DecodeBase58CheckResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.DecodeBase58Check is not implemented")
 }
 
-// CalculateMerkleTree calls utils.v1.UtilsService.CalculateMerkleTree.
-func (c *utilsServiceClient) CalculateMerkleTree(ctx context.Context, req *connect.Request[v1.CalculateMerkleTreeRequest]) (*connect.Response[v1.CalculateMerkleTreeResponse], error) {
-	return c.calculateMerkleTree.CallUnary(ctx, req)
+func (UnimplementedUtilsServiceHandler) EncodeBase58Check(context.Context, *v1.EncodeBase58CheckRequest) (*v1.EncodeBase58CheckResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.EncodeBase58Check is not implemented")
 }
 
-// GeneratePaperWallet calls utils.v1.UtilsService.GeneratePaperWallet.
-func (c *utilsServiceClient) GeneratePaperWallet(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.GeneratePaperWalletResponse], error) {
-	return c.generatePaperWallet.CallUnary(ctx, req)
+func (UnimplementedUtilsServiceHandler) CalculateMerkleTree(context.Context, *v1.CalculateMerkleTreeRequest) (*v1.CalculateMerkleTreeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.CalculateMerkleTree is not implemented")
 }
 
-// ValidateWIF calls utils.v1.UtilsService.ValidateWIF.
-func (c *utilsServiceClient) ValidateWIF(ctx context.Context, req *connect.Request[v1.ValidateWIFRequest]) (*connect.Response[v1.ValidateWIFResponse], error) {
-	return c.validateWIF.CallUnary(ctx, req)
+func (UnimplementedUtilsServiceHandler) GeneratePaperWallet(context.Context, *emptypb.Empty) (*v1.GeneratePaperWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.GeneratePaperWallet is not implemented")
 }
 
-// WIFToAddress calls utils.v1.UtilsService.WIFToAddress.
-func (c *utilsServiceClient) WIFToAddress(ctx context.Context, req *connect.Request[v1.WIFToAddressRequest]) (*connect.Response[v1.WIFToAddressResponse], error) {
-	return c.wIFToAddress.CallUnary(ctx, req)
+func (UnimplementedUtilsServiceHandler) ValidateWIF(context.Context, *v1.ValidateWIFRequest) (*v1.ValidateWIFResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.ValidateWIF is not implemented")
 }
 
-// UtilsServiceHandler is an implementation of the utils.v1.UtilsService service.
-type UtilsServiceHandler interface {
-	// Bitcoin URI parsing (BIP-0021)
-	ParseBitcoinURI(context.Context, *connect.Request[v1.ParseBitcoinURIRequest]) (*connect.Response[v1.ParseBitcoinURIResponse], error)
-	ValidateBitcoinURI(context.Context, *connect.Request[v1.ValidateBitcoinURIRequest]) (*connect.Response[v1.ValidateBitcoinURIResponse], error)
-	// Base58Check encoding/decoding
-	DecodeBase58Check(context.Context, *connect.Request[v1.DecodeBase58CheckRequest]) (*connect.Response[v1.DecodeBase58CheckResponse], error)
-	EncodeBase58Check(context.Context, *connect.Request[v1.EncodeBase58CheckRequest]) (*connect.Response[v1.EncodeBase58CheckResponse], error)
-	// Merkle Tree calculation
-	CalculateMerkleTree(context.Context, *connect.Request[v1.CalculateMerkleTreeRequest]) (*connect.Response[v1.CalculateMerkleTreeResponse], error)
-	// Paper Wallet generation
-	GeneratePaperWallet(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GeneratePaperWalletResponse], error)
-	ValidateWIF(context.Context, *connect.Request[v1.ValidateWIFRequest]) (*connect.Response[v1.ValidateWIFResponse], error)
-	WIFToAddress(context.Context, *connect.Request[v1.WIFToAddressRequest]) (*connect.Response[v1.WIFToAddressResponse], error)
+func (UnimplementedUtilsServiceHandler) WIFToAddress(context.Context, *v1.WIFToAddressRequest) (*v1.WIFToAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "utils.v1.UtilsService.WIFToAddress is not implemented")
 }
 
-// NewUtilsServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewUtilsServiceHandler(svc UtilsServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	utilsServiceMethods := v1.File_utils_v1_utils_proto.Services().ByName("UtilsService").Methods()
-	utilsServiceParseBitcoinURIHandler := connect.NewUnaryHandler(
-		UtilsServiceParseBitcoinURIProcedure,
-		svc.ParseBitcoinURI,
-		connect.WithSchema(utilsServiceMethods.ByName("ParseBitcoinURI")),
-		connect.WithHandlerOptions(opts...),
-	)
-	utilsServiceValidateBitcoinURIHandler := connect.NewUnaryHandler(
-		UtilsServiceValidateBitcoinURIProcedure,
-		svc.ValidateBitcoinURI,
-		connect.WithSchema(utilsServiceMethods.ByName("ValidateBitcoinURI")),
-		connect.WithHandlerOptions(opts...),
-	)
-	utilsServiceDecodeBase58CheckHandler := connect.NewUnaryHandler(
-		UtilsServiceDecodeBase58CheckProcedure,
-		svc.DecodeBase58Check,
-		connect.WithSchema(utilsServiceMethods.ByName("DecodeBase58Check")),
-		connect.WithHandlerOptions(opts...),
-	)
-	utilsServiceEncodeBase58CheckHandler := connect.NewUnaryHandler(
-		UtilsServiceEncodeBase58CheckProcedure,
-		svc.EncodeBase58Check,
-		connect.WithSchema(utilsServiceMethods.ByName("EncodeBase58Check")),
-		connect.WithHandlerOptions(opts...),
-	)
-	utilsServiceCalculateMerkleTreeHandler := connect.NewUnaryHandler(
-		UtilsServiceCalculateMerkleTreeProcedure,
-		svc.CalculateMerkleTree,
-		connect.WithSchema(utilsServiceMethods.ByName("CalculateMerkleTree")),
-		connect.WithHandlerOptions(opts...),
-	)
-	utilsServiceGeneratePaperWalletHandler := connect.NewUnaryHandler(
-		UtilsServiceGeneratePaperWalletProcedure,
-		svc.GeneratePaperWallet,
-		connect.WithSchema(utilsServiceMethods.ByName("GeneratePaperWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	utilsServiceValidateWIFHandler := connect.NewUnaryHandler(
-		UtilsServiceValidateWIFProcedure,
-		svc.ValidateWIF,
-		connect.WithSchema(utilsServiceMethods.ByName("ValidateWIF")),
-		connect.WithHandlerOptions(opts...),
-	)
-	utilsServiceWIFToAddressHandler := connect.NewUnaryHandler(
-		UtilsServiceWIFToAddressProcedure,
-		svc.WIFToAddress,
-		connect.WithSchema(utilsServiceMethods.ByName("WIFToAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/utils.v1.UtilsService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case UtilsServiceParseBitcoinURIProcedure:
-			utilsServiceParseBitcoinURIHandler.ServeHTTP(w, r)
-		case UtilsServiceValidateBitcoinURIProcedure:
-			utilsServiceValidateBitcoinURIHandler.ServeHTTP(w, r)
-		case UtilsServiceDecodeBase58CheckProcedure:
-			utilsServiceDecodeBase58CheckHandler.ServeHTTP(w, r)
-		case UtilsServiceEncodeBase58CheckProcedure:
-			utilsServiceEncodeBase58CheckHandler.ServeHTTP(w, r)
-		case UtilsServiceCalculateMerkleTreeProcedure:
-			utilsServiceCalculateMerkleTreeHandler.ServeHTTP(w, r)
-		case UtilsServiceGeneratePaperWalletProcedure:
-			utilsServiceGeneratePaperWalletHandler.ServeHTTP(w, r)
-		case UtilsServiceValidateWIFProcedure:
-			utilsServiceValidateWIFHandler.ServeHTTP(w, r)
-		case UtilsServiceWIFToAddressProcedure:
-			utilsServiceWIFToAddressHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type utilsServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedUtilsServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedUtilsServiceHandler struct{}
+func (c *utilsServiceClient) ParseBitcoinURI(ctx context.Context, req *v1.ParseBitcoinURIRequest) (*v1.ParseBitcoinURIResponse, error) {
+	var res v1.ParseBitcoinURIResponse
+	if err := c.client.CallUnary(ctx, utilsServiceParseBitcoinURISpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *utilsServiceClient) ValidateBitcoinURI(ctx context.Context, req *v1.ValidateBitcoinURIRequest) (*v1.ValidateBitcoinURIResponse, error) {
+	var res v1.ValidateBitcoinURIResponse
+	if err := c.client.CallUnary(ctx, utilsServiceValidateBitcoinURISpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *utilsServiceClient) DecodeBase58Check(ctx context.Context, req *v1.DecodeBase58CheckRequest) (*v1.DecodeBase58CheckResponse, error) {
+	var res v1.DecodeBase58CheckResponse
+	if err := c.client.CallUnary(ctx, utilsServiceDecodeBase58CheckSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedUtilsServiceHandler) ParseBitcoinURI(context.Context, *connect.Request[v1.ParseBitcoinURIRequest]) (*connect.Response[v1.ParseBitcoinURIResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.ParseBitcoinURI is not implemented"))
+func (c *utilsServiceClient) EncodeBase58Check(ctx context.Context, req *v1.EncodeBase58CheckRequest) (*v1.EncodeBase58CheckResponse, error) {
+	var res v1.EncodeBase58CheckResponse
+	if err := c.client.CallUnary(ctx, utilsServiceEncodeBase58CheckSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedUtilsServiceHandler) ValidateBitcoinURI(context.Context, *connect.Request[v1.ValidateBitcoinURIRequest]) (*connect.Response[v1.ValidateBitcoinURIResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.ValidateBitcoinURI is not implemented"))
+func (c *utilsServiceClient) CalculateMerkleTree(ctx context.Context, req *v1.CalculateMerkleTreeRequest) (*v1.CalculateMerkleTreeResponse, error) {
+	var res v1.CalculateMerkleTreeResponse
+	if err := c.client.CallUnary(ctx, utilsServiceCalculateMerkleTreeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedUtilsServiceHandler) DecodeBase58Check(context.Context, *connect.Request[v1.DecodeBase58CheckRequest]) (*connect.Response[v1.DecodeBase58CheckResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.DecodeBase58Check is not implemented"))
+func (c *utilsServiceClient) GeneratePaperWallet(ctx context.Context, req *emptypb.Empty) (*v1.GeneratePaperWalletResponse, error) {
+	var res v1.GeneratePaperWalletResponse
+	if err := c.client.CallUnary(ctx, utilsServiceGeneratePaperWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedUtilsServiceHandler) EncodeBase58Check(context.Context, *connect.Request[v1.EncodeBase58CheckRequest]) (*connect.Response[v1.EncodeBase58CheckResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.EncodeBase58Check is not implemented"))
+func (c *utilsServiceClient) ValidateWIF(ctx context.Context, req *v1.ValidateWIFRequest) (*v1.ValidateWIFResponse, error) {
+	var res v1.ValidateWIFResponse
+	if err := c.client.CallUnary(ctx, utilsServiceValidateWIFSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedUtilsServiceHandler) CalculateMerkleTree(context.Context, *connect.Request[v1.CalculateMerkleTreeRequest]) (*connect.Response[v1.CalculateMerkleTreeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.CalculateMerkleTree is not implemented"))
+func (c *utilsServiceClient) WIFToAddress(ctx context.Context, req *v1.WIFToAddressRequest) (*v1.WIFToAddressResponse, error) {
+	var res v1.WIFToAddressResponse
+	if err := c.client.CallUnary(ctx, utilsServiceWIFToAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedUtilsServiceHandler) GeneratePaperWallet(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GeneratePaperWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.GeneratePaperWallet is not implemented"))
+type utilsServiceHandler struct{ svc UtilsServiceHandler }
+
+func (h utilsServiceHandler) parseBitcoinURI(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ParseBitcoinURIRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ParseBitcoinURI(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedUtilsServiceHandler) ValidateWIF(context.Context, *connect.Request[v1.ValidateWIFRequest]) (*connect.Response[v1.ValidateWIFResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.ValidateWIF is not implemented"))
+func (h utilsServiceHandler) validateBitcoinURI(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ValidateBitcoinURIRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ValidateBitcoinURI(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedUtilsServiceHandler) WIFToAddress(context.Context, *connect.Request[v1.WIFToAddressRequest]) (*connect.Response[v1.WIFToAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("utils.v1.UtilsService.WIFToAddress is not implemented"))
+func (h utilsServiceHandler) decodeBase58Check(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DecodeBase58CheckRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DecodeBase58Check(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h utilsServiceHandler) encodeBase58Check(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EncodeBase58CheckRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EncodeBase58Check(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h utilsServiceHandler) calculateMerkleTree(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CalculateMerkleTreeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CalculateMerkleTree(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h utilsServiceHandler) generatePaperWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GeneratePaperWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h utilsServiceHandler) validateWIF(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ValidateWIFRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ValidateWIF(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h utilsServiceHandler) wIFToAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WIFToAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.WIFToAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/wallet/v1/walletv1connect/wallet.connect.go b/bitwindow/server/gen/wallet/v1/walletv1connect/wallet.connect.go
index 632a2a05a9..7071c36240 100644
--- a/bitwindow/server/gen/wallet/v1/walletv1connect/wallet.connect.go
+++ b/bitwindow/server/gen/wallet/v1/walletv1connect/wallet.connect.go
@@ -5,1053 +5,1264 @@
 package walletv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/wallet/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// WalletServiceName is the fully-qualified name of the WalletService service.
 	WalletServiceName = "wallet.v1.WalletService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// WalletServiceSendTransactionProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceSendTransactionProcedure is the procedure name of the WalletService's
 	// SendTransaction RPC.
 	WalletServiceSendTransactionProcedure = "/wallet.v1.WalletService/SendTransaction"
-	// WalletServiceGetBalanceProcedure is the fully-qualified name of the WalletService's GetBalance
-	// RPC.
+	// WalletServiceGetBalanceProcedure is the procedure name of the WalletService's GetBalance RPC.
 	WalletServiceGetBalanceProcedure = "/wallet.v1.WalletService/GetBalance"
-	// WalletServiceGetNewAddressProcedure is the fully-qualified name of the WalletService's
-	// GetNewAddress RPC.
+	// WalletServiceGetNewAddressProcedure is the procedure name of the WalletService's GetNewAddress
+	// RPC.
 	WalletServiceGetNewAddressProcedure = "/wallet.v1.WalletService/GetNewAddress"
-	// WalletServiceListTransactionsProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceListTransactionsProcedure is the procedure name of the WalletService's
 	// ListTransactions RPC.
 	WalletServiceListTransactionsProcedure = "/wallet.v1.WalletService/ListTransactions"
-	// WalletServiceListUnspentProcedure is the fully-qualified name of the WalletService's ListUnspent
-	// RPC.
+	// WalletServiceListUnspentProcedure is the procedure name of the WalletService's ListUnspent RPC.
 	WalletServiceListUnspentProcedure = "/wallet.v1.WalletService/ListUnspent"
-	// WalletServiceListReceiveAddressesProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceListReceiveAddressesProcedure is the procedure name of the WalletService's
 	// ListReceiveAddresses RPC.
 	WalletServiceListReceiveAddressesProcedure = "/wallet.v1.WalletService/ListReceiveAddresses"
-	// WalletServiceListSidechainDepositsProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceListSidechainDepositsProcedure is the procedure name of the WalletService's
 	// ListSidechainDeposits RPC.
 	WalletServiceListSidechainDepositsProcedure = "/wallet.v1.WalletService/ListSidechainDeposits"
-	// WalletServiceCreateSidechainDepositProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceCreateSidechainDepositProcedure is the procedure name of the WalletService's
 	// CreateSidechainDeposit RPC.
 	WalletServiceCreateSidechainDepositProcedure = "/wallet.v1.WalletService/CreateSidechainDeposit"
-	// WalletServiceSignMessageProcedure is the fully-qualified name of the WalletService's SignMessage
-	// RPC.
+	// WalletServiceSignMessageProcedure is the procedure name of the WalletService's SignMessage RPC.
 	WalletServiceSignMessageProcedure = "/wallet.v1.WalletService/SignMessage"
-	// WalletServiceVerifyMessageProcedure is the fully-qualified name of the WalletService's
-	// VerifyMessage RPC.
+	// WalletServiceVerifyMessageProcedure is the procedure name of the WalletService's VerifyMessage
+	// RPC.
 	WalletServiceVerifyMessageProcedure = "/wallet.v1.WalletService/VerifyMessage"
-	// WalletServiceGetStatsProcedure is the fully-qualified name of the WalletService's GetStats RPC.
+	// WalletServiceGetStatsProcedure is the procedure name of the WalletService's GetStats RPC.
 	WalletServiceGetStatsProcedure = "/wallet.v1.WalletService/GetStats"
-	// WalletServiceUnlockWalletProcedure is the fully-qualified name of the WalletService's
-	// UnlockWallet RPC.
+	// WalletServiceUnlockWalletProcedure is the procedure name of the WalletService's UnlockWallet RPC.
 	WalletServiceUnlockWalletProcedure = "/wallet.v1.WalletService/UnlockWallet"
-	// WalletServiceLockWalletProcedure is the fully-qualified name of the WalletService's LockWallet
-	// RPC.
+	// WalletServiceLockWalletProcedure is the procedure name of the WalletService's LockWallet RPC.
 	WalletServiceLockWalletProcedure = "/wallet.v1.WalletService/LockWallet"
-	// WalletServiceIsWalletUnlockedProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceIsWalletUnlockedProcedure is the procedure name of the WalletService's
 	// IsWalletUnlocked RPC.
 	WalletServiceIsWalletUnlockedProcedure = "/wallet.v1.WalletService/IsWalletUnlocked"
-	// WalletServiceCreateChequeProcedure is the fully-qualified name of the WalletService's
-	// CreateCheque RPC.
+	// WalletServiceCreateChequeProcedure is the procedure name of the WalletService's CreateCheque RPC.
 	WalletServiceCreateChequeProcedure = "/wallet.v1.WalletService/CreateCheque"
-	// WalletServiceGetChequeProcedure is the fully-qualified name of the WalletService's GetCheque RPC.
+	// WalletServiceGetChequeProcedure is the procedure name of the WalletService's GetCheque RPC.
 	WalletServiceGetChequeProcedure = "/wallet.v1.WalletService/GetCheque"
-	// WalletServiceGetChequePrivateKeyProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceGetChequePrivateKeyProcedure is the procedure name of the WalletService's
 	// GetChequePrivateKey RPC.
 	WalletServiceGetChequePrivateKeyProcedure = "/wallet.v1.WalletService/GetChequePrivateKey"
-	// WalletServiceListChequesProcedure is the fully-qualified name of the WalletService's ListCheques
-	// RPC.
+	// WalletServiceListChequesProcedure is the procedure name of the WalletService's ListCheques RPC.
 	WalletServiceListChequesProcedure = "/wallet.v1.WalletService/ListCheques"
-	// WalletServiceCheckChequeFundingProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceCheckChequeFundingProcedure is the procedure name of the WalletService's
 	// CheckChequeFunding RPC.
 	WalletServiceCheckChequeFundingProcedure = "/wallet.v1.WalletService/CheckChequeFunding"
-	// WalletServicePreviewSweepProcedure is the fully-qualified name of the WalletService's
-	// PreviewSweep RPC.
+	// WalletServicePreviewSweepProcedure is the procedure name of the WalletService's PreviewSweep RPC.
 	WalletServicePreviewSweepProcedure = "/wallet.v1.WalletService/PreviewSweep"
-	// WalletServiceSweepChequeProcedure is the fully-qualified name of the WalletService's SweepCheque
-	// RPC.
+	// WalletServiceSweepChequeProcedure is the procedure name of the WalletService's SweepCheque RPC.
 	WalletServiceSweepChequeProcedure = "/wallet.v1.WalletService/SweepCheque"
-	// WalletServiceDeleteChequeProcedure is the fully-qualified name of the WalletService's
-	// DeleteCheque RPC.
+	// WalletServiceDeleteChequeProcedure is the procedure name of the WalletService's DeleteCheque RPC.
 	WalletServiceDeleteChequeProcedure = "/wallet.v1.WalletService/DeleteCheque"
-	// WalletServiceSetUTXOMetadataProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceSetUTXOMetadataProcedure is the procedure name of the WalletService's
 	// SetUTXOMetadata RPC.
 	WalletServiceSetUTXOMetadataProcedure = "/wallet.v1.WalletService/SetUTXOMetadata"
-	// WalletServiceGetUTXOMetadataProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceGetUTXOMetadataProcedure is the procedure name of the WalletService's
 	// GetUTXOMetadata RPC.
 	WalletServiceGetUTXOMetadataProcedure = "/wallet.v1.WalletService/GetUTXOMetadata"
-	// WalletServiceSetCoinSelectionStrategyProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceSetCoinSelectionStrategyProcedure is the procedure name of the WalletService's
 	// SetCoinSelectionStrategy RPC.
 	WalletServiceSetCoinSelectionStrategyProcedure = "/wallet.v1.WalletService/SetCoinSelectionStrategy"
-	// WalletServiceGetCoinSelectionStrategyProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceGetCoinSelectionStrategyProcedure is the procedure name of the WalletService's
 	// GetCoinSelectionStrategy RPC.
 	WalletServiceGetCoinSelectionStrategyProcedure = "/wallet.v1.WalletService/GetCoinSelectionStrategy"
-	// WalletServiceGetTransactionDetailsProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceGetTransactionDetailsProcedure is the procedure name of the WalletService's
 	// GetTransactionDetails RPC.
 	WalletServiceGetTransactionDetailsProcedure = "/wallet.v1.WalletService/GetTransactionDetails"
-	// WalletServiceGetUTXODistributionProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceGetUTXODistributionProcedure is the procedure name of the WalletService's
 	// GetUTXODistribution RPC.
 	WalletServiceGetUTXODistributionProcedure = "/wallet.v1.WalletService/GetUTXODistribution"
-	// WalletServiceBumpFeeProcedure is the fully-qualified name of the WalletService's BumpFee RPC.
+	// WalletServiceBumpFeeProcedure is the procedure name of the WalletService's BumpFee RPC.
 	WalletServiceBumpFeeProcedure = "/wallet.v1.WalletService/BumpFee"
-	// WalletServiceSelectCoinsProcedure is the fully-qualified name of the WalletService's SelectCoins
-	// RPC.
+	// WalletServiceSelectCoinsProcedure is the procedure name of the WalletService's SelectCoins RPC.
 	WalletServiceSelectCoinsProcedure = "/wallet.v1.WalletService/SelectCoins"
-	// WalletServiceCreateBackupProcedure is the fully-qualified name of the WalletService's
-	// CreateBackup RPC.
+	// WalletServiceCreateBackupProcedure is the procedure name of the WalletService's CreateBackup RPC.
 	WalletServiceCreateBackupProcedure = "/wallet.v1.WalletService/CreateBackup"
-	// WalletServiceRestoreBackupProcedure is the fully-qualified name of the WalletService's
-	// RestoreBackup RPC.
+	// WalletServiceRestoreBackupProcedure is the procedure name of the WalletService's RestoreBackup
+	// RPC.
 	WalletServiceRestoreBackupProcedure = "/wallet.v1.WalletService/RestoreBackup"
-	// WalletServiceValidateBackupProcedure is the fully-qualified name of the WalletService's
-	// ValidateBackup RPC.
+	// WalletServiceValidateBackupProcedure is the procedure name of the WalletService's ValidateBackup
+	// RPC.
 	WalletServiceValidateBackupProcedure = "/wallet.v1.WalletService/ValidateBackup"
 )
 
+var (
+	walletServiceSendTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("SendTransaction"),
+			Procedure:  WalletServiceSendTransactionProcedure,
+		}
+	})
+	walletServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetBalance"),
+			Procedure:  WalletServiceGetBalanceProcedure,
+		}
+	})
+	walletServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetNewAddress"),
+			Procedure:  WalletServiceGetNewAddressProcedure,
+		}
+	})
+	walletServiceListTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListTransactions"),
+			Procedure:  WalletServiceListTransactionsProcedure,
+		}
+	})
+	walletServiceListUnspentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListUnspent"),
+			Procedure:  WalletServiceListUnspentProcedure,
+		}
+	})
+	walletServiceListReceiveAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListReceiveAddresses"),
+			Procedure:  WalletServiceListReceiveAddressesProcedure,
+		}
+	})
+	walletServiceListSidechainDepositsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListSidechainDeposits"),
+			Procedure:  WalletServiceListSidechainDepositsProcedure,
+		}
+	})
+	walletServiceCreateSidechainDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CreateSidechainDeposit"),
+			Procedure:  WalletServiceCreateSidechainDepositProcedure,
+		}
+	})
+	walletServiceSignMessageSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("SignMessage"),
+			Procedure:  WalletServiceSignMessageProcedure,
+		}
+	})
+	walletServiceVerifyMessageSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("VerifyMessage"),
+			Procedure:  WalletServiceVerifyMessageProcedure,
+		}
+	})
+	walletServiceGetStatsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetStats"),
+			Procedure:  WalletServiceGetStatsProcedure,
+		}
+	})
+	walletServiceUnlockWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("UnlockWallet"),
+			Procedure:  WalletServiceUnlockWalletProcedure,
+		}
+	})
+	walletServiceLockWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("LockWallet"),
+			Procedure:  WalletServiceLockWalletProcedure,
+		}
+	})
+	walletServiceIsWalletUnlockedSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("IsWalletUnlocked"),
+			Procedure:  WalletServiceIsWalletUnlockedProcedure,
+		}
+	})
+	walletServiceCreateChequeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CreateCheque"),
+			Procedure:  WalletServiceCreateChequeProcedure,
+		}
+	})
+	walletServiceGetChequeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetCheque"),
+			Procedure:  WalletServiceGetChequeProcedure,
+		}
+	})
+	walletServiceGetChequePrivateKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetChequePrivateKey"),
+			Procedure:  WalletServiceGetChequePrivateKeyProcedure,
+		}
+	})
+	walletServiceListChequesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListCheques"),
+			Procedure:  WalletServiceListChequesProcedure,
+		}
+	})
+	walletServiceCheckChequeFundingSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CheckChequeFunding"),
+			Procedure:  WalletServiceCheckChequeFundingProcedure,
+		}
+	})
+	walletServicePreviewSweepSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("PreviewSweep"),
+			Procedure:  WalletServicePreviewSweepProcedure,
+		}
+	})
+	walletServiceSweepChequeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("SweepCheque"),
+			Procedure:  WalletServiceSweepChequeProcedure,
+		}
+	})
+	walletServiceDeleteChequeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("DeleteCheque"),
+			Procedure:  WalletServiceDeleteChequeProcedure,
+		}
+	})
+	walletServiceSetUTXOMetadataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("SetUTXOMetadata"),
+			Procedure:  WalletServiceSetUTXOMetadataProcedure,
+		}
+	})
+	walletServiceGetUTXOMetadataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetUTXOMetadata"),
+			Procedure:  WalletServiceGetUTXOMetadataProcedure,
+		}
+	})
+	walletServiceSetCoinSelectionStrategySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("SetCoinSelectionStrategy"),
+			Procedure:  WalletServiceSetCoinSelectionStrategyProcedure,
+		}
+	})
+	walletServiceGetCoinSelectionStrategySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetCoinSelectionStrategy"),
+			Procedure:  WalletServiceGetCoinSelectionStrategyProcedure,
+		}
+	})
+	walletServiceGetTransactionDetailsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetTransactionDetails"),
+			Procedure:  WalletServiceGetTransactionDetailsProcedure,
+		}
+	})
+	walletServiceGetUTXODistributionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetUTXODistribution"),
+			Procedure:  WalletServiceGetUTXODistributionProcedure,
+		}
+	})
+	walletServiceBumpFeeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("BumpFee"),
+			Procedure:  WalletServiceBumpFeeProcedure,
+		}
+	})
+	walletServiceSelectCoinsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("SelectCoins"),
+			Procedure:  WalletServiceSelectCoinsProcedure,
+		}
+	})
+	walletServiceCreateBackupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CreateBackup"),
+			Procedure:  WalletServiceCreateBackupProcedure,
+		}
+	})
+	walletServiceRestoreBackupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("RestoreBackup"),
+			Procedure:  WalletServiceRestoreBackupProcedure,
+		}
+	})
+	walletServiceValidateBackupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ValidateBackup"),
+			Procedure:  WalletServiceValidateBackupProcedure,
+		}
+	})
+)
+
 // WalletServiceClient is a client for the wallet.v1.WalletService service.
 type WalletServiceClient interface {
-	SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error)
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Problem: deriving nilly willy here is potentially problematic. There's no way of listing
-	// out unused addresses, so we risk crossing the sync gap.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	ListUnspent(context.Context, *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error)
-	ListReceiveAddresses(context.Context, *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error)
-	ListSidechainDeposits(context.Context, *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error)
-	CreateSidechainDeposit(context.Context, *connect.Request[v1.CreateSidechainDepositRequest]) (*connect.Response[v1.CreateSidechainDepositResponse], error)
-	SignMessage(context.Context, *connect.Request[v1.SignMessageRequest]) (*connect.Response[v1.SignMessageResponse], error)
-	VerifyMessage(context.Context, *connect.Request[v1.VerifyMessageRequest]) (*connect.Response[v1.VerifyMessageResponse], error)
-	GetStats(context.Context, *connect.Request[v1.GetStatsRequest]) (*connect.Response[v1.GetStatsResponse], error)
-	// Wallet unlock/lock for cheque operations
-	UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[emptypb.Empty], error)
-	LockWallet(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	IsWalletUnlocked(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	// Cheque operations
-	CreateCheque(context.Context, *connect.Request[v1.CreateChequeRequest]) (*connect.Response[v1.CreateChequeResponse], error)
-	GetCheque(context.Context, *connect.Request[v1.GetChequeRequest]) (*connect.Response[v1.GetChequeResponse], error)
-	GetChequePrivateKey(context.Context, *connect.Request[v1.GetChequePrivateKeyRequest]) (*connect.Response[v1.GetChequePrivateKeyResponse], error)
-	ListCheques(context.Context, *connect.Request[v1.ListChequesRequest]) (*connect.Response[v1.ListChequesResponse], error)
-	CheckChequeFunding(context.Context, *connect.Request[v1.CheckChequeFundingRequest]) (*connect.Response[v1.CheckChequeFundingResponse], error)
-	PreviewSweep(context.Context, *connect.Request[v1.PreviewSweepRequest]) (*connect.Response[v1.PreviewSweepResponse], error)
-	SweepCheque(context.Context, *connect.Request[v1.SweepChequeRequest]) (*connect.Response[v1.SweepChequeResponse], error)
-	DeleteCheque(context.Context, *connect.Request[v1.DeleteChequeRequest]) (*connect.Response[emptypb.Empty], error)
-	// UTXO Coin Control
-	SetUTXOMetadata(context.Context, *connect.Request[v1.SetUTXOMetadataRequest]) (*connect.Response[emptypb.Empty], error)
-	GetUTXOMetadata(context.Context, *connect.Request[v1.GetUTXOMetadataRequest]) (*connect.Response[v1.GetUTXOMetadataResponse], error)
-	// Coin Selection Preferences
-	SetCoinSelectionStrategy(context.Context, *connect.Request[v1.SetCoinSelectionStrategyRequest]) (*connect.Response[emptypb.Empty], error)
-	GetCoinSelectionStrategy(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetCoinSelectionStrategyResponse], error)
-	// Transaction Details (enriched with input values/addresses)
-	GetTransactionDetails(context.Context, *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error)
-	// UTXO Distribution (for chart visualization)
-	GetUTXODistribution(context.Context, *connect.Request[v1.GetUTXODistributionRequest]) (*connect.Response[v1.GetUTXODistributionResponse], error)
-	// RBF - Replace-By-Fee for unconfirmed transactions
-	BumpFee(context.Context, *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error)
-	// Coin Selection - Select UTXOs for a transaction
-	SelectCoins(context.Context, *connect.Request[v1.SelectCoinsRequest]) (*connect.Response[v1.SelectCoinsResponse], error)
-	// Backup / Restore
-	CreateBackup(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.CreateBackupResponse], error)
-	RestoreBackup(context.Context, *connect.Request[v1.RestoreBackupRequest]) (*connect.Response[emptypb.Empty], error)
-	ValidateBackup(context.Context, *connect.Request[v1.ValidateBackupRequest]) (*connect.Response[v1.ValidateBackupResponse], error)
-}
-
-// NewWalletServiceClient constructs a client for the wallet.v1.WalletService service. By default,
-// it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and
-// sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC()
-// or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewWalletServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) WalletServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	walletServiceMethods := v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods()
-	return &walletServiceClient{
-		sendTransaction: connect.NewClient[v1.SendTransactionRequest, v1.SendTransactionResponse](
-			httpClient,
-			baseURL+WalletServiceSendTransactionProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("SendTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+WalletServiceGetBalanceProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+WalletServiceGetNewAddressProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		listTransactions: connect.NewClient[v1.ListTransactionsRequest, v1.ListTransactionsResponse](
-			httpClient,
-			baseURL+WalletServiceListTransactionsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListTransactions")),
-			connect.WithClientOptions(opts...),
-		),
-		listUnspent: connect.NewClient[v1.ListUnspentRequest, v1.ListUnspentResponse](
-			httpClient,
-			baseURL+WalletServiceListUnspentProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListUnspent")),
-			connect.WithClientOptions(opts...),
-		),
-		listReceiveAddresses: connect.NewClient[v1.ListReceiveAddressesRequest, v1.ListReceiveAddressesResponse](
-			httpClient,
-			baseURL+WalletServiceListReceiveAddressesProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListReceiveAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		listSidechainDeposits: connect.NewClient[v1.ListSidechainDepositsRequest, v1.ListSidechainDepositsResponse](
-			httpClient,
-			baseURL+WalletServiceListSidechainDepositsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListSidechainDeposits")),
-			connect.WithClientOptions(opts...),
-		),
-		createSidechainDeposit: connect.NewClient[v1.CreateSidechainDepositRequest, v1.CreateSidechainDepositResponse](
-			httpClient,
-			baseURL+WalletServiceCreateSidechainDepositProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CreateSidechainDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		signMessage: connect.NewClient[v1.SignMessageRequest, v1.SignMessageResponse](
-			httpClient,
-			baseURL+WalletServiceSignMessageProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("SignMessage")),
-			connect.WithClientOptions(opts...),
-		),
-		verifyMessage: connect.NewClient[v1.VerifyMessageRequest, v1.VerifyMessageResponse](
-			httpClient,
-			baseURL+WalletServiceVerifyMessageProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("VerifyMessage")),
-			connect.WithClientOptions(opts...),
-		),
-		getStats: connect.NewClient[v1.GetStatsRequest, v1.GetStatsResponse](
-			httpClient,
-			baseURL+WalletServiceGetStatsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetStats")),
-			connect.WithClientOptions(opts...),
-		),
-		unlockWallet: connect.NewClient[v1.UnlockWalletRequest, emptypb.Empty](
-			httpClient,
-			baseURL+WalletServiceUnlockWalletProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("UnlockWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		lockWallet: connect.NewClient[emptypb.Empty, emptypb.Empty](
-			httpClient,
-			baseURL+WalletServiceLockWalletProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("LockWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		isWalletUnlocked: connect.NewClient[emptypb.Empty, emptypb.Empty](
-			httpClient,
-			baseURL+WalletServiceIsWalletUnlockedProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("IsWalletUnlocked")),
-			connect.WithClientOptions(opts...),
-		),
-		createCheque: connect.NewClient[v1.CreateChequeRequest, v1.CreateChequeResponse](
-			httpClient,
-			baseURL+WalletServiceCreateChequeProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CreateCheque")),
-			connect.WithClientOptions(opts...),
-		),
-		getCheque: connect.NewClient[v1.GetChequeRequest, v1.GetChequeResponse](
-			httpClient,
-			baseURL+WalletServiceGetChequeProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetCheque")),
-			connect.WithClientOptions(opts...),
-		),
-		getChequePrivateKey: connect.NewClient[v1.GetChequePrivateKeyRequest, v1.GetChequePrivateKeyResponse](
-			httpClient,
-			baseURL+WalletServiceGetChequePrivateKeyProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetChequePrivateKey")),
-			connect.WithClientOptions(opts...),
-		),
-		listCheques: connect.NewClient[v1.ListChequesRequest, v1.ListChequesResponse](
-			httpClient,
-			baseURL+WalletServiceListChequesProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListCheques")),
-			connect.WithClientOptions(opts...),
-		),
-		checkChequeFunding: connect.NewClient[v1.CheckChequeFundingRequest, v1.CheckChequeFundingResponse](
-			httpClient,
-			baseURL+WalletServiceCheckChequeFundingProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CheckChequeFunding")),
-			connect.WithClientOptions(opts...),
-		),
-		previewSweep: connect.NewClient[v1.PreviewSweepRequest, v1.PreviewSweepResponse](
-			httpClient,
-			baseURL+WalletServicePreviewSweepProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("PreviewSweep")),
-			connect.WithClientOptions(opts...),
-		),
-		sweepCheque: connect.NewClient[v1.SweepChequeRequest, v1.SweepChequeResponse](
-			httpClient,
-			baseURL+WalletServiceSweepChequeProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("SweepCheque")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteCheque: connect.NewClient[v1.DeleteChequeRequest, emptypb.Empty](
-			httpClient,
-			baseURL+WalletServiceDeleteChequeProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("DeleteCheque")),
-			connect.WithClientOptions(opts...),
-		),
-		setUTXOMetadata: connect.NewClient[v1.SetUTXOMetadataRequest, emptypb.Empty](
-			httpClient,
-			baseURL+WalletServiceSetUTXOMetadataProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("SetUTXOMetadata")),
-			connect.WithClientOptions(opts...),
-		),
-		getUTXOMetadata: connect.NewClient[v1.GetUTXOMetadataRequest, v1.GetUTXOMetadataResponse](
-			httpClient,
-			baseURL+WalletServiceGetUTXOMetadataProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetUTXOMetadata")),
-			connect.WithClientOptions(opts...),
-		),
-		setCoinSelectionStrategy: connect.NewClient[v1.SetCoinSelectionStrategyRequest, emptypb.Empty](
-			httpClient,
-			baseURL+WalletServiceSetCoinSelectionStrategyProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("SetCoinSelectionStrategy")),
-			connect.WithClientOptions(opts...),
-		),
-		getCoinSelectionStrategy: connect.NewClient[emptypb.Empty, v1.GetCoinSelectionStrategyResponse](
-			httpClient,
-			baseURL+WalletServiceGetCoinSelectionStrategyProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetCoinSelectionStrategy")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransactionDetails: connect.NewClient[v1.GetTransactionDetailsRequest, v1.GetTransactionDetailsResponse](
-			httpClient,
-			baseURL+WalletServiceGetTransactionDetailsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetTransactionDetails")),
-			connect.WithClientOptions(opts...),
-		),
-		getUTXODistribution: connect.NewClient[v1.GetUTXODistributionRequest, v1.GetUTXODistributionResponse](
-			httpClient,
-			baseURL+WalletServiceGetUTXODistributionProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetUTXODistribution")),
-			connect.WithClientOptions(opts...),
-		),
-		bumpFee: connect.NewClient[v1.BumpFeeRequest, v1.BumpFeeResponse](
-			httpClient,
-			baseURL+WalletServiceBumpFeeProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("BumpFee")),
-			connect.WithClientOptions(opts...),
-		),
-		selectCoins: connect.NewClient[v1.SelectCoinsRequest, v1.SelectCoinsResponse](
-			httpClient,
-			baseURL+WalletServiceSelectCoinsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("SelectCoins")),
-			connect.WithClientOptions(opts...),
-		),
-		createBackup: connect.NewClient[emptypb.Empty, v1.CreateBackupResponse](
-			httpClient,
-			baseURL+WalletServiceCreateBackupProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CreateBackup")),
-			connect.WithClientOptions(opts...),
-		),
-		restoreBackup: connect.NewClient[v1.RestoreBackupRequest, emptypb.Empty](
-			httpClient,
-			baseURL+WalletServiceRestoreBackupProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("RestoreBackup")),
-			connect.WithClientOptions(opts...),
-		),
-		validateBackup: connect.NewClient[v1.ValidateBackupRequest, v1.ValidateBackupResponse](
-			httpClient,
-			baseURL+WalletServiceValidateBackupProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ValidateBackup")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// walletServiceClient implements WalletServiceClient.
-type walletServiceClient struct {
-	sendTransaction          *connect.Client[v1.SendTransactionRequest, v1.SendTransactionResponse]
-	getBalance               *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getNewAddress            *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	listTransactions         *connect.Client[v1.ListTransactionsRequest, v1.ListTransactionsResponse]
-	listUnspent              *connect.Client[v1.ListUnspentRequest, v1.ListUnspentResponse]
-	listReceiveAddresses     *connect.Client[v1.ListReceiveAddressesRequest, v1.ListReceiveAddressesResponse]
-	listSidechainDeposits    *connect.Client[v1.ListSidechainDepositsRequest, v1.ListSidechainDepositsResponse]
-	createSidechainDeposit   *connect.Client[v1.CreateSidechainDepositRequest, v1.CreateSidechainDepositResponse]
-	signMessage              *connect.Client[v1.SignMessageRequest, v1.SignMessageResponse]
-	verifyMessage            *connect.Client[v1.VerifyMessageRequest, v1.VerifyMessageResponse]
-	getStats                 *connect.Client[v1.GetStatsRequest, v1.GetStatsResponse]
-	unlockWallet             *connect.Client[v1.UnlockWalletRequest, emptypb.Empty]
-	lockWallet               *connect.Client[emptypb.Empty, emptypb.Empty]
-	isWalletUnlocked         *connect.Client[emptypb.Empty, emptypb.Empty]
-	createCheque             *connect.Client[v1.CreateChequeRequest, v1.CreateChequeResponse]
-	getCheque                *connect.Client[v1.GetChequeRequest, v1.GetChequeResponse]
-	getChequePrivateKey      *connect.Client[v1.GetChequePrivateKeyRequest, v1.GetChequePrivateKeyResponse]
-	listCheques              *connect.Client[v1.ListChequesRequest, v1.ListChequesResponse]
-	checkChequeFunding       *connect.Client[v1.CheckChequeFundingRequest, v1.CheckChequeFundingResponse]
-	previewSweep             *connect.Client[v1.PreviewSweepRequest, v1.PreviewSweepResponse]
-	sweepCheque              *connect.Client[v1.SweepChequeRequest, v1.SweepChequeResponse]
-	deleteCheque             *connect.Client[v1.DeleteChequeRequest, emptypb.Empty]
-	setUTXOMetadata          *connect.Client[v1.SetUTXOMetadataRequest, emptypb.Empty]
-	getUTXOMetadata          *connect.Client[v1.GetUTXOMetadataRequest, v1.GetUTXOMetadataResponse]
-	setCoinSelectionStrategy *connect.Client[v1.SetCoinSelectionStrategyRequest, emptypb.Empty]
-	getCoinSelectionStrategy *connect.Client[emptypb.Empty, v1.GetCoinSelectionStrategyResponse]
-	getTransactionDetails    *connect.Client[v1.GetTransactionDetailsRequest, v1.GetTransactionDetailsResponse]
-	getUTXODistribution      *connect.Client[v1.GetUTXODistributionRequest, v1.GetUTXODistributionResponse]
-	bumpFee                  *connect.Client[v1.BumpFeeRequest, v1.BumpFeeResponse]
-	selectCoins              *connect.Client[v1.SelectCoinsRequest, v1.SelectCoinsResponse]
-	createBackup             *connect.Client[emptypb.Empty, v1.CreateBackupResponse]
-	restoreBackup            *connect.Client[v1.RestoreBackupRequest, emptypb.Empty]
-	validateBackup           *connect.Client[v1.ValidateBackupRequest, v1.ValidateBackupResponse]
+	SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error)
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	ListUnspent(context.Context, *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error)
+	ListReceiveAddresses(context.Context, *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error)
+	ListSidechainDeposits(context.Context, *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error)
+	CreateSidechainDeposit(context.Context, *v1.CreateSidechainDepositRequest) (*v1.CreateSidechainDepositResponse, error)
+	SignMessage(context.Context, *v1.SignMessageRequest) (*v1.SignMessageResponse, error)
+	VerifyMessage(context.Context, *v1.VerifyMessageRequest) (*v1.VerifyMessageResponse, error)
+	GetStats(context.Context, *v1.GetStatsRequest) (*v1.GetStatsResponse, error)
+	UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*emptypb.Empty, error)
+	LockWallet(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	IsWalletUnlocked(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	CreateCheque(context.Context, *v1.CreateChequeRequest) (*v1.CreateChequeResponse, error)
+	GetCheque(context.Context, *v1.GetChequeRequest) (*v1.GetChequeResponse, error)
+	GetChequePrivateKey(context.Context, *v1.GetChequePrivateKeyRequest) (*v1.GetChequePrivateKeyResponse, error)
+	ListCheques(context.Context, *v1.ListChequesRequest) (*v1.ListChequesResponse, error)
+	CheckChequeFunding(context.Context, *v1.CheckChequeFundingRequest) (*v1.CheckChequeFundingResponse, error)
+	PreviewSweep(context.Context, *v1.PreviewSweepRequest) (*v1.PreviewSweepResponse, error)
+	SweepCheque(context.Context, *v1.SweepChequeRequest) (*v1.SweepChequeResponse, error)
+	DeleteCheque(context.Context, *v1.DeleteChequeRequest) (*emptypb.Empty, error)
+	SetUTXOMetadata(context.Context, *v1.SetUTXOMetadataRequest) (*emptypb.Empty, error)
+	GetUTXOMetadata(context.Context, *v1.GetUTXOMetadataRequest) (*v1.GetUTXOMetadataResponse, error)
+	SetCoinSelectionStrategy(context.Context, *v1.SetCoinSelectionStrategyRequest) (*emptypb.Empty, error)
+	GetCoinSelectionStrategy(context.Context, *emptypb.Empty) (*v1.GetCoinSelectionStrategyResponse, error)
+	GetTransactionDetails(context.Context, *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error)
+	GetUTXODistribution(context.Context, *v1.GetUTXODistributionRequest) (*v1.GetUTXODistributionResponse, error)
+	BumpFee(context.Context, *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error)
+	SelectCoins(context.Context, *v1.SelectCoinsRequest) (*v1.SelectCoinsResponse, error)
+	CreateBackup(context.Context, *emptypb.Empty) (*v1.CreateBackupResponse, error)
+	RestoreBackup(context.Context, *v1.RestoreBackupRequest) (*emptypb.Empty, error)
+	ValidateBackup(context.Context, *v1.ValidateBackupRequest) (*v1.ValidateBackupResponse, error)
+}
+
+// NewWalletServiceClient constructs a client for the wallet.v1.WalletService service. Multiple
+// service clients may share a single connect.Client.
+func NewWalletServiceClient(client *connect.Client) WalletServiceClient {
+	return &walletServiceClient{client: client}
 }
 
-// SendTransaction calls wallet.v1.WalletService.SendTransaction.
-func (c *walletServiceClient) SendTransaction(ctx context.Context, req *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error) {
-	return c.sendTransaction.CallUnary(ctx, req)
+// WalletServiceHandler is an implementation of the wallet.v1.WalletService service.
+type WalletServiceHandler interface {
+	SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error)
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	ListUnspent(context.Context, *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error)
+	ListReceiveAddresses(context.Context, *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error)
+	ListSidechainDeposits(context.Context, *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error)
+	CreateSidechainDeposit(context.Context, *v1.CreateSidechainDepositRequest) (*v1.CreateSidechainDepositResponse, error)
+	SignMessage(context.Context, *v1.SignMessageRequest) (*v1.SignMessageResponse, error)
+	VerifyMessage(context.Context, *v1.VerifyMessageRequest) (*v1.VerifyMessageResponse, error)
+	GetStats(context.Context, *v1.GetStatsRequest) (*v1.GetStatsResponse, error)
+	UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*emptypb.Empty, error)
+	LockWallet(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	IsWalletUnlocked(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
+	CreateCheque(context.Context, *v1.CreateChequeRequest) (*v1.CreateChequeResponse, error)
+	GetCheque(context.Context, *v1.GetChequeRequest) (*v1.GetChequeResponse, error)
+	GetChequePrivateKey(context.Context, *v1.GetChequePrivateKeyRequest) (*v1.GetChequePrivateKeyResponse, error)
+	ListCheques(context.Context, *v1.ListChequesRequest) (*v1.ListChequesResponse, error)
+	CheckChequeFunding(context.Context, *v1.CheckChequeFundingRequest) (*v1.CheckChequeFundingResponse, error)
+	PreviewSweep(context.Context, *v1.PreviewSweepRequest) (*v1.PreviewSweepResponse, error)
+	SweepCheque(context.Context, *v1.SweepChequeRequest) (*v1.SweepChequeResponse, error)
+	DeleteCheque(context.Context, *v1.DeleteChequeRequest) (*emptypb.Empty, error)
+	SetUTXOMetadata(context.Context, *v1.SetUTXOMetadataRequest) (*emptypb.Empty, error)
+	GetUTXOMetadata(context.Context, *v1.GetUTXOMetadataRequest) (*v1.GetUTXOMetadataResponse, error)
+	SetCoinSelectionStrategy(context.Context, *v1.SetCoinSelectionStrategyRequest) (*emptypb.Empty, error)
+	GetCoinSelectionStrategy(context.Context, *emptypb.Empty) (*v1.GetCoinSelectionStrategyResponse, error)
+	GetTransactionDetails(context.Context, *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error)
+	GetUTXODistribution(context.Context, *v1.GetUTXODistributionRequest) (*v1.GetUTXODistributionResponse, error)
+	BumpFee(context.Context, *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error)
+	SelectCoins(context.Context, *v1.SelectCoinsRequest) (*v1.SelectCoinsResponse, error)
+	CreateBackup(context.Context, *emptypb.Empty) (*v1.CreateBackupResponse, error)
+	RestoreBackup(context.Context, *v1.RestoreBackupRequest) (*emptypb.Empty, error)
+	ValidateBackup(context.Context, *v1.ValidateBackupRequest) (*v1.ValidateBackupResponse, error)
+}
+
+// RegisterWalletServiceHandler registers svc as the wallet.v1.WalletService implementation on
+// server.
+func RegisterWalletServiceHandler(server *connect.Server, svc WalletServiceHandler) {
+	adapter := walletServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: walletServiceSendTransactionSpec(), Handler: adapter.sendTransaction},
+		connect.Method{Spec: walletServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: walletServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: walletServiceListTransactionsSpec(), Handler: adapter.listTransactions},
+		connect.Method{Spec: walletServiceListUnspentSpec(), Handler: adapter.listUnspent},
+		connect.Method{Spec: walletServiceListReceiveAddressesSpec(), Handler: adapter.listReceiveAddresses},
+		connect.Method{Spec: walletServiceListSidechainDepositsSpec(), Handler: adapter.listSidechainDeposits},
+		connect.Method{Spec: walletServiceCreateSidechainDepositSpec(), Handler: adapter.createSidechainDeposit},
+		connect.Method{Spec: walletServiceSignMessageSpec(), Handler: adapter.signMessage},
+		connect.Method{Spec: walletServiceVerifyMessageSpec(), Handler: adapter.verifyMessage},
+		connect.Method{Spec: walletServiceGetStatsSpec(), Handler: adapter.getStats},
+		connect.Method{Spec: walletServiceUnlockWalletSpec(), Handler: adapter.unlockWallet},
+		connect.Method{Spec: walletServiceLockWalletSpec(), Handler: adapter.lockWallet},
+		connect.Method{Spec: walletServiceIsWalletUnlockedSpec(), Handler: adapter.isWalletUnlocked},
+		connect.Method{Spec: walletServiceCreateChequeSpec(), Handler: adapter.createCheque},
+		connect.Method{Spec: walletServiceGetChequeSpec(), Handler: adapter.getCheque},
+		connect.Method{Spec: walletServiceGetChequePrivateKeySpec(), Handler: adapter.getChequePrivateKey},
+		connect.Method{Spec: walletServiceListChequesSpec(), Handler: adapter.listCheques},
+		connect.Method{Spec: walletServiceCheckChequeFundingSpec(), Handler: adapter.checkChequeFunding},
+		connect.Method{Spec: walletServicePreviewSweepSpec(), Handler: adapter.previewSweep},
+		connect.Method{Spec: walletServiceSweepChequeSpec(), Handler: adapter.sweepCheque},
+		connect.Method{Spec: walletServiceDeleteChequeSpec(), Handler: adapter.deleteCheque},
+		connect.Method{Spec: walletServiceSetUTXOMetadataSpec(), Handler: adapter.setUTXOMetadata},
+		connect.Method{Spec: walletServiceGetUTXOMetadataSpec(), Handler: adapter.getUTXOMetadata},
+		connect.Method{Spec: walletServiceSetCoinSelectionStrategySpec(), Handler: adapter.setCoinSelectionStrategy},
+		connect.Method{Spec: walletServiceGetCoinSelectionStrategySpec(), Handler: adapter.getCoinSelectionStrategy},
+		connect.Method{Spec: walletServiceGetTransactionDetailsSpec(), Handler: adapter.getTransactionDetails},
+		connect.Method{Spec: walletServiceGetUTXODistributionSpec(), Handler: adapter.getUTXODistribution},
+		connect.Method{Spec: walletServiceBumpFeeSpec(), Handler: adapter.bumpFee},
+		connect.Method{Spec: walletServiceSelectCoinsSpec(), Handler: adapter.selectCoins},
+		connect.Method{Spec: walletServiceCreateBackupSpec(), Handler: adapter.createBackup},
+		connect.Method{Spec: walletServiceRestoreBackupSpec(), Handler: adapter.restoreBackup},
+		connect.Method{Spec: walletServiceValidateBackupSpec(), Handler: adapter.validateBackup},
+	)
 }
 
-// GetBalance calls wallet.v1.WalletService.GetBalance.
-func (c *walletServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// UnimplementedWalletServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedWalletServiceHandler struct{}
+
+func (UnimplementedWalletServiceHandler) SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.SendTransaction is not implemented")
 }
 
-// GetNewAddress calls wallet.v1.WalletService.GetNewAddress.
-func (c *walletServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetBalance is not implemented")
 }
 
-// ListTransactions calls wallet.v1.WalletService.ListTransactions.
-func (c *walletServiceClient) ListTransactions(ctx context.Context, req *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return c.listTransactions.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetNewAddress is not implemented")
 }
 
-// ListUnspent calls wallet.v1.WalletService.ListUnspent.
-func (c *walletServiceClient) ListUnspent(ctx context.Context, req *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error) {
-	return c.listUnspent.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.ListTransactions is not implemented")
 }
 
-// ListReceiveAddresses calls wallet.v1.WalletService.ListReceiveAddresses.
-func (c *walletServiceClient) ListReceiveAddresses(ctx context.Context, req *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error) {
-	return c.listReceiveAddresses.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) ListUnspent(context.Context, *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.ListUnspent is not implemented")
 }
 
-// ListSidechainDeposits calls wallet.v1.WalletService.ListSidechainDeposits.
-func (c *walletServiceClient) ListSidechainDeposits(ctx context.Context, req *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error) {
-	return c.listSidechainDeposits.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) ListReceiveAddresses(context.Context, *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.ListReceiveAddresses is not implemented")
 }
 
-// CreateSidechainDeposit calls wallet.v1.WalletService.CreateSidechainDeposit.
-func (c *walletServiceClient) CreateSidechainDeposit(ctx context.Context, req *connect.Request[v1.CreateSidechainDepositRequest]) (*connect.Response[v1.CreateSidechainDepositResponse], error) {
-	return c.createSidechainDeposit.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) ListSidechainDeposits(context.Context, *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.ListSidechainDeposits is not implemented")
 }
 
-// SignMessage calls wallet.v1.WalletService.SignMessage.
-func (c *walletServiceClient) SignMessage(ctx context.Context, req *connect.Request[v1.SignMessageRequest]) (*connect.Response[v1.SignMessageResponse], error) {
-	return c.signMessage.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) CreateSidechainDeposit(context.Context, *v1.CreateSidechainDepositRequest) (*v1.CreateSidechainDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.CreateSidechainDeposit is not implemented")
 }
 
-// VerifyMessage calls wallet.v1.WalletService.VerifyMessage.
-func (c *walletServiceClient) VerifyMessage(ctx context.Context, req *connect.Request[v1.VerifyMessageRequest]) (*connect.Response[v1.VerifyMessageResponse], error) {
-	return c.verifyMessage.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) SignMessage(context.Context, *v1.SignMessageRequest) (*v1.SignMessageResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.SignMessage is not implemented")
 }
 
-// GetStats calls wallet.v1.WalletService.GetStats.
-func (c *walletServiceClient) GetStats(ctx context.Context, req *connect.Request[v1.GetStatsRequest]) (*connect.Response[v1.GetStatsResponse], error) {
-	return c.getStats.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) VerifyMessage(context.Context, *v1.VerifyMessageRequest) (*v1.VerifyMessageResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.VerifyMessage is not implemented")
 }
 
-// UnlockWallet calls wallet.v1.WalletService.UnlockWallet.
-func (c *walletServiceClient) UnlockWallet(ctx context.Context, req *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.unlockWallet.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetStats(context.Context, *v1.GetStatsRequest) (*v1.GetStatsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetStats is not implemented")
 }
 
-// LockWallet calls wallet.v1.WalletService.LockWallet.
-func (c *walletServiceClient) LockWallet(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return c.lockWallet.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.UnlockWallet is not implemented")
 }
 
-// IsWalletUnlocked calls wallet.v1.WalletService.IsWalletUnlocked.
-func (c *walletServiceClient) IsWalletUnlocked(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return c.isWalletUnlocked.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) LockWallet(context.Context, *emptypb.Empty) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.LockWallet is not implemented")
 }
 
-// CreateCheque calls wallet.v1.WalletService.CreateCheque.
-func (c *walletServiceClient) CreateCheque(ctx context.Context, req *connect.Request[v1.CreateChequeRequest]) (*connect.Response[v1.CreateChequeResponse], error) {
-	return c.createCheque.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) IsWalletUnlocked(context.Context, *emptypb.Empty) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.IsWalletUnlocked is not implemented")
 }
 
-// GetCheque calls wallet.v1.WalletService.GetCheque.
-func (c *walletServiceClient) GetCheque(ctx context.Context, req *connect.Request[v1.GetChequeRequest]) (*connect.Response[v1.GetChequeResponse], error) {
-	return c.getCheque.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) CreateCheque(context.Context, *v1.CreateChequeRequest) (*v1.CreateChequeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.CreateCheque is not implemented")
 }
 
-// GetChequePrivateKey calls wallet.v1.WalletService.GetChequePrivateKey.
-func (c *walletServiceClient) GetChequePrivateKey(ctx context.Context, req *connect.Request[v1.GetChequePrivateKeyRequest]) (*connect.Response[v1.GetChequePrivateKeyResponse], error) {
-	return c.getChequePrivateKey.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetCheque(context.Context, *v1.GetChequeRequest) (*v1.GetChequeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetCheque is not implemented")
 }
 
-// ListCheques calls wallet.v1.WalletService.ListCheques.
-func (c *walletServiceClient) ListCheques(ctx context.Context, req *connect.Request[v1.ListChequesRequest]) (*connect.Response[v1.ListChequesResponse], error) {
-	return c.listCheques.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetChequePrivateKey(context.Context, *v1.GetChequePrivateKeyRequest) (*v1.GetChequePrivateKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetChequePrivateKey is not implemented")
 }
 
-// CheckChequeFunding calls wallet.v1.WalletService.CheckChequeFunding.
-func (c *walletServiceClient) CheckChequeFunding(ctx context.Context, req *connect.Request[v1.CheckChequeFundingRequest]) (*connect.Response[v1.CheckChequeFundingResponse], error) {
-	return c.checkChequeFunding.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) ListCheques(context.Context, *v1.ListChequesRequest) (*v1.ListChequesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.ListCheques is not implemented")
 }
 
-// PreviewSweep calls wallet.v1.WalletService.PreviewSweep.
-func (c *walletServiceClient) PreviewSweep(ctx context.Context, req *connect.Request[v1.PreviewSweepRequest]) (*connect.Response[v1.PreviewSweepResponse], error) {
-	return c.previewSweep.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) CheckChequeFunding(context.Context, *v1.CheckChequeFundingRequest) (*v1.CheckChequeFundingResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.CheckChequeFunding is not implemented")
 }
 
-// SweepCheque calls wallet.v1.WalletService.SweepCheque.
-func (c *walletServiceClient) SweepCheque(ctx context.Context, req *connect.Request[v1.SweepChequeRequest]) (*connect.Response[v1.SweepChequeResponse], error) {
-	return c.sweepCheque.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) PreviewSweep(context.Context, *v1.PreviewSweepRequest) (*v1.PreviewSweepResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.PreviewSweep is not implemented")
 }
 
-// DeleteCheque calls wallet.v1.WalletService.DeleteCheque.
-func (c *walletServiceClient) DeleteCheque(ctx context.Context, req *connect.Request[v1.DeleteChequeRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.deleteCheque.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) SweepCheque(context.Context, *v1.SweepChequeRequest) (*v1.SweepChequeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.SweepCheque is not implemented")
 }
 
-// SetUTXOMetadata calls wallet.v1.WalletService.SetUTXOMetadata.
-func (c *walletServiceClient) SetUTXOMetadata(ctx context.Context, req *connect.Request[v1.SetUTXOMetadataRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.setUTXOMetadata.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) DeleteCheque(context.Context, *v1.DeleteChequeRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.DeleteCheque is not implemented")
 }
 
-// GetUTXOMetadata calls wallet.v1.WalletService.GetUTXOMetadata.
-func (c *walletServiceClient) GetUTXOMetadata(ctx context.Context, req *connect.Request[v1.GetUTXOMetadataRequest]) (*connect.Response[v1.GetUTXOMetadataResponse], error) {
-	return c.getUTXOMetadata.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) SetUTXOMetadata(context.Context, *v1.SetUTXOMetadataRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.SetUTXOMetadata is not implemented")
 }
 
-// SetCoinSelectionStrategy calls wallet.v1.WalletService.SetCoinSelectionStrategy.
-func (c *walletServiceClient) SetCoinSelectionStrategy(ctx context.Context, req *connect.Request[v1.SetCoinSelectionStrategyRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.setCoinSelectionStrategy.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetUTXOMetadata(context.Context, *v1.GetUTXOMetadataRequest) (*v1.GetUTXOMetadataResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetUTXOMetadata is not implemented")
 }
 
-// GetCoinSelectionStrategy calls wallet.v1.WalletService.GetCoinSelectionStrategy.
-func (c *walletServiceClient) GetCoinSelectionStrategy(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetCoinSelectionStrategyResponse], error) {
-	return c.getCoinSelectionStrategy.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) SetCoinSelectionStrategy(context.Context, *v1.SetCoinSelectionStrategyRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.SetCoinSelectionStrategy is not implemented")
 }
 
-// GetTransactionDetails calls wallet.v1.WalletService.GetTransactionDetails.
-func (c *walletServiceClient) GetTransactionDetails(ctx context.Context, req *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error) {
-	return c.getTransactionDetails.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetCoinSelectionStrategy(context.Context, *emptypb.Empty) (*v1.GetCoinSelectionStrategyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetCoinSelectionStrategy is not implemented")
 }
 
-// GetUTXODistribution calls wallet.v1.WalletService.GetUTXODistribution.
-func (c *walletServiceClient) GetUTXODistribution(ctx context.Context, req *connect.Request[v1.GetUTXODistributionRequest]) (*connect.Response[v1.GetUTXODistributionResponse], error) {
-	return c.getUTXODistribution.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetTransactionDetails(context.Context, *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetTransactionDetails is not implemented")
 }
 
-// BumpFee calls wallet.v1.WalletService.BumpFee.
-func (c *walletServiceClient) BumpFee(ctx context.Context, req *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error) {
-	return c.bumpFee.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) GetUTXODistribution(context.Context, *v1.GetUTXODistributionRequest) (*v1.GetUTXODistributionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.GetUTXODistribution is not implemented")
 }
 
-// SelectCoins calls wallet.v1.WalletService.SelectCoins.
-func (c *walletServiceClient) SelectCoins(ctx context.Context, req *connect.Request[v1.SelectCoinsRequest]) (*connect.Response[v1.SelectCoinsResponse], error) {
-	return c.selectCoins.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) BumpFee(context.Context, *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.BumpFee is not implemented")
 }
 
-// CreateBackup calls wallet.v1.WalletService.CreateBackup.
-func (c *walletServiceClient) CreateBackup(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.CreateBackupResponse], error) {
-	return c.createBackup.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) SelectCoins(context.Context, *v1.SelectCoinsRequest) (*v1.SelectCoinsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.SelectCoins is not implemented")
 }
 
-// RestoreBackup calls wallet.v1.WalletService.RestoreBackup.
-func (c *walletServiceClient) RestoreBackup(ctx context.Context, req *connect.Request[v1.RestoreBackupRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.restoreBackup.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) CreateBackup(context.Context, *emptypb.Empty) (*v1.CreateBackupResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.CreateBackup is not implemented")
 }
 
-// ValidateBackup calls wallet.v1.WalletService.ValidateBackup.
-func (c *walletServiceClient) ValidateBackup(ctx context.Context, req *connect.Request[v1.ValidateBackupRequest]) (*connect.Response[v1.ValidateBackupResponse], error) {
-	return c.validateBackup.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) RestoreBackup(context.Context, *v1.RestoreBackupRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.RestoreBackup is not implemented")
 }
 
-// WalletServiceHandler is an implementation of the wallet.v1.WalletService service.
-type WalletServiceHandler interface {
-	SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error)
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Problem: deriving nilly willy here is potentially problematic. There's no way of listing
-	// out unused addresses, so we risk crossing the sync gap.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	ListUnspent(context.Context, *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error)
-	ListReceiveAddresses(context.Context, *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error)
-	ListSidechainDeposits(context.Context, *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error)
-	CreateSidechainDeposit(context.Context, *connect.Request[v1.CreateSidechainDepositRequest]) (*connect.Response[v1.CreateSidechainDepositResponse], error)
-	SignMessage(context.Context, *connect.Request[v1.SignMessageRequest]) (*connect.Response[v1.SignMessageResponse], error)
-	VerifyMessage(context.Context, *connect.Request[v1.VerifyMessageRequest]) (*connect.Response[v1.VerifyMessageResponse], error)
-	GetStats(context.Context, *connect.Request[v1.GetStatsRequest]) (*connect.Response[v1.GetStatsResponse], error)
-	// Wallet unlock/lock for cheque operations
-	UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[emptypb.Empty], error)
-	LockWallet(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	IsWalletUnlocked(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error)
-	// Cheque operations
-	CreateCheque(context.Context, *connect.Request[v1.CreateChequeRequest]) (*connect.Response[v1.CreateChequeResponse], error)
-	GetCheque(context.Context, *connect.Request[v1.GetChequeRequest]) (*connect.Response[v1.GetChequeResponse], error)
-	GetChequePrivateKey(context.Context, *connect.Request[v1.GetChequePrivateKeyRequest]) (*connect.Response[v1.GetChequePrivateKeyResponse], error)
-	ListCheques(context.Context, *connect.Request[v1.ListChequesRequest]) (*connect.Response[v1.ListChequesResponse], error)
-	CheckChequeFunding(context.Context, *connect.Request[v1.CheckChequeFundingRequest]) (*connect.Response[v1.CheckChequeFundingResponse], error)
-	PreviewSweep(context.Context, *connect.Request[v1.PreviewSweepRequest]) (*connect.Response[v1.PreviewSweepResponse], error)
-	SweepCheque(context.Context, *connect.Request[v1.SweepChequeRequest]) (*connect.Response[v1.SweepChequeResponse], error)
-	DeleteCheque(context.Context, *connect.Request[v1.DeleteChequeRequest]) (*connect.Response[emptypb.Empty], error)
-	// UTXO Coin Control
-	SetUTXOMetadata(context.Context, *connect.Request[v1.SetUTXOMetadataRequest]) (*connect.Response[emptypb.Empty], error)
-	GetUTXOMetadata(context.Context, *connect.Request[v1.GetUTXOMetadataRequest]) (*connect.Response[v1.GetUTXOMetadataResponse], error)
-	// Coin Selection Preferences
-	SetCoinSelectionStrategy(context.Context, *connect.Request[v1.SetCoinSelectionStrategyRequest]) (*connect.Response[emptypb.Empty], error)
-	GetCoinSelectionStrategy(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetCoinSelectionStrategyResponse], error)
-	// Transaction Details (enriched with input values/addresses)
-	GetTransactionDetails(context.Context, *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error)
-	// UTXO Distribution (for chart visualization)
-	GetUTXODistribution(context.Context, *connect.Request[v1.GetUTXODistributionRequest]) (*connect.Response[v1.GetUTXODistributionResponse], error)
-	// RBF - Replace-By-Fee for unconfirmed transactions
-	BumpFee(context.Context, *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error)
-	// Coin Selection - Select UTXOs for a transaction
-	SelectCoins(context.Context, *connect.Request[v1.SelectCoinsRequest]) (*connect.Response[v1.SelectCoinsResponse], error)
-	// Backup / Restore
-	CreateBackup(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.CreateBackupResponse], error)
-	RestoreBackup(context.Context, *connect.Request[v1.RestoreBackupRequest]) (*connect.Response[emptypb.Empty], error)
-	ValidateBackup(context.Context, *connect.Request[v1.ValidateBackupRequest]) (*connect.Response[v1.ValidateBackupResponse], error)
-}
-
-// NewWalletServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewWalletServiceHandler(svc WalletServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	walletServiceMethods := v1.File_wallet_v1_wallet_proto.Services().ByName("WalletService").Methods()
-	walletServiceSendTransactionHandler := connect.NewUnaryHandler(
-		WalletServiceSendTransactionProcedure,
-		svc.SendTransaction,
-		connect.WithSchema(walletServiceMethods.ByName("SendTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetBalanceHandler := connect.NewUnaryHandler(
-		WalletServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(walletServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		WalletServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(walletServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListTransactionsHandler := connect.NewUnaryHandler(
-		WalletServiceListTransactionsProcedure,
-		svc.ListTransactions,
-		connect.WithSchema(walletServiceMethods.ByName("ListTransactions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListUnspentHandler := connect.NewUnaryHandler(
-		WalletServiceListUnspentProcedure,
-		svc.ListUnspent,
-		connect.WithSchema(walletServiceMethods.ByName("ListUnspent")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListReceiveAddressesHandler := connect.NewUnaryHandler(
-		WalletServiceListReceiveAddressesProcedure,
-		svc.ListReceiveAddresses,
-		connect.WithSchema(walletServiceMethods.ByName("ListReceiveAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListSidechainDepositsHandler := connect.NewUnaryHandler(
-		WalletServiceListSidechainDepositsProcedure,
-		svc.ListSidechainDeposits,
-		connect.WithSchema(walletServiceMethods.ByName("ListSidechainDeposits")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCreateSidechainDepositHandler := connect.NewUnaryHandler(
-		WalletServiceCreateSidechainDepositProcedure,
-		svc.CreateSidechainDeposit,
-		connect.WithSchema(walletServiceMethods.ByName("CreateSidechainDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceSignMessageHandler := connect.NewUnaryHandler(
-		WalletServiceSignMessageProcedure,
-		svc.SignMessage,
-		connect.WithSchema(walletServiceMethods.ByName("SignMessage")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceVerifyMessageHandler := connect.NewUnaryHandler(
-		WalletServiceVerifyMessageProcedure,
-		svc.VerifyMessage,
-		connect.WithSchema(walletServiceMethods.ByName("VerifyMessage")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetStatsHandler := connect.NewUnaryHandler(
-		WalletServiceGetStatsProcedure,
-		svc.GetStats,
-		connect.WithSchema(walletServiceMethods.ByName("GetStats")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceUnlockWalletHandler := connect.NewUnaryHandler(
-		WalletServiceUnlockWalletProcedure,
-		svc.UnlockWallet,
-		connect.WithSchema(walletServiceMethods.ByName("UnlockWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceLockWalletHandler := connect.NewUnaryHandler(
-		WalletServiceLockWalletProcedure,
-		svc.LockWallet,
-		connect.WithSchema(walletServiceMethods.ByName("LockWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceIsWalletUnlockedHandler := connect.NewUnaryHandler(
-		WalletServiceIsWalletUnlockedProcedure,
-		svc.IsWalletUnlocked,
-		connect.WithSchema(walletServiceMethods.ByName("IsWalletUnlocked")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCreateChequeHandler := connect.NewUnaryHandler(
-		WalletServiceCreateChequeProcedure,
-		svc.CreateCheque,
-		connect.WithSchema(walletServiceMethods.ByName("CreateCheque")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetChequeHandler := connect.NewUnaryHandler(
-		WalletServiceGetChequeProcedure,
-		svc.GetCheque,
-		connect.WithSchema(walletServiceMethods.ByName("GetCheque")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetChequePrivateKeyHandler := connect.NewUnaryHandler(
-		WalletServiceGetChequePrivateKeyProcedure,
-		svc.GetChequePrivateKey,
-		connect.WithSchema(walletServiceMethods.ByName("GetChequePrivateKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListChequesHandler := connect.NewUnaryHandler(
-		WalletServiceListChequesProcedure,
-		svc.ListCheques,
-		connect.WithSchema(walletServiceMethods.ByName("ListCheques")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCheckChequeFundingHandler := connect.NewUnaryHandler(
-		WalletServiceCheckChequeFundingProcedure,
-		svc.CheckChequeFunding,
-		connect.WithSchema(walletServiceMethods.ByName("CheckChequeFunding")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServicePreviewSweepHandler := connect.NewUnaryHandler(
-		WalletServicePreviewSweepProcedure,
-		svc.PreviewSweep,
-		connect.WithSchema(walletServiceMethods.ByName("PreviewSweep")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceSweepChequeHandler := connect.NewUnaryHandler(
-		WalletServiceSweepChequeProcedure,
-		svc.SweepCheque,
-		connect.WithSchema(walletServiceMethods.ByName("SweepCheque")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceDeleteChequeHandler := connect.NewUnaryHandler(
-		WalletServiceDeleteChequeProcedure,
-		svc.DeleteCheque,
-		connect.WithSchema(walletServiceMethods.ByName("DeleteCheque")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceSetUTXOMetadataHandler := connect.NewUnaryHandler(
-		WalletServiceSetUTXOMetadataProcedure,
-		svc.SetUTXOMetadata,
-		connect.WithSchema(walletServiceMethods.ByName("SetUTXOMetadata")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetUTXOMetadataHandler := connect.NewUnaryHandler(
-		WalletServiceGetUTXOMetadataProcedure,
-		svc.GetUTXOMetadata,
-		connect.WithSchema(walletServiceMethods.ByName("GetUTXOMetadata")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceSetCoinSelectionStrategyHandler := connect.NewUnaryHandler(
-		WalletServiceSetCoinSelectionStrategyProcedure,
-		svc.SetCoinSelectionStrategy,
-		connect.WithSchema(walletServiceMethods.ByName("SetCoinSelectionStrategy")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetCoinSelectionStrategyHandler := connect.NewUnaryHandler(
-		WalletServiceGetCoinSelectionStrategyProcedure,
-		svc.GetCoinSelectionStrategy,
-		connect.WithSchema(walletServiceMethods.ByName("GetCoinSelectionStrategy")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetTransactionDetailsHandler := connect.NewUnaryHandler(
-		WalletServiceGetTransactionDetailsProcedure,
-		svc.GetTransactionDetails,
-		connect.WithSchema(walletServiceMethods.ByName("GetTransactionDetails")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetUTXODistributionHandler := connect.NewUnaryHandler(
-		WalletServiceGetUTXODistributionProcedure,
-		svc.GetUTXODistribution,
-		connect.WithSchema(walletServiceMethods.ByName("GetUTXODistribution")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceBumpFeeHandler := connect.NewUnaryHandler(
-		WalletServiceBumpFeeProcedure,
-		svc.BumpFee,
-		connect.WithSchema(walletServiceMethods.ByName("BumpFee")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceSelectCoinsHandler := connect.NewUnaryHandler(
-		WalletServiceSelectCoinsProcedure,
-		svc.SelectCoins,
-		connect.WithSchema(walletServiceMethods.ByName("SelectCoins")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCreateBackupHandler := connect.NewUnaryHandler(
-		WalletServiceCreateBackupProcedure,
-		svc.CreateBackup,
-		connect.WithSchema(walletServiceMethods.ByName("CreateBackup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceRestoreBackupHandler := connect.NewUnaryHandler(
-		WalletServiceRestoreBackupProcedure,
-		svc.RestoreBackup,
-		connect.WithSchema(walletServiceMethods.ByName("RestoreBackup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceValidateBackupHandler := connect.NewUnaryHandler(
-		WalletServiceValidateBackupProcedure,
-		svc.ValidateBackup,
-		connect.WithSchema(walletServiceMethods.ByName("ValidateBackup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/wallet.v1.WalletService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case WalletServiceSendTransactionProcedure:
-			walletServiceSendTransactionHandler.ServeHTTP(w, r)
-		case WalletServiceGetBalanceProcedure:
-			walletServiceGetBalanceHandler.ServeHTTP(w, r)
-		case WalletServiceGetNewAddressProcedure:
-			walletServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case WalletServiceListTransactionsProcedure:
-			walletServiceListTransactionsHandler.ServeHTTP(w, r)
-		case WalletServiceListUnspentProcedure:
-			walletServiceListUnspentHandler.ServeHTTP(w, r)
-		case WalletServiceListReceiveAddressesProcedure:
-			walletServiceListReceiveAddressesHandler.ServeHTTP(w, r)
-		case WalletServiceListSidechainDepositsProcedure:
-			walletServiceListSidechainDepositsHandler.ServeHTTP(w, r)
-		case WalletServiceCreateSidechainDepositProcedure:
-			walletServiceCreateSidechainDepositHandler.ServeHTTP(w, r)
-		case WalletServiceSignMessageProcedure:
-			walletServiceSignMessageHandler.ServeHTTP(w, r)
-		case WalletServiceVerifyMessageProcedure:
-			walletServiceVerifyMessageHandler.ServeHTTP(w, r)
-		case WalletServiceGetStatsProcedure:
-			walletServiceGetStatsHandler.ServeHTTP(w, r)
-		case WalletServiceUnlockWalletProcedure:
-			walletServiceUnlockWalletHandler.ServeHTTP(w, r)
-		case WalletServiceLockWalletProcedure:
-			walletServiceLockWalletHandler.ServeHTTP(w, r)
-		case WalletServiceIsWalletUnlockedProcedure:
-			walletServiceIsWalletUnlockedHandler.ServeHTTP(w, r)
-		case WalletServiceCreateChequeProcedure:
-			walletServiceCreateChequeHandler.ServeHTTP(w, r)
-		case WalletServiceGetChequeProcedure:
-			walletServiceGetChequeHandler.ServeHTTP(w, r)
-		case WalletServiceGetChequePrivateKeyProcedure:
-			walletServiceGetChequePrivateKeyHandler.ServeHTTP(w, r)
-		case WalletServiceListChequesProcedure:
-			walletServiceListChequesHandler.ServeHTTP(w, r)
-		case WalletServiceCheckChequeFundingProcedure:
-			walletServiceCheckChequeFundingHandler.ServeHTTP(w, r)
-		case WalletServicePreviewSweepProcedure:
-			walletServicePreviewSweepHandler.ServeHTTP(w, r)
-		case WalletServiceSweepChequeProcedure:
-			walletServiceSweepChequeHandler.ServeHTTP(w, r)
-		case WalletServiceDeleteChequeProcedure:
-			walletServiceDeleteChequeHandler.ServeHTTP(w, r)
-		case WalletServiceSetUTXOMetadataProcedure:
-			walletServiceSetUTXOMetadataHandler.ServeHTTP(w, r)
-		case WalletServiceGetUTXOMetadataProcedure:
-			walletServiceGetUTXOMetadataHandler.ServeHTTP(w, r)
-		case WalletServiceSetCoinSelectionStrategyProcedure:
-			walletServiceSetCoinSelectionStrategyHandler.ServeHTTP(w, r)
-		case WalletServiceGetCoinSelectionStrategyProcedure:
-			walletServiceGetCoinSelectionStrategyHandler.ServeHTTP(w, r)
-		case WalletServiceGetTransactionDetailsProcedure:
-			walletServiceGetTransactionDetailsHandler.ServeHTTP(w, r)
-		case WalletServiceGetUTXODistributionProcedure:
-			walletServiceGetUTXODistributionHandler.ServeHTTP(w, r)
-		case WalletServiceBumpFeeProcedure:
-			walletServiceBumpFeeHandler.ServeHTTP(w, r)
-		case WalletServiceSelectCoinsProcedure:
-			walletServiceSelectCoinsHandler.ServeHTTP(w, r)
-		case WalletServiceCreateBackupProcedure:
-			walletServiceCreateBackupHandler.ServeHTTP(w, r)
-		case WalletServiceRestoreBackupProcedure:
-			walletServiceRestoreBackupHandler.ServeHTTP(w, r)
-		case WalletServiceValidateBackupProcedure:
-			walletServiceValidateBackupHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedWalletServiceHandler) ValidateBackup(context.Context, *v1.ValidateBackupRequest) (*v1.ValidateBackupResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "wallet.v1.WalletService.ValidateBackup is not implemented")
 }
 
-// UnimplementedWalletServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedWalletServiceHandler struct{}
+type walletServiceClient struct {
+	client *connect.Client
+}
+
+func (c *walletServiceClient) SendTransaction(ctx context.Context, req *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error) {
+	var res v1.SendTransactionResponse
+	if err := c.client.CallUnary(ctx, walletServiceSendTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) ListTransactions(ctx context.Context, req *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	var res v1.ListTransactionsResponse
+	if err := c.client.CallUnary(ctx, walletServiceListTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) ListUnspent(ctx context.Context, req *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error) {
+	var res v1.ListUnspentResponse
+	if err := c.client.CallUnary(ctx, walletServiceListUnspentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) ListReceiveAddresses(ctx context.Context, req *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error) {
+	var res v1.ListReceiveAddressesResponse
+	if err := c.client.CallUnary(ctx, walletServiceListReceiveAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedWalletServiceHandler) SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.SendTransaction is not implemented"))
+func (c *walletServiceClient) ListSidechainDeposits(ctx context.Context, req *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error) {
+	var res v1.ListSidechainDepositsResponse
+	if err := c.client.CallUnary(ctx, walletServiceListSidechainDepositsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CreateSidechainDeposit(ctx context.Context, req *v1.CreateSidechainDepositRequest) (*v1.CreateSidechainDepositResponse, error) {
+	var res v1.CreateSidechainDepositResponse
+	if err := c.client.CallUnary(ctx, walletServiceCreateSidechainDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) SignMessage(ctx context.Context, req *v1.SignMessageRequest) (*v1.SignMessageResponse, error) {
+	var res v1.SignMessageResponse
+	if err := c.client.CallUnary(ctx, walletServiceSignMessageSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) VerifyMessage(ctx context.Context, req *v1.VerifyMessageRequest) (*v1.VerifyMessageResponse, error) {
+	var res v1.VerifyMessageResponse
+	if err := c.client.CallUnary(ctx, walletServiceVerifyMessageSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetStats(ctx context.Context, req *v1.GetStatsRequest) (*v1.GetStatsResponse, error) {
+	var res v1.GetStatsResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetStatsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) UnlockWallet(ctx context.Context, req *v1.UnlockWalletRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletServiceUnlockWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) LockWallet(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletServiceLockWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) IsWalletUnlocked(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletServiceIsWalletUnlockedSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CreateCheque(ctx context.Context, req *v1.CreateChequeRequest) (*v1.CreateChequeResponse, error) {
+	var res v1.CreateChequeResponse
+	if err := c.client.CallUnary(ctx, walletServiceCreateChequeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetCheque(ctx context.Context, req *v1.GetChequeRequest) (*v1.GetChequeResponse, error) {
+	var res v1.GetChequeResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetChequeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetChequePrivateKey(ctx context.Context, req *v1.GetChequePrivateKeyRequest) (*v1.GetChequePrivateKeyResponse, error) {
+	var res v1.GetChequePrivateKeyResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetChequePrivateKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) ListCheques(ctx context.Context, req *v1.ListChequesRequest) (*v1.ListChequesResponse, error) {
+	var res v1.ListChequesResponse
+	if err := c.client.CallUnary(ctx, walletServiceListChequesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CheckChequeFunding(ctx context.Context, req *v1.CheckChequeFundingRequest) (*v1.CheckChequeFundingResponse, error) {
+	var res v1.CheckChequeFundingResponse
+	if err := c.client.CallUnary(ctx, walletServiceCheckChequeFundingSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) PreviewSweep(ctx context.Context, req *v1.PreviewSweepRequest) (*v1.PreviewSweepResponse, error) {
+	var res v1.PreviewSweepResponse
+	if err := c.client.CallUnary(ctx, walletServicePreviewSweepSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) SweepCheque(ctx context.Context, req *v1.SweepChequeRequest) (*v1.SweepChequeResponse, error) {
+	var res v1.SweepChequeResponse
+	if err := c.client.CallUnary(ctx, walletServiceSweepChequeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) DeleteCheque(ctx context.Context, req *v1.DeleteChequeRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletServiceDeleteChequeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) SetUTXOMetadata(ctx context.Context, req *v1.SetUTXOMetadataRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletServiceSetUTXOMetadataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetUTXOMetadata(ctx context.Context, req *v1.GetUTXOMetadataRequest) (*v1.GetUTXOMetadataResponse, error) {
+	var res v1.GetUTXOMetadataResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetUTXOMetadataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) SetCoinSelectionStrategy(ctx context.Context, req *v1.SetCoinSelectionStrategyRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletServiceSetCoinSelectionStrategySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetCoinSelectionStrategy(ctx context.Context, req *emptypb.Empty) (*v1.GetCoinSelectionStrategyResponse, error) {
+	var res v1.GetCoinSelectionStrategyResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetCoinSelectionStrategySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetTransactionDetails(ctx context.Context, req *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error) {
+	var res v1.GetTransactionDetailsResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetTransactionDetailsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetUTXODistribution(ctx context.Context, req *v1.GetUTXODistributionRequest) (*v1.GetUTXODistributionResponse, error) {
+	var res v1.GetUTXODistributionResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetUTXODistributionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) BumpFee(ctx context.Context, req *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error) {
+	var res v1.BumpFeeResponse
+	if err := c.client.CallUnary(ctx, walletServiceBumpFeeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) SelectCoins(ctx context.Context, req *v1.SelectCoinsRequest) (*v1.SelectCoinsResponse, error) {
+	var res v1.SelectCoinsResponse
+	if err := c.client.CallUnary(ctx, walletServiceSelectCoinsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CreateBackup(ctx context.Context, req *emptypb.Empty) (*v1.CreateBackupResponse, error) {
+	var res v1.CreateBackupResponse
+	if err := c.client.CallUnary(ctx, walletServiceCreateBackupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) RestoreBackup(ctx context.Context, req *v1.RestoreBackupRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletServiceRestoreBackupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetBalance is not implemented"))
+func (c *walletServiceClient) ValidateBackup(ctx context.Context, req *v1.ValidateBackupRequest) (*v1.ValidateBackupResponse, error) {
+	var res v1.ValidateBackupResponse
+	if err := c.client.CallUnary(ctx, walletServiceValidateBackupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetNewAddress is not implemented"))
+type walletServiceHandler struct{ svc WalletServiceHandler }
+
+func (h walletServiceHandler) sendTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SendTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SendTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.ListTransactions is not implemented"))
+func (h walletServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListUnspent(context.Context, *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.ListUnspent is not implemented"))
+func (h walletServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListReceiveAddresses(context.Context, *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.ListReceiveAddresses is not implemented"))
+func (h walletServiceHandler) listTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListSidechainDeposits(context.Context, *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.ListSidechainDeposits is not implemented"))
+func (h walletServiceHandler) listUnspent(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUnspentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUnspent(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) CreateSidechainDeposit(context.Context, *connect.Request[v1.CreateSidechainDepositRequest]) (*connect.Response[v1.CreateSidechainDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.CreateSidechainDeposit is not implemented"))
+func (h walletServiceHandler) listReceiveAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListReceiveAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListReceiveAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) SignMessage(context.Context, *connect.Request[v1.SignMessageRequest]) (*connect.Response[v1.SignMessageResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.SignMessage is not implemented"))
+func (h walletServiceHandler) listSidechainDeposits(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSidechainDepositsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSidechainDeposits(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) VerifyMessage(context.Context, *connect.Request[v1.VerifyMessageRequest]) (*connect.Response[v1.VerifyMessageResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.VerifyMessage is not implemented"))
+func (h walletServiceHandler) createSidechainDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateSidechainDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateSidechainDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletServiceHandler) signMessage(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignMessageRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignMessage(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletServiceHandler) verifyMessage(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VerifyMessageRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VerifyMessage(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetStats(context.Context, *connect.Request[v1.GetStatsRequest]) (*connect.Response[v1.GetStatsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetStats is not implemented"))
+func (h walletServiceHandler) getStats(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetStatsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetStats(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.UnlockWallet is not implemented"))
+func (h walletServiceHandler) unlockWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UnlockWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UnlockWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) LockWallet(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.LockWallet is not implemented"))
+func (h walletServiceHandler) lockWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.LockWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) IsWalletUnlocked(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.IsWalletUnlocked is not implemented"))
+func (h walletServiceHandler) isWalletUnlocked(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.IsWalletUnlocked(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) CreateCheque(context.Context, *connect.Request[v1.CreateChequeRequest]) (*connect.Response[v1.CreateChequeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.CreateCheque is not implemented"))
+func (h walletServiceHandler) createCheque(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateChequeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateCheque(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetCheque(context.Context, *connect.Request[v1.GetChequeRequest]) (*connect.Response[v1.GetChequeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetCheque is not implemented"))
+func (h walletServiceHandler) getCheque(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetChequeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCheque(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetChequePrivateKey(context.Context, *connect.Request[v1.GetChequePrivateKeyRequest]) (*connect.Response[v1.GetChequePrivateKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetChequePrivateKey is not implemented"))
+func (h walletServiceHandler) getChequePrivateKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetChequePrivateKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetChequePrivateKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListCheques(context.Context, *connect.Request[v1.ListChequesRequest]) (*connect.Response[v1.ListChequesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.ListCheques is not implemented"))
+func (h walletServiceHandler) listCheques(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListChequesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListCheques(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) CheckChequeFunding(context.Context, *connect.Request[v1.CheckChequeFundingRequest]) (*connect.Response[v1.CheckChequeFundingResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.CheckChequeFunding is not implemented"))
+func (h walletServiceHandler) checkChequeFunding(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CheckChequeFundingRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CheckChequeFunding(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) PreviewSweep(context.Context, *connect.Request[v1.PreviewSweepRequest]) (*connect.Response[v1.PreviewSweepResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.PreviewSweep is not implemented"))
+func (h walletServiceHandler) previewSweep(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PreviewSweepRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PreviewSweep(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) SweepCheque(context.Context, *connect.Request[v1.SweepChequeRequest]) (*connect.Response[v1.SweepChequeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.SweepCheque is not implemented"))
+func (h walletServiceHandler) sweepCheque(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SweepChequeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SweepCheque(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) DeleteCheque(context.Context, *connect.Request[v1.DeleteChequeRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.DeleteCheque is not implemented"))
+func (h walletServiceHandler) deleteCheque(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteChequeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeleteCheque(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) SetUTXOMetadata(context.Context, *connect.Request[v1.SetUTXOMetadataRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.SetUTXOMetadata is not implemented"))
+func (h walletServiceHandler) setUTXOMetadata(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetUTXOMetadataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetUTXOMetadata(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetUTXOMetadata(context.Context, *connect.Request[v1.GetUTXOMetadataRequest]) (*connect.Response[v1.GetUTXOMetadataResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetUTXOMetadata is not implemented"))
+func (h walletServiceHandler) getUTXOMetadata(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetUTXOMetadataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetUTXOMetadata(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) SetCoinSelectionStrategy(context.Context, *connect.Request[v1.SetCoinSelectionStrategyRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.SetCoinSelectionStrategy is not implemented"))
+func (h walletServiceHandler) setCoinSelectionStrategy(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetCoinSelectionStrategyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetCoinSelectionStrategy(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetCoinSelectionStrategy(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.GetCoinSelectionStrategyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetCoinSelectionStrategy is not implemented"))
+func (h walletServiceHandler) getCoinSelectionStrategy(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCoinSelectionStrategy(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetTransactionDetails(context.Context, *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetTransactionDetails is not implemented"))
+func (h walletServiceHandler) getTransactionDetails(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransactionDetailsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransactionDetails(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetUTXODistribution(context.Context, *connect.Request[v1.GetUTXODistributionRequest]) (*connect.Response[v1.GetUTXODistributionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.GetUTXODistribution is not implemented"))
+func (h walletServiceHandler) getUTXODistribution(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetUTXODistributionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetUTXODistribution(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) BumpFee(context.Context, *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.BumpFee is not implemented"))
+func (h walletServiceHandler) bumpFee(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BumpFeeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BumpFee(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) SelectCoins(context.Context, *connect.Request[v1.SelectCoinsRequest]) (*connect.Response[v1.SelectCoinsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.SelectCoins is not implemented"))
+func (h walletServiceHandler) selectCoins(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SelectCoinsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SelectCoins(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) CreateBackup(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.CreateBackupResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.CreateBackup is not implemented"))
+func (h walletServiceHandler) createBackup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateBackup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) RestoreBackup(context.Context, *connect.Request[v1.RestoreBackupRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.RestoreBackup is not implemented"))
+func (h walletServiceHandler) restoreBackup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RestoreBackupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RestoreBackup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ValidateBackup(context.Context, *connect.Request[v1.ValidateBackupRequest]) (*connect.Response[v1.ValidateBackupResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("wallet.v1.WalletService.ValidateBackup is not implemented"))
+func (h walletServiceHandler) validateBackup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ValidateBackupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ValidateBackup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/gen/walletpsbt/v1/walletpsbtv1connect/walletpsbt.connect.go b/bitwindow/server/gen/walletpsbt/v1/walletpsbtv1connect/walletpsbt.connect.go
index b31c58d16a..eaba8fb897 100644
--- a/bitwindow/server/gen/walletpsbt/v1/walletpsbtv1connect/walletpsbt.connect.go
+++ b/bitwindow/server/gen/walletpsbt/v1/walletpsbtv1connect/walletpsbt.connect.go
@@ -5,164 +5,169 @@
 package walletpsbtv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/bitwindow/server/gen/walletpsbt/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// WalletPsbtServiceName is the fully-qualified name of the WalletPsbtService service.
 	WalletPsbtServiceName = "walletpsbt.v1.WalletPsbtService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// WalletPsbtServiceListDraftsProcedure is the fully-qualified name of the WalletPsbtService's
-	// ListDrafts RPC.
+	// WalletPsbtServiceListDraftsProcedure is the procedure name of the WalletPsbtService's ListDrafts
+	// RPC.
 	WalletPsbtServiceListDraftsProcedure = "/walletpsbt.v1.WalletPsbtService/ListDrafts"
-	// WalletPsbtServiceSaveDraftProcedure is the fully-qualified name of the WalletPsbtService's
-	// SaveDraft RPC.
+	// WalletPsbtServiceSaveDraftProcedure is the procedure name of the WalletPsbtService's SaveDraft
+	// RPC.
 	WalletPsbtServiceSaveDraftProcedure = "/walletpsbt.v1.WalletPsbtService/SaveDraft"
-	// WalletPsbtServiceDeleteDraftProcedure is the fully-qualified name of the WalletPsbtService's
+	// WalletPsbtServiceDeleteDraftProcedure is the procedure name of the WalletPsbtService's
 	// DeleteDraft RPC.
 	WalletPsbtServiceDeleteDraftProcedure = "/walletpsbt.v1.WalletPsbtService/DeleteDraft"
 )
 
+var (
+	walletPsbtServiceListDraftsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletpsbt_v1_walletpsbt_proto.Services().ByName("WalletPsbtService").Methods().ByName("ListDrafts"),
+			Procedure:  WalletPsbtServiceListDraftsProcedure,
+		}
+	})
+	walletPsbtServiceSaveDraftSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletpsbt_v1_walletpsbt_proto.Services().ByName("WalletPsbtService").Methods().ByName("SaveDraft"),
+			Procedure:  WalletPsbtServiceSaveDraftProcedure,
+		}
+	})
+	walletPsbtServiceDeleteDraftSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletpsbt_v1_walletpsbt_proto.Services().ByName("WalletPsbtService").Methods().ByName("DeleteDraft"),
+			Procedure:  WalletPsbtServiceDeleteDraftProcedure,
+		}
+	})
+)
+
 // WalletPsbtServiceClient is a client for the walletpsbt.v1.WalletPsbtService service.
 type WalletPsbtServiceClient interface {
-	ListDrafts(context.Context, *connect.Request[v1.ListDraftsRequest]) (*connect.Response[v1.ListDraftsResponse], error)
-	SaveDraft(context.Context, *connect.Request[v1.SaveDraftRequest]) (*connect.Response[v1.SaveDraftResponse], error)
-	DeleteDraft(context.Context, *connect.Request[v1.DeleteDraftRequest]) (*connect.Response[emptypb.Empty], error)
+	ListDrafts(context.Context, *v1.ListDraftsRequest) (*v1.ListDraftsResponse, error)
+	SaveDraft(context.Context, *v1.SaveDraftRequest) (*v1.SaveDraftResponse, error)
+	DeleteDraft(context.Context, *v1.DeleteDraftRequest) (*emptypb.Empty, error)
 }
 
 // NewWalletPsbtServiceClient constructs a client for the walletpsbt.v1.WalletPsbtService service.
-// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped
-// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewWalletPsbtServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) WalletPsbtServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	walletPsbtServiceMethods := v1.File_walletpsbt_v1_walletpsbt_proto.Services().ByName("WalletPsbtService").Methods()
-	return &walletPsbtServiceClient{
-		listDrafts: connect.NewClient[v1.ListDraftsRequest, v1.ListDraftsResponse](
-			httpClient,
-			baseURL+WalletPsbtServiceListDraftsProcedure,
-			connect.WithSchema(walletPsbtServiceMethods.ByName("ListDrafts")),
-			connect.WithClientOptions(opts...),
-		),
-		saveDraft: connect.NewClient[v1.SaveDraftRequest, v1.SaveDraftResponse](
-			httpClient,
-			baseURL+WalletPsbtServiceSaveDraftProcedure,
-			connect.WithSchema(walletPsbtServiceMethods.ByName("SaveDraft")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteDraft: connect.NewClient[v1.DeleteDraftRequest, emptypb.Empty](
-			httpClient,
-			baseURL+WalletPsbtServiceDeleteDraftProcedure,
-			connect.WithSchema(walletPsbtServiceMethods.ByName("DeleteDraft")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// Multiple service clients may share a single connect.Client.
+func NewWalletPsbtServiceClient(client *connect.Client) WalletPsbtServiceClient {
+	return &walletPsbtServiceClient{client: client}
 }
 
-// walletPsbtServiceClient implements WalletPsbtServiceClient.
-type walletPsbtServiceClient struct {
-	listDrafts  *connect.Client[v1.ListDraftsRequest, v1.ListDraftsResponse]
-	saveDraft   *connect.Client[v1.SaveDraftRequest, v1.SaveDraftResponse]
-	deleteDraft *connect.Client[v1.DeleteDraftRequest, emptypb.Empty]
+// WalletPsbtServiceHandler is an implementation of the walletpsbt.v1.WalletPsbtService service.
+type WalletPsbtServiceHandler interface {
+	ListDrafts(context.Context, *v1.ListDraftsRequest) (*v1.ListDraftsResponse, error)
+	SaveDraft(context.Context, *v1.SaveDraftRequest) (*v1.SaveDraftResponse, error)
+	DeleteDraft(context.Context, *v1.DeleteDraftRequest) (*emptypb.Empty, error)
 }
 
-// ListDrafts calls walletpsbt.v1.WalletPsbtService.ListDrafts.
-func (c *walletPsbtServiceClient) ListDrafts(ctx context.Context, req *connect.Request[v1.ListDraftsRequest]) (*connect.Response[v1.ListDraftsResponse], error) {
-	return c.listDrafts.CallUnary(ctx, req)
+// RegisterWalletPsbtServiceHandler registers svc as the walletpsbt.v1.WalletPsbtService
+// implementation on server.
+func RegisterWalletPsbtServiceHandler(server *connect.Server, svc WalletPsbtServiceHandler) {
+	adapter := walletPsbtServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: walletPsbtServiceListDraftsSpec(), Handler: adapter.listDrafts},
+		connect.Method{Spec: walletPsbtServiceSaveDraftSpec(), Handler: adapter.saveDraft},
+		connect.Method{Spec: walletPsbtServiceDeleteDraftSpec(), Handler: adapter.deleteDraft},
+	)
 }
 
-// SaveDraft calls walletpsbt.v1.WalletPsbtService.SaveDraft.
-func (c *walletPsbtServiceClient) SaveDraft(ctx context.Context, req *connect.Request[v1.SaveDraftRequest]) (*connect.Response[v1.SaveDraftResponse], error) {
-	return c.saveDraft.CallUnary(ctx, req)
+// UnimplementedWalletPsbtServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedWalletPsbtServiceHandler struct{}
+
+func (UnimplementedWalletPsbtServiceHandler) ListDrafts(context.Context, *v1.ListDraftsRequest) (*v1.ListDraftsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletpsbt.v1.WalletPsbtService.ListDrafts is not implemented")
 }
 
-// DeleteDraft calls walletpsbt.v1.WalletPsbtService.DeleteDraft.
-func (c *walletPsbtServiceClient) DeleteDraft(ctx context.Context, req *connect.Request[v1.DeleteDraftRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.deleteDraft.CallUnary(ctx, req)
+func (UnimplementedWalletPsbtServiceHandler) SaveDraft(context.Context, *v1.SaveDraftRequest) (*v1.SaveDraftResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletpsbt.v1.WalletPsbtService.SaveDraft is not implemented")
 }
 
-// WalletPsbtServiceHandler is an implementation of the walletpsbt.v1.WalletPsbtService service.
-type WalletPsbtServiceHandler interface {
-	ListDrafts(context.Context, *connect.Request[v1.ListDraftsRequest]) (*connect.Response[v1.ListDraftsResponse], error)
-	SaveDraft(context.Context, *connect.Request[v1.SaveDraftRequest]) (*connect.Response[v1.SaveDraftResponse], error)
-	DeleteDraft(context.Context, *connect.Request[v1.DeleteDraftRequest]) (*connect.Response[emptypb.Empty], error)
+func (UnimplementedWalletPsbtServiceHandler) DeleteDraft(context.Context, *v1.DeleteDraftRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletpsbt.v1.WalletPsbtService.DeleteDraft is not implemented")
 }
 
-// NewWalletPsbtServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewWalletPsbtServiceHandler(svc WalletPsbtServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	walletPsbtServiceMethods := v1.File_walletpsbt_v1_walletpsbt_proto.Services().ByName("WalletPsbtService").Methods()
-	walletPsbtServiceListDraftsHandler := connect.NewUnaryHandler(
-		WalletPsbtServiceListDraftsProcedure,
-		svc.ListDrafts,
-		connect.WithSchema(walletPsbtServiceMethods.ByName("ListDrafts")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletPsbtServiceSaveDraftHandler := connect.NewUnaryHandler(
-		WalletPsbtServiceSaveDraftProcedure,
-		svc.SaveDraft,
-		connect.WithSchema(walletPsbtServiceMethods.ByName("SaveDraft")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletPsbtServiceDeleteDraftHandler := connect.NewUnaryHandler(
-		WalletPsbtServiceDeleteDraftProcedure,
-		svc.DeleteDraft,
-		connect.WithSchema(walletPsbtServiceMethods.ByName("DeleteDraft")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/walletpsbt.v1.WalletPsbtService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case WalletPsbtServiceListDraftsProcedure:
-			walletPsbtServiceListDraftsHandler.ServeHTTP(w, r)
-		case WalletPsbtServiceSaveDraftProcedure:
-			walletPsbtServiceSaveDraftHandler.ServeHTTP(w, r)
-		case WalletPsbtServiceDeleteDraftProcedure:
-			walletPsbtServiceDeleteDraftHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type walletPsbtServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedWalletPsbtServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedWalletPsbtServiceHandler struct{}
+func (c *walletPsbtServiceClient) ListDrafts(ctx context.Context, req *v1.ListDraftsRequest) (*v1.ListDraftsResponse, error) {
+	var res v1.ListDraftsResponse
+	if err := c.client.CallUnary(ctx, walletPsbtServiceListDraftsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletPsbtServiceClient) SaveDraft(ctx context.Context, req *v1.SaveDraftRequest) (*v1.SaveDraftResponse, error) {
+	var res v1.SaveDraftResponse
+	if err := c.client.CallUnary(ctx, walletPsbtServiceSaveDraftSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedWalletPsbtServiceHandler) ListDrafts(context.Context, *connect.Request[v1.ListDraftsRequest]) (*connect.Response[v1.ListDraftsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletpsbt.v1.WalletPsbtService.ListDrafts is not implemented"))
+func (c *walletPsbtServiceClient) DeleteDraft(ctx context.Context, req *v1.DeleteDraftRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletPsbtServiceDeleteDraftSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletPsbtServiceHandler) SaveDraft(context.Context, *connect.Request[v1.SaveDraftRequest]) (*connect.Response[v1.SaveDraftResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletpsbt.v1.WalletPsbtService.SaveDraft is not implemented"))
+type walletPsbtServiceHandler struct{ svc WalletPsbtServiceHandler }
+
+func (h walletPsbtServiceHandler) listDrafts(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListDraftsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListDrafts(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletPsbtServiceHandler) DeleteDraft(context.Context, *connect.Request[v1.DeleteDraftRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletpsbt.v1.WalletPsbtService.DeleteDraft is not implemented"))
+func (h walletPsbtServiceHandler) saveDraft(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SaveDraftRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SaveDraft(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletPsbtServiceHandler) deleteDraft(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteDraftRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeleteDraft(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/bitwindow/server/go.mod b/bitwindow/server/go.mod
index 3dfe2a06db..bb3a2d491f 100644
--- a/bitwindow/server/go.mod
+++ b/bitwindow/server/go.mod
@@ -6,6 +6,7 @@ require (
 	buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.12-20260825204119-511051f7f437.1
 	buf.build/go/protovalidate v1.4.0
 	connectrpc.com/connect v1.21.0
+	connectrpc.com/connect/v2 v2.0.1
 	connectrpc.com/grpcreflect v1.3.1
 	github.com/LayerTwo-Labs/sidesail/coinnews/codec v0.0.0
 	github.com/LayerTwo-Labs/sidesail/coinnews/server v0.0.0
diff --git a/bitwindow/server/go.sum b/bitwindow/server/go.sum
index 8065452b90..4f6eb524d4 100644
--- a/bitwindow/server/go.sum
+++ b/bitwindow/server/go.sum
@@ -8,6 +8,8 @@ cel.dev/expr v0.25.3 h1:A2jO8jwOugrrovveCWfj0KEZOfqiLgAcwjpHPhzIGw0=
 cel.dev/expr v0.25.3/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4=
 connectrpc.com/connect v1.21.0 h1:LhqSJt7jHf5NJBo9Jq/t/9FjcYAideif0mg+qe2jCUs=
 connectrpc.com/connect v1.21.0/go.mod h1:A2ygJrukXwWy32vkCAAHNVguZrqZ+jeZ9rGRnGR4dN4=
+connectrpc.com/connect/v2 v2.0.1 h1:WTAycxe87UqxSM5oxS30d1dalZ+C5xz8Ec8O6zVYkHQ=
+connectrpc.com/connect/v2 v2.0.1/go.mod h1:N32OLrstcPUzkykFynnefFro3+xzSdOrZlK2jHmS/xo=
 connectrpc.com/grpchealth v1.5.0 h1:nHEVTwz9WYKxW2JTYUFD337q76oAZMvot9jX0WjVCQo=
 connectrpc.com/grpchealth v1.5.0/go.mod h1:fC9WGwKmDruKCNh8wj2rThiaxxoiXxvsCVIu2Ex2voA=
 connectrpc.com/grpcreflect v1.3.1 h1:iU8385WX2RYriTwOIN8mf2qKl0qTxgY9yRPXTVhr+ao=
@@ -102,10 +104,10 @@ github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9yS
 github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.1.5-0.20170601210322-f6abca593680/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
-github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
+github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/tidwall/gjson v1.19.0 h1:xwxm7n691Uf3u5OFjzngavjGTh55KX5q/9w9xHW88JU=
@@ -129,8 +131,6 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
 golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
-golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
-golang.org/x/exp v0.0.0-20260112195511-716be5621a96/go.mod h1:nzimsREAkjBCIEFtHiYkrJyT+2uy9YZJB7H1k68CXZU=
 golang.org/x/exp v0.0.0-20260820142414-ca536658362e h1:01Ju2A/fZKkci4zqx0eZxw//DnRYOnBiGJG14hFBhO8=
 golang.org/x/exp v0.0.0-20260820142414-ca536658362e/go.mod h1:zeBbvyFKDaLwa7CH/zI8KXt7gTl14SF7sO08Pl5jBCM=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -140,9 +140,9 @@ golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
 golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
 golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
 golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
diff --git a/bitwindow/server/integrationtest/backend_runtime_smoke_test.go b/bitwindow/server/integrationtest/backend_runtime_smoke_test.go
index edb590f5b3..0c37851eda 100644
--- a/bitwindow/server/integrationtest/backend_runtime_smoke_test.go
+++ b/bitwindow/server/integrationtest/backend_runtime_smoke_test.go
@@ -21,7 +21,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -46,10 +47,10 @@ func TestBackendRuntimeOwnershipSmoke(t *testing.T) {
 
 	node := newOrchestratorOnlyNode(t)
 
-	_, err := node.WalletClient.GenerateWallet(ctx, connect.NewRequest(&walletpb.GenerateWalletRequest{
+	_, err := node.WalletClient.GenerateWallet(ctx, &walletpb.GenerateWalletRequest{
 		Name:           "backend-runtime-enforcer",
 		CustomMnemonic: testEnforcerMnemonic,
-	}))
+	})
 	require.NoError(t, err)
 
 	bitwindowdBin := buildBitwindowd(t, t.TempDir())
@@ -60,30 +61,32 @@ func TestBackendRuntimeOwnershipSmoke(t *testing.T) {
 	proc := startBitwindowd(t, bitwindowdBin, node, apiHost, logDir)
 	defer stopCmdProcess(t, proc)
 
-	authIC := localauth.Interceptor(node.BitwindowDir)
-	healthClient := healthv1connect.NewHealthServiceClient(
+	authIC := localauth.ClientInterceptor(node.BitwindowDir)
+	healthClient := healthv1connect.NewHealthServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		bitwindowdURL,
-		connect.WithInterceptors(authIC),
-	)
-	orchClient := orchrpc.NewOrchestratorServiceClient(
+		connecthttp.WithReadMaxBytes(0),
+	), authIC,
+	))
+	orchClient := orchrpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		fmt.Sprintf("http://127.0.0.1:%d", node.OrchdGRPCPort),
-		connect.WithGRPC(),
-		connect.WithInterceptors(authIC),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), authIC,
+	))
 
 	waitForBitwindowdHealth(t, ctx, healthClient)
 	waitForBinaryReady(t, ctx, orchClient, "bitcoind")
 	waitForEnforcerBlockchainInfo(t, ctx, orchClient)
 
-	mainchainInfo, err := orchClient.GetMainchainBlockchainInfo(ctx, connect.NewRequest(&orchpb.GetMainchainBlockchainInfoRequest{}))
+	mainchainInfo, err := orchClient.GetMainchainBlockchainInfo(ctx, &orchpb.GetMainchainBlockchainInfoRequest{})
 	require.NoError(t, err)
-	require.Equal(t, "regtest", mainchainInfo.Msg.GetChain())
+	require.Equal(t, "regtest", mainchainInfo.GetChain())
 
-	statusResp, err := healthClient.Check(ctx, connect.NewRequest(&emptypb.Empty{}))
+	statusResp, err := healthClient.Check(ctx, &emptypb.Empty{})
 	require.NoError(t, err)
-	require.Equal(t, healthv1.CheckResponse_STATUS_SERVING, serviceStatus(statusResp.Msg, "bitcoind"))
+	require.Equal(t, healthv1.CheckResponse_STATUS_SERVING, serviceStatus(statusResp, "bitcoind"))
 }
 
 func buildBitwindowd(t *testing.T, outDir string) string {
@@ -263,12 +266,13 @@ port=%d
 		BitcoindP2PPort:  p2pPort,
 		OrchdGRPCPort:    grpcPort,
 		EnforcerGRPCPort: basePort + 212,
-		WalletClient: walletrpc.NewWalletManagerServiceClient(
+		WalletClient: walletrpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(
 			http.DefaultClient,
 			fmt.Sprintf("http://127.0.0.1:%d", grpcPort),
-			connect.WithGRPC(),
-			connect.WithInterceptors(localauth.Interceptor(bitwindowDir)),
-		),
+			connecthttp.WithReadMaxBytes(0),
+			connecthttp.WithGRPC(),
+		), localauth.ClientInterceptor(bitwindowDir),
+		)),
 	}
 
 	return node
@@ -449,9 +453,9 @@ func waitForBitwindowdHealth(t *testing.T, ctx context.Context, client healthv1c
 	var lastErr error
 	deadline := time.Now().Add(90 * time.Second)
 	for time.Now().Before(deadline) {
-		resp, err := client.Check(ctx, connect.NewRequest(&emptypb.Empty{}))
+		resp, err := client.Check(ctx, &emptypb.Empty{})
 		if err == nil {
-			require.NotNil(t, resp.Msg)
+			require.NotNil(t, resp)
 			return
 		}
 		lastErr = err
@@ -471,9 +475,9 @@ func waitForBinaryReady(t *testing.T, ctx context.Context, client orchrpc.Orches
 
 	deadline := time.Now().Add(2 * time.Minute)
 	for time.Now().Before(deadline) {
-		resp, err := client.GetBinaryStatus(ctx, connect.NewRequest(&orchpb.GetBinaryStatusRequest{Name: name}))
+		resp, err := client.GetBinaryStatus(ctx, &orchpb.GetBinaryStatusRequest{Name: name})
 		if err == nil {
-			lastStatus = resp.Msg.GetStatus()
+			lastStatus = resp.GetStatus()
 			if lastStatus.GetRunning() && lastStatus.GetConnected() && lastStatus.GetHealthy() {
 				return lastStatus
 			}
@@ -499,9 +503,9 @@ func waitForEnforcerBlockchainInfo(t *testing.T, ctx context.Context, client orc
 	var lastErr error
 	deadline := time.Now().Add(2 * time.Minute)
 	for time.Now().Before(deadline) {
-		resp, err := client.GetEnforcerBlockchainInfo(ctx, connect.NewRequest(&orchpb.GetEnforcerBlockchainInfoRequest{}))
+		resp, err := client.GetEnforcerBlockchainInfo(ctx, &orchpb.GetEnforcerBlockchainInfoRequest{})
 		if err == nil {
-			require.NotNil(t, resp.Msg)
+			require.NotNil(t, resp)
 			return
 		}
 		lastErr = err
diff --git a/bitwindow/server/integrationtest/wallet_test.go b/bitwindow/server/integrationtest/wallet_test.go
index c4403d6e5f..6f78029f20 100644
--- a/bitwindow/server/integrationtest/wallet_test.go
+++ b/bitwindow/server/integrationtest/wallet_test.go
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/require"
 	"github.com/tyler-smith/go-bip32"
 
@@ -64,53 +63,53 @@ func TestBitwindowWalletIntegration(t *testing.T) {
 		client := nodeA.WalletClient
 
 		// The first wallet carries the starter material. It stays unfunded.
-		_, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		_, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "bw-primary",
-		}))
+		})
 		require.NoError(t, err)
 
 		// GenerateWallet (bitcoinCore).
-		genResp, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		genResp, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "bw-core",
-		}))
+		})
 		require.NoError(t, err)
-		coreID := genResp.Msg.WalletId
+		coreID := genResp.WalletId
 
 		// EnsureCoreWallets.
-		_, err = client.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+		_, err = client.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 		require.NoError(t, err)
 
 		// Switch to the bitcoinCore wallet.
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: coreID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: coreID})
 		require.NoError(t, err)
 
 		// GetNewAddress.
-		addrResp, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		addrResp, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
-		require.True(t, strings.HasPrefix(addrResp.Msg.Address, "bcrt1"))
+		require.True(t, strings.HasPrefix(addrResp.Address, "bcrt1"))
 
 		// Mine blocks.
-		err = nodeA.MineToAddress(ctx, 101, addrResp.Msg.Address)
+		err = nodeA.MineToAddress(ctx, 101, addrResp.Address)
 		require.NoError(t, err)
 
 		// GetBalance.
-		bal, err := client.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
+		bal, err := client.GetBalance(ctx, &pb.GetBalanceRequest{})
 		require.NoError(t, err)
-		require.Greater(t, bal.Msg.ConfirmedSats, float64(0))
-		t.Logf("balance: %f sats", bal.Msg.ConfirmedSats)
+		require.Greater(t, bal.ConfirmedSats, float64(0))
+		t.Logf("balance: %f sats", bal.ConfirmedSats)
 
 		// SendTransaction cross-node.
 		_ = nodeB.FundWallet(t)
 
-		addrBResp, err := nodeB.WalletClient.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		addrBResp, err := nodeB.WalletClient.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
 
-		sendResp, err := client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
-			Destinations: map[string]int64{addrBResp.Msg.Address: 50_000_000},
-		}))
+		sendResp, err := client.SendTransaction(ctx, &pb.SendTransactionRequest{
+			Destinations: map[string]int64{addrBResp.Address: 50_000_000},
+		})
 		require.NoError(t, err)
-		require.NotEmpty(t, sendResp.Msg.Txid)
-		t.Logf("sent tx: %s", sendResp.Msg.Txid)
+		require.NotEmpty(t, sendResp.Txid)
+		t.Logf("sent tx: %s", sendResp.Txid)
 
 		err = nodeA.Mine(ctx, t, 1)
 		require.NoError(t, err)
@@ -118,10 +117,10 @@ func TestBitwindowWalletIntegration(t *testing.T) {
 		nodeA.WaitForSync(t, nodeB)
 
 		// Verify on B side.
-		txsB, err := nodeB.WalletClient.ListTransactions(ctx, connect.NewRequest(&pb.ListTransactionsRequest{Count: 200}))
+		txsB, err := nodeB.WalletClient.ListTransactions(ctx, &pb.ListTransactionsRequest{Count: 200})
 		require.NoError(t, err)
 		foundReceive := false
-		for _, tx := range txsB.Msg.Transactions {
+		for _, tx := range txsB.Transactions {
 			if tx.Category == "receive" && tx.AmountSats == 50_000_000 {
 				foundReceive = true
 				break
@@ -139,59 +138,59 @@ func TestBitwindowWalletIntegration(t *testing.T) {
 		client := nodeA.WalletClient
 
 		woXpub := generateTestXpub(t)
-		woResp, err := client.CreateWatchOnlyWallet(ctx, connect.NewRequest(&pb.CreateWatchOnlyWalletRequest{
+		woResp, err := client.CreateWatchOnlyWallet(ctx, &pb.CreateWatchOnlyWalletRequest{
 			Name:             "bw-watch",
 			XpubOrDescriptor: fmt.Sprintf("wpkh(%s/0/*)", woXpub),
 			GradientJson:     `{"background_svg":""}`,
-		}))
+		})
 		require.NoError(t, err)
-		woID := woResp.Msg.WalletId
+		woID := woResp.WalletId
 
-		_, err = client.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+		_, err = client.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 		require.NoError(t, err)
 
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: woID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: woID})
 		require.NoError(t, err)
 
-		addrResp, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		addrResp, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
-		require.True(t, strings.HasPrefix(addrResp.Msg.Address, "bcrt1"))
+		require.True(t, strings.HasPrefix(addrResp.Address, "bcrt1"))
 
 		// Send from the wallet Phase 1 mined to. The first Core wallet in the
 		// list is bw-primary, which holds nothing.
-		list, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		list, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
 		var fundedID string
-		for _, w := range list.Msg.Wallets {
+		for _, w := range list.Wallets {
 			if w.Name == "bw-core" {
 				fundedID = w.Id
 				break
 			}
 		}
 		require.NotEmpty(t, fundedID)
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: fundedID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: fundedID})
 		require.NoError(t, err)
 
-		_, err = client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
-			Destinations: map[string]int64{addrResp.Msg.Address: 5_000_000},
-		}))
+		_, err = client.SendTransaction(ctx, &pb.SendTransactionRequest{
+			Destinations: map[string]int64{addrResp.Address: 5_000_000},
+		})
 		require.NoError(t, err)
 
 		err = nodeA.Mine(ctx, t, 1)
 		require.NoError(t, err)
 
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: woID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: woID})
 		require.NoError(t, err)
 
-		bal, err := client.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
+		bal, err := client.GetBalance(ctx, &pb.GetBalanceRequest{})
 		require.NoError(t, err)
-		require.Greater(t, bal.Msg.ConfirmedSats, float64(0))
-		t.Logf("watch-only balance: %f sats", bal.Msg.ConfirmedSats)
+		require.Greater(t, bal.ConfirmedSats, float64(0))
+		t.Logf("watch-only balance: %f sats", bal.ConfirmedSats)
 
 		// Send from watch-only should fail.
-		_, err = client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+		_, err = client.SendTransaction(ctx, &pb.SendTransactionRequest{
 			Destinations: map[string]int64{"bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080": 1_000_000},
-		}))
+		})
 		require.ErrorContains(t, err, "Private keys are disabled for this wallet")
 		t.Logf("watch-only send correctly failed: %v", err)
 	})
@@ -204,10 +203,10 @@ func TestBitwindowWalletIntegration(t *testing.T) {
 		defer cancel()
 		client := nodeA.WalletClient
 
-		walletList, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		walletList, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
 		var primaryID string
-		for _, w := range walletList.Msg.Wallets {
+		for _, w := range walletList.Wallets {
 			if w.Name == "bw-primary" {
 				primaryID = w.Id
 				break
@@ -215,21 +214,21 @@ func TestBitwindowWalletIntegration(t *testing.T) {
 		}
 		require.NotEmpty(t, primaryID)
 
-		seedResp, err := client.GetWalletSeed(ctx, connect.NewRequest(&pb.GetWalletSeedRequest{WalletId: primaryID}))
+		seedResp, err := client.GetWalletSeed(ctx, &pb.GetWalletSeedRequest{WalletId: primaryID})
 		require.NoError(t, err)
-		require.NotEmpty(t, seedResp.Msg.SeedHex)
-		require.Len(t, seedResp.Msg.SeedHex, 128) // 64 bytes = 128 hex chars
-		t.Logf("primary seed (first 16 chars): %s...", seedResp.Msg.SeedHex[:16])
+		require.NotEmpty(t, seedResp.SeedHex)
+		require.Len(t, seedResp.SeedHex, 128) // 64 bytes = 128 hex chars
+		t.Logf("primary seed (first 16 chars): %s...", seedResp.SeedHex[:16])
 
-		list, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		list, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
-		require.NotEmpty(t, list.Msg.Wallets)
+		require.NotEmpty(t, list.Wallets)
 
-		seedResp2, err := client.GetWalletSeed(ctx, connect.NewRequest(&pb.GetWalletSeedRequest{
-			WalletId: list.Msg.Wallets[0].Id,
-		}))
+		seedResp2, err := client.GetWalletSeed(ctx, &pb.GetWalletSeedRequest{
+			WalletId: list.Wallets[0].Id,
+		})
 		require.NoError(t, err)
-		require.NotEmpty(t, seedResp2.Msg.SeedHex)
+		require.NotEmpty(t, seedResp2.SeedHex)
 	})
 
 }
diff --git a/bitwindow/server/main.go b/bitwindow/server/main.go
index db7ede091a..c4d0f49451 100644
--- a/bitwindow/server/main.go
+++ b/bitwindow/server/main.go
@@ -21,7 +21,6 @@ import (
 	"syscall"
 	"time"
 
-	"connectrpc.com/connect"
 	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/jessevdk/go-flags"
 	"github.com/rs/zerolog"
@@ -767,7 +766,7 @@ func relayShutdownToDrivechaind(addr, bitwindowDir string, log zerolog.Logger) {
 	defer cancel()
 	// only_if_last: we cannot see a sidechain frontend attached straight to
 	// drivechaind, so let its own lease decide.
-	if _, err := client.Shutdown(ctx, connect.NewRequest(&orchpb.ShutdownRequest{OnlyIfLast: true})); err != nil {
+	if _, err := client.Shutdown(ctx, &orchpb.ShutdownRequest{OnlyIfLast: true}); err != nil {
 		log.Warn().Err(err).Msg("relay Shutdown to drivechaind on exit (continuing)")
 		return
 	}
@@ -800,7 +799,7 @@ func retireOrchestrator(ctx context.Context, addr, bitwindowDir string, log *zer
 	defer cancel()
 	// A daemon that takes this exits at once, so it often drops the answer.
 	// The freed port is the signal that counts, not the reply.
-	if _, err := client.Shutdown(drainCtx, connect.NewRequest(&orchpb.ShutdownRequest{KeepL1: true})); err != nil {
+	if _, err := client.Shutdown(drainCtx, &orchpb.ShutdownRequest{KeepL1: true}); err != nil {
 		log.Info().Err(err).Msg("asked the old drivechaind to exit, waiting for the port")
 	}
 
@@ -829,14 +828,14 @@ func waitForOrchestratorNetwork(ctx context.Context, addr, bitwindowDir string,
 	confClient := dial.BitcoinConf(addr, bitwindowDir)
 
 	for i := 0; i < 30; i++ {
-		resp, err := confClient.GetBitcoinConfig(ctx, connect.NewRequest(&orchpb.GetBitcoinConfigRequest{}))
+		resp, err := confClient.GetBitcoinConfig(ctx, &orchpb.GetBitcoinConfigRequest{})
 		if err == nil {
-			network := resp.Msg.GetNetwork()
+			network := resp.GetNetwork()
 			if network == "" {
 				return "", "", errors.New("drivechaind returned empty network")
 			}
 			log.Info().Str("network", network).Int("attempts", i+1).Msg("aligned to drivechaind network")
-			return network, resp.Msg.GetEcashNetworkId(), nil
+			return network, resp.GetEcashNetworkId(), nil
 		}
 		if i == 29 {
 			return "", "", fmt.Errorf("drivechaind did not become ready: %w", err)
diff --git a/bitwindow/server/service/service.go b/bitwindow/server/service/service.go
index 0206597d5e..84878f6679 100644
--- a/bitwindow/server/service/service.go
+++ b/bitwindow/server/service/service.go
@@ -8,7 +8,7 @@ import (
 	"sync/atomic"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 )
 
@@ -59,7 +59,7 @@ func (s *Service[T]) Connect(ctx context.Context) (T, error) {
 	if err != nil {
 		s.setConnected(ctx, false)
 		var zero T
-		return zero, connect.NewError(connect.CodeUnavailable, fmt.Errorf("%s does not accept connections: %w", s.name, err))
+		return zero, connect.NewError(connect.CodeUnavailable, fmt.Sprintf("%s does not accept connections: %s", s.name, err)).WithCause(err)
 	}
 
 	s.mu.Lock()
diff --git a/bitwindow/server/service/service_test.go b/bitwindow/server/service/service_test.go
index 7a01cf4698..4e88ce9865 100644
--- a/bitwindow/server/service/service_test.go
+++ b/bitwindow/server/service/service_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
diff --git a/bitwindow/server/tests/apitests/apitests.go b/bitwindow/server/tests/apitests/apitests.go
index d8be2f2606..297a8ffec7 100644
--- a/bitwindow/server/tests/apitests/apitests.go
+++ b/bitwindow/server/tests/apitests/apitests.go
@@ -13,7 +13,9 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -155,7 +157,13 @@ func WithOrchestratorControl(handler orchctlrpc.OrchestratorServiceHandler) Serv
 	return func(opt *configg) { opt.control = handler }
 }
 
-func API(t *testing.T, database *sql.DB, options ...ServerOpt) (connect.HTTPClient, string) {
+func RPC(t *testing.T, database *sql.DB, options ...ServerOpt) *connect.Client {
+	t.Helper()
+	client, address := API(t, database, options...)
+	return connect.NewClient(connecthttp.NewTransport(client, address, connecthttp.WithReadMaxBytes(0)))
+}
+
+func API(t *testing.T, database *sql.DB, options ...ServerOpt) (*http.Client, string) {
 	ctrl := gomock.NewController(t)
 
 	// Create isolated logger for this test to avoid race conditions
@@ -178,7 +186,7 @@ func API(t *testing.T, database *sql.DB, options ...ServerOpt) (connect.HTTPClie
 	if mock, ok := conf.bitcoind.(*mocks.MockBitcoinServiceClient); ok {
 		mock.EXPECT().
 			GetZmqNotifications(gomock.Any(), gomock.Any()).
-			Return(nil, connect.NewError(connect.CodeUnavailable, errors.New("no ZMQ in tests"))).
+			Return(nil, connectv1.NewError(connectv1.CodeUnavailable, errors.New("no ZMQ in tests"))).
 			AnyTimes()
 	}
 
@@ -339,7 +347,7 @@ func makeWalletWatchOnly(t *testing.T, walletDir string) {
 	require.NoError(t, os.WriteFile(walletPath, data, 0600))
 }
 
-func serve(t *testing.T, server *api.Server) (connect.HTTPClient, string) {
+func serve(t *testing.T, server *api.Server) (*http.Client, string) {
 	testServer := httptest.NewUnstartedServer(server.Handler())
 	// Bidi streams such as gRPC reflection need HTTP/2, as Server.Serve allows.
 	testServer.Config.Protocols = new(http.Protocols)
@@ -374,7 +382,7 @@ func defaultBitcoindMock(ctrl *gomock.Controller) bitcoindv1alphaconnect.Bitcoin
 	// Core is down, so the parser waits. An empty chain makes the parser
 	// purge the block rows a test seeds. These go first to match ahead of
 	// the height 1 answer of ExpectCoreWalletSetup.
-	down := connect.NewError(connect.CodeUnavailable, errors.New("core is down"))
+	down := connect.NewError(connect.CodeUnavailable, "core is down")
 	mock.EXPECT().GetBlockHash(gomock.Any(), gomock.Any()).Return(nil, down).AnyTimes()
 	mock.EXPECT().GetRawMempool(gomock.Any(), gomock.Any()).Return(nil, down).AnyTimes()
 
@@ -382,7 +390,7 @@ func defaultBitcoindMock(ctrl *gomock.Controller) bitcoindv1alphaconnect.Bitcoin
 
 	mock.EXPECT().
 		ListWallets(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.ListWalletsResponse]{
+		Return(&connectv1.Response[corepb.ListWalletsResponse]{
 			Msg: &corepb.ListWalletsResponse{
 				Wallets: []string{},
 			},
@@ -400,7 +408,9 @@ func orchestratorServer(t *testing.T, control orchctlrpc.OrchestratorServiceHand
 		control = orchctlrpc.UnimplementedOrchestratorServiceHandler{}
 	}
 	mux := http.NewServeMux()
-	mux.Handle(orchctlrpc.NewOrchestratorServiceHandler(control))
+	srv := connect.NewServer()
+	orchctlrpc.RegisterOrchestratorServiceHandler(srv, control)
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
 	return server.URL
@@ -412,10 +422,12 @@ func orchestratorServer(t *testing.T, control orchctlrpc.OrchestratorServiceHand
 func CoreWalletOrchestrator(t *testing.T) orchrpc.WalletManagerServiceClient {
 	t.Helper()
 	mux := http.NewServeMux()
-	mux.Handle(orchrpc.NewWalletManagerServiceHandler(coreWalletManager{}))
+	srv := connect.NewServer()
+	orchrpc.RegisterWalletManagerServiceHandler(srv, coreWalletManager{})
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
-	return orchrpc.NewWalletManagerServiceClient(server.Client(), server.URL)
+	return orchrpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 }
 
 type coreWalletManager struct {
@@ -434,18 +446,18 @@ type openWallet struct {
 }
 
 func (o openWallet) ListWallets(
-	context.Context, *connect.Request[orchpb.ListWalletsRequest],
-) (*connect.Response[orchpb.ListWalletsResponse], error) {
-	return connect.NewResponse(&orchpb.ListWalletsResponse{
+	context.Context, *orchpb.ListWalletsRequest,
+) (*orchpb.ListWalletsResponse, error) {
+	return &orchpb.ListWalletsResponse{
 		Wallets:        []*orchpb.WalletMetadata{o.wallet},
 		ActiveWalletId: o.wallet.Id,
-	}), nil
+	}, nil
 }
 
 func (o openWallet) GetWalletStatus(
-	context.Context, *connect.Request[orchpb.GetWalletStatusRequest],
-) (*connect.Response[orchpb.GetWalletStatusResponse], error) {
-	return connect.NewResponse(&orchpb.GetWalletStatusResponse{State: orchpb.WalletState_WALLET_STATE_UNLOCKED}), nil
+	context.Context, *orchpb.GetWalletStatusRequest,
+) (*orchpb.GetWalletStatusResponse, error) {
+	return &orchpb.GetWalletStatusResponse{State: orchpb.WalletState_WALLET_STATE_UNLOCKED}, nil
 }
 
 // fixtureOrchestrator returns an orchestrator client in full mode whose
@@ -457,10 +469,12 @@ func fixtureOrchestrator(t *testing.T, walletDir string) orchrpc.WalletManagerSe
 	t.Cleanup(svc.Close)
 
 	mux := http.NewServeMux()
-	mux.Handle(orchrpc.NewWalletManagerServiceHandler(fixtureWalletManager{wallets: orchapi.NewWalletHandler(svc)}))
+	srv := connect.NewServer()
+	orchrpc.RegisterWalletManagerServiceHandler(srv, fixtureWalletManager{wallets: orchapi.NewWalletHandler(svc)})
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
-	return orchrpc.NewWalletManagerServiceClient(server.Client(), server.URL)
+	return orchrpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 }
 
 // PasswordWalletOrchestrator returns the fixture orchestrator of
@@ -478,47 +492,47 @@ type fixtureWalletManager struct {
 }
 
 func (m fixtureWalletManager) GetWalletStatus(
-	ctx context.Context, req *connect.Request[orchpb.GetWalletStatusRequest],
-) (*connect.Response[orchpb.GetWalletStatusResponse], error) {
+	ctx context.Context, req *orchpb.GetWalletStatusRequest,
+) (*orchpb.GetWalletStatusResponse, error) {
 	return m.wallets.GetWalletStatus(ctx, req)
 }
 
 func (m fixtureWalletManager) UnlockWallet(
-	ctx context.Context, req *connect.Request[orchpb.UnlockWalletRequest],
-) (*connect.Response[orchpb.UnlockWalletResponse], error) {
+	ctx context.Context, req *orchpb.UnlockWalletRequest,
+) (*orchpb.UnlockWalletResponse, error) {
 	return m.wallets.UnlockWallet(ctx, req)
 }
 
 func (m fixtureWalletManager) LockWallet(
-	ctx context.Context, req *connect.Request[orchpb.LockWalletRequest],
-) (*connect.Response[orchpb.LockWalletResponse], error) {
+	ctx context.Context, req *orchpb.LockWalletRequest,
+) (*orchpb.LockWalletResponse, error) {
 	return m.wallets.LockWallet(ctx, req)
 }
 
 func (m fixtureWalletManager) ListWallets(
-	ctx context.Context, req *connect.Request[orchpb.ListWalletsRequest],
-) (*connect.Response[orchpb.ListWalletsResponse], error) {
+	ctx context.Context, req *orchpb.ListWalletsRequest,
+) (*orchpb.ListWalletsResponse, error) {
 	return m.wallets.ListWallets(ctx, req)
 }
 
 func (m fixtureWalletManager) GetWalletSeed(
-	ctx context.Context, req *connect.Request[orchpb.GetWalletSeedRequest],
-) (*connect.Response[orchpb.GetWalletSeedResponse], error) {
+	ctx context.Context, req *orchpb.GetWalletSeedRequest,
+) (*orchpb.GetWalletSeedResponse, error) {
 	return m.wallets.GetWalletSeed(ctx, req)
 }
 
 func (fixtureWalletManager) GetNodeMode(
-	context.Context, *connect.Request[orchpb.GetNodeModeRequest],
-) (*connect.Response[orchpb.GetNodeModeResponse], error) {
-	return connect.NewResponse(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}), nil
+	context.Context, *orchpb.GetNodeModeRequest,
+) (*orchpb.GetNodeModeResponse, error) {
+	return &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}, nil
 }
 
 func (coreWalletManager) CreateBitcoinCoreWallet(
-	_ context.Context, req *connect.Request[orchpb.CreateBitcoinCoreWalletRequest],
-) (*connect.Response[orchpb.CreateBitcoinCoreWalletResponse], error) {
-	return connect.NewResponse(&orchpb.CreateBitcoinCoreWalletResponse{
-		CoreWalletName: "wallet_" + req.Msg.WalletId[:8],
-	}), nil
+	_ context.Context, req *orchpb.CreateBitcoinCoreWalletRequest,
+) (*orchpb.CreateBitcoinCoreWalletResponse, error) {
+	return &orchpb.CreateBitcoinCoreWalletResponse{
+		CoreWalletName: "wallet_" + req.WalletId[:8],
+	}, nil
 }
 
 // ExpectCoreWalletSetup allows the calls the wallet engine makes in the
@@ -530,28 +544,28 @@ func (coreWalletManager) CreateBitcoinCoreWallet(
 func ExpectCoreWalletSetup(mock *mocks.MockBitcoinServiceClient) {
 	mock.EXPECT().
 		ListWallets(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.ListWalletsResponse]{
+		Return(&connectv1.Response[corepb.ListWalletsResponse]{
 			Msg: &corepb.ListWalletsResponse{Wallets: []string{}},
 		}, nil).
 		AnyTimes()
 
 	mock.EXPECT().
 		CreateWallet(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.CreateWalletResponse]{
+		Return(&connectv1.Response[corepb.CreateWalletResponse]{
 			Msg: &corepb.CreateWalletResponse{},
 		}, nil).
 		AnyTimes()
 
 	mock.EXPECT().
 		ImportDescriptors(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.ImportDescriptorsResponse]{
+		Return(&connectv1.Response[corepb.ImportDescriptorsResponse]{
 			Msg: &corepb.ImportDescriptorsResponse{},
 		}, nil).
 		AnyTimes()
 
 	mock.EXPECT().
 		ListTransactions(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.ListTransactionsResponse]{
+		Return(&connectv1.Response[corepb.ListTransactionsResponse]{
 			Msg: &corepb.ListTransactionsResponse{},
 		}, nil).
 		AnyTimes()
@@ -562,7 +576,7 @@ func ExpectCoreWalletSetup(mock *mocks.MockBitcoinServiceClient) {
 	// catch-all swallows the counted expectations a test sets for its own
 	// heights.
 	mock.EXPECT().
-		GetBlockHash(gomock.Any(), gomock.Cond(func(req *connect.Request[corepb.GetBlockHashRequest]) bool {
+		GetBlockHash(gomock.Any(), gomock.Cond(func(req *connectv1.Request[corepb.GetBlockHashRequest]) bool {
 			return req.Msg.GetHeight() == 1
 		})).
 		Return(nil, errors.New("Block height out of range")). //nolint:staticcheck // bitcoind's wording, which the parser matches on
@@ -580,7 +594,7 @@ func ExpectOrchestratorReads(mock *mocks.MockWalletManagerServiceClient) {
 	// Every send hands over the coins the user froze first.
 	mock.EXPECT().
 		SetFrozenCoins(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[emptypb.Empty]{Msg: &emptypb.Empty{}}, nil).
+		Return(&emptypb.Empty{}, nil).
 		AnyTimes()
 }
 
@@ -590,44 +604,34 @@ func expectOrchestratorReads(mock *mocks.MockWalletManagerServiceClient) {
 
 	mock.EXPECT().
 		GetWalletSeed(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetWalletSeedResponse]{
-			Msg: &orchpb.GetWalletSeedResponse{SeedHex: seedHex},
-		}, nil).
+		Return(&orchpb.GetWalletSeedResponse{SeedHex: seedHex}, nil).
 		AnyTimes()
 
 	mock.EXPECT().
 		ListWallets(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.ListWalletsResponse]{
-			Msg: &orchpb.ListWalletsResponse{
-				Wallets: []*orchpb.WalletMetadata{{
-					Id:         fixtureWalletID,
-					Name:       "Test Wallet",
-					WalletType: orchpb.WalletType_WALLET_TYPE_ELECTRUM,
-				}},
-				ActiveWalletId: fixtureWalletID,
-			},
+		Return(&orchpb.ListWalletsResponse{
+			Wallets: []*orchpb.WalletMetadata{{
+				Id:         fixtureWalletID,
+				Name:       "Test Wallet",
+				WalletType: orchpb.WalletType_WALLET_TYPE_ELECTRUM,
+			}},
+			ActiveWalletId: fixtureWalletID,
 		}, nil).
 		AnyTimes()
 
 	mock.EXPECT().
 		GetAddressUnspent(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetAddressUnspentResponse]{
-			Msg: &orchpb.GetAddressUnspentResponse{},
-		}, nil).
+		Return(&orchpb.GetAddressUnspentResponse{}, nil).
 		AnyTimes()
 
 	mock.EXPECT().
 		GetWalletStatus(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetWalletStatusResponse]{
-			Msg: &orchpb.GetWalletStatusResponse{State: orchpb.WalletState_WALLET_STATE_UNLOCKED},
-		}, nil).
+		Return(&orchpb.GetWalletStatusResponse{State: orchpb.WalletState_WALLET_STATE_UNLOCKED}, nil).
 		AnyTimes()
 
 	mock.EXPECT().
 		GetNodeMode(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[orchpb.GetNodeModeResponse]{
-			Msg: &orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL},
-		}, nil).
+		Return(&orchpb.GetNodeModeResponse{Mode: orchpb.NodeMode_NODE_MODE_FULL}, nil).
 		AnyTimes()
 }
 
diff --git a/bitwindow/server/tests/apitests/localauth_test.go b/bitwindow/server/tests/apitests/localauth_test.go
index 0c11e0e2e9..02052f4268 100644
--- a/bitwindow/server/tests/apitests/localauth_test.go
+++ b/bitwindow/server/tests/apitests/localauth_test.go
@@ -6,7 +6,9 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"connectrpc.com/grpcreflect"
 	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/stretchr/testify/require"
@@ -34,23 +36,23 @@ func TestLocalAuth(t *testing.T) {
 	apitests.ExpectCoreWalletSetup(bitcoind)
 	bitcoind.EXPECT().
 		GetRawMempool(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.GetRawMempoolResponse]{Msg: &corepb.GetRawMempoolResponse{}}, nil).
+		Return(&connectv1.Response[corepb.GetRawMempoolResponse]{Msg: &corepb.GetRawMempoolResponse{}}, nil).
 		AnyTimes()
 	bitcoind.EXPECT().
 		GetBlockchainInfo(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[corepb.GetBlockchainInfoResponse]{Msg: &corepb.GetBlockchainInfoResponse{Chain: "regtest"}}, nil).
+		Return(&connectv1.Response[corepb.GetBlockchainInfoResponse]{Msg: &corepb.GetBlockchainInfoResponse{Chain: "regtest"}}, nil).
 		AnyTimes()
 
 	validator := mocks.NewMockValidatorServiceClient(ctrl)
 	validator.EXPECT().
 		GetChainInfo(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[mainchainv1.GetChainInfoResponse]{Msg: &mainchainv1.GetChainInfoResponse{}}, nil).
+		Return(&mainchainv1.GetChainInfoResponse{}, nil).
 		AnyTimes()
 
 	crypto := mocks.NewMockCryptoServiceClient(ctrl)
 	crypto.EXPECT().
 		Ripemd160(gomock.Any(), gomock.Any()).
-		Return(&connect.Response[cryptov1.Ripemd160Response]{Msg: &cryptov1.Ripemd160Response{}}, nil).
+		Return(&cryptov1.Ripemd160Response{}, nil).
 		AnyTimes()
 
 	dir := t.TempDir()
@@ -88,9 +90,9 @@ func TestLocalAuth(t *testing.T) {
 			methods := service.Methods()
 			for i := range methods.Len() {
 				procedure := "/" + string(service.FullName()) + "/" + string(methods.Get(i).Name())
-				var connectErr *connect.Error
+				var connectErr *connectv1.Error
 				require.ErrorAs(t, callWithoutToken(t, h2, baseURL+procedure, methods.Get(i)), &connectErr, procedure)
-				require.Equal(t, connect.CodeUnauthenticated, connectErr.Code(), procedure)
+				require.Equal(t, connectv1.CodeUnauthenticated, connectErr.Code(), procedure)
 				require.Equal(t, localauth.TokenRejectedMessage, connectErr.Message(), procedure)
 				checked++
 			}
@@ -111,10 +113,11 @@ func TestLocalAuth(t *testing.T) {
 	})
 
 	t.Run("a call with the cookie token passes auth", func(t *testing.T) {
-		cli := healthv1connect.NewHealthServiceClient(httpClient, baseURL,
-			connect.WithInterceptors(localauth.Interceptor(dir)))
+		cli := healthv1connect.NewHealthServiceClient(connect.NewClient(connecthttp.NewTransport(httpClient, baseURL,
+			connecthttp.WithReadMaxBytes(0),
+		), localauth.ClientInterceptor(dir)))
 
-		_, err := cli.Check(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := cli.Check(t.Context(), &emptypb.Empty{})
 		require.NoError(t, err)
 	})
 }
@@ -135,14 +138,14 @@ func http2Client(t *testing.T) *http.Client {
 func callWithoutToken(t *testing.T, h2 *http.Client, url string, method protoreflect.MethodDescriptor) error {
 	t.Helper()
 
-	client := connect.NewClient[emptypb.Empty, emptypb.Empty](h2, url)
+	client := connectv1.NewClient[emptypb.Empty, emptypb.Empty](h2, url)
 	switch {
 	case !method.IsStreamingClient() && !method.IsStreamingServer():
-		_, err := client.CallUnary(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		_, err := client.CallUnary(t.Context(), connectv1.NewRequest(&emptypb.Empty{}))
 		return err
 
 	case !method.IsStreamingClient():
-		stream, err := client.CallServerStream(t.Context(), connect.NewRequest(&emptypb.Empty{}))
+		stream, err := client.CallServerStream(t.Context(), connectv1.NewRequest(&emptypb.Empty{}))
 		if err != nil {
 			return err
 		}
diff --git a/bitwindow/server/tests/mocks/mock_crypto.go b/bitwindow/server/tests/mocks/mock_crypto.go
index c92c9ba7c8..73180c5fb1 100644
--- a/bitwindow/server/tests/mocks/mock_crypto.go
+++ b/bitwindow/server/tests/mocks/mock_crypto.go
@@ -13,7 +13,6 @@ import (
 	context "context"
 	reflect "reflect"
 
-	connect "connectrpc.com/connect"
 	cryptov1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/crypto/v1"
 	gomock "go.uber.org/mock/gomock"
 )
@@ -43,10 +42,10 @@ func (m *MockCryptoServiceClient) EXPECT() *MockCryptoServiceClientMockRecorder
 }
 
 // HmacSha512 mocks base method.
-func (m *MockCryptoServiceClient) HmacSha512(arg0 context.Context, arg1 *connect.Request[cryptov1.HmacSha512Request]) (*connect.Response[cryptov1.HmacSha512Response], error) {
+func (m *MockCryptoServiceClient) HmacSha512(arg0 context.Context, arg1 *cryptov1.HmacSha512Request) (*cryptov1.HmacSha512Response, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HmacSha512", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.HmacSha512Response])
+	ret0, _ := ret[0].(*cryptov1.HmacSha512Response)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -58,10 +57,10 @@ func (mr *MockCryptoServiceClientMockRecorder) HmacSha512(arg0, arg1 any) *gomoc
 }
 
 // Ripemd160 mocks base method.
-func (m *MockCryptoServiceClient) Ripemd160(arg0 context.Context, arg1 *connect.Request[cryptov1.Ripemd160Request]) (*connect.Response[cryptov1.Ripemd160Response], error) {
+func (m *MockCryptoServiceClient) Ripemd160(arg0 context.Context, arg1 *cryptov1.Ripemd160Request) (*cryptov1.Ripemd160Response, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Ripemd160", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Ripemd160Response])
+	ret0, _ := ret[0].(*cryptov1.Ripemd160Response)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -73,10 +72,10 @@ func (mr *MockCryptoServiceClientMockRecorder) Ripemd160(arg0, arg1 any) *gomock
 }
 
 // Secp256K1SecretKeyToPublicKey mocks base method.
-func (m *MockCryptoServiceClient) Secp256K1SecretKeyToPublicKey(arg0 context.Context, arg1 *connect.Request[cryptov1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[cryptov1.Secp256K1SecretKeyToPublicKeyResponse], error) {
+func (m *MockCryptoServiceClient) Secp256K1SecretKeyToPublicKey(arg0 context.Context, arg1 *cryptov1.Secp256K1SecretKeyToPublicKeyRequest) (*cryptov1.Secp256K1SecretKeyToPublicKeyResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Secp256K1SecretKeyToPublicKey", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Secp256K1SecretKeyToPublicKeyResponse])
+	ret0, _ := ret[0].(*cryptov1.Secp256K1SecretKeyToPublicKeyResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -88,10 +87,10 @@ func (mr *MockCryptoServiceClientMockRecorder) Secp256K1SecretKeyToPublicKey(arg
 }
 
 // Secp256K1Sign mocks base method.
-func (m *MockCryptoServiceClient) Secp256K1Sign(arg0 context.Context, arg1 *connect.Request[cryptov1.Secp256K1SignRequest]) (*connect.Response[cryptov1.Secp256K1SignResponse], error) {
+func (m *MockCryptoServiceClient) Secp256K1Sign(arg0 context.Context, arg1 *cryptov1.Secp256K1SignRequest) (*cryptov1.Secp256K1SignResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Secp256K1Sign", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Secp256K1SignResponse])
+	ret0, _ := ret[0].(*cryptov1.Secp256K1SignResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -103,10 +102,10 @@ func (mr *MockCryptoServiceClientMockRecorder) Secp256K1Sign(arg0, arg1 any) *go
 }
 
 // Secp256K1Verify mocks base method.
-func (m *MockCryptoServiceClient) Secp256K1Verify(arg0 context.Context, arg1 *connect.Request[cryptov1.Secp256K1VerifyRequest]) (*connect.Response[cryptov1.Secp256K1VerifyResponse], error) {
+func (m *MockCryptoServiceClient) Secp256K1Verify(arg0 context.Context, arg1 *cryptov1.Secp256K1VerifyRequest) (*cryptov1.Secp256K1VerifyResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Secp256K1Verify", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Secp256K1VerifyResponse])
+	ret0, _ := ret[0].(*cryptov1.Secp256K1VerifyResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -142,10 +141,10 @@ func (m *MockCryptoServiceHandler) EXPECT() *MockCryptoServiceHandlerMockRecorde
 }
 
 // HmacSha512 mocks base method.
-func (m *MockCryptoServiceHandler) HmacSha512(arg0 context.Context, arg1 *connect.Request[cryptov1.HmacSha512Request]) (*connect.Response[cryptov1.HmacSha512Response], error) {
+func (m *MockCryptoServiceHandler) HmacSha512(arg0 context.Context, arg1 *cryptov1.HmacSha512Request) (*cryptov1.HmacSha512Response, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HmacSha512", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.HmacSha512Response])
+	ret0, _ := ret[0].(*cryptov1.HmacSha512Response)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -157,10 +156,10 @@ func (mr *MockCryptoServiceHandlerMockRecorder) HmacSha512(arg0, arg1 any) *gomo
 }
 
 // Ripemd160 mocks base method.
-func (m *MockCryptoServiceHandler) Ripemd160(arg0 context.Context, arg1 *connect.Request[cryptov1.Ripemd160Request]) (*connect.Response[cryptov1.Ripemd160Response], error) {
+func (m *MockCryptoServiceHandler) Ripemd160(arg0 context.Context, arg1 *cryptov1.Ripemd160Request) (*cryptov1.Ripemd160Response, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Ripemd160", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Ripemd160Response])
+	ret0, _ := ret[0].(*cryptov1.Ripemd160Response)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -172,10 +171,10 @@ func (mr *MockCryptoServiceHandlerMockRecorder) Ripemd160(arg0, arg1 any) *gomoc
 }
 
 // Secp256K1SecretKeyToPublicKey mocks base method.
-func (m *MockCryptoServiceHandler) Secp256K1SecretKeyToPublicKey(arg0 context.Context, arg1 *connect.Request[cryptov1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[cryptov1.Secp256K1SecretKeyToPublicKeyResponse], error) {
+func (m *MockCryptoServiceHandler) Secp256K1SecretKeyToPublicKey(arg0 context.Context, arg1 *cryptov1.Secp256K1SecretKeyToPublicKeyRequest) (*cryptov1.Secp256K1SecretKeyToPublicKeyResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Secp256K1SecretKeyToPublicKey", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Secp256K1SecretKeyToPublicKeyResponse])
+	ret0, _ := ret[0].(*cryptov1.Secp256K1SecretKeyToPublicKeyResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -187,10 +186,10 @@ func (mr *MockCryptoServiceHandlerMockRecorder) Secp256K1SecretKeyToPublicKey(ar
 }
 
 // Secp256K1Sign mocks base method.
-func (m *MockCryptoServiceHandler) Secp256K1Sign(arg0 context.Context, arg1 *connect.Request[cryptov1.Secp256K1SignRequest]) (*connect.Response[cryptov1.Secp256K1SignResponse], error) {
+func (m *MockCryptoServiceHandler) Secp256K1Sign(arg0 context.Context, arg1 *cryptov1.Secp256K1SignRequest) (*cryptov1.Secp256K1SignResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Secp256K1Sign", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Secp256K1SignResponse])
+	ret0, _ := ret[0].(*cryptov1.Secp256K1SignResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -202,10 +201,10 @@ func (mr *MockCryptoServiceHandlerMockRecorder) Secp256K1Sign(arg0, arg1 any) *g
 }
 
 // Secp256K1Verify mocks base method.
-func (m *MockCryptoServiceHandler) Secp256K1Verify(arg0 context.Context, arg1 *connect.Request[cryptov1.Secp256K1VerifyRequest]) (*connect.Response[cryptov1.Secp256K1VerifyResponse], error) {
+func (m *MockCryptoServiceHandler) Secp256K1Verify(arg0 context.Context, arg1 *cryptov1.Secp256K1VerifyRequest) (*cryptov1.Secp256K1VerifyResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Secp256K1Verify", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[cryptov1.Secp256K1VerifyResponse])
+	ret0, _ := ret[0].(*cryptov1.Secp256K1VerifyResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
diff --git a/bitwindow/server/tests/mocks/mock_validator.go b/bitwindow/server/tests/mocks/mock_validator.go
index 85f90914dc..c11b4f8236 100644
--- a/bitwindow/server/tests/mocks/mock_validator.go
+++ b/bitwindow/server/tests/mocks/mock_validator.go
@@ -13,8 +13,8 @@ import (
 	context "context"
 	reflect "reflect"
 
-	connect "connectrpc.com/connect"
 	mainchainv1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
+	mainchainv1connect "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect"
 	gomock "go.uber.org/mock/gomock"
 )
 
@@ -43,10 +43,10 @@ func (m *MockValidatorServiceClient) EXPECT() *MockValidatorServiceClientMockRec
 }
 
 // GetBlockHeaderInfo mocks base method.
-func (m *MockValidatorServiceClient) GetBlockHeaderInfo(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetBlockHeaderInfoRequest]) (*connect.Response[mainchainv1.GetBlockHeaderInfoResponse], error) {
+func (m *MockValidatorServiceClient) GetBlockHeaderInfo(arg0 context.Context, arg1 *mainchainv1.GetBlockHeaderInfoRequest) (*mainchainv1.GetBlockHeaderInfoResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBlockHeaderInfo", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetBlockHeaderInfoResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetBlockHeaderInfoResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -58,10 +58,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetBlockHeaderInfo(arg0, arg1
 }
 
 // GetBlockInfo mocks base method.
-func (m *MockValidatorServiceClient) GetBlockInfo(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetBlockInfoRequest]) (*connect.Response[mainchainv1.GetBlockInfoResponse], error) {
+func (m *MockValidatorServiceClient) GetBlockInfo(arg0 context.Context, arg1 *mainchainv1.GetBlockInfoRequest) (*mainchainv1.GetBlockInfoResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBlockInfo", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetBlockInfoResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetBlockInfoResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -73,10 +73,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetBlockInfo(arg0, arg1 any) *
 }
 
 // GetBmmHStarCommitment mocks base method.
-func (m *MockValidatorServiceClient) GetBmmHStarCommitment(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetBmmHStarCommitmentRequest]) (*connect.Response[mainchainv1.GetBmmHStarCommitmentResponse], error) {
+func (m *MockValidatorServiceClient) GetBmmHStarCommitment(arg0 context.Context, arg1 *mainchainv1.GetBmmHStarCommitmentRequest) (*mainchainv1.GetBmmHStarCommitmentResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBmmHStarCommitment", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetBmmHStarCommitmentResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetBmmHStarCommitmentResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -88,10 +88,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetBmmHStarCommitment(arg0, ar
 }
 
 // GetChainInfo mocks base method.
-func (m *MockValidatorServiceClient) GetChainInfo(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetChainInfoRequest]) (*connect.Response[mainchainv1.GetChainInfoResponse], error) {
+func (m *MockValidatorServiceClient) GetChainInfo(arg0 context.Context, arg1 *mainchainv1.GetChainInfoRequest) (*mainchainv1.GetChainInfoResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetChainInfo", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetChainInfoResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetChainInfoResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -103,10 +103,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetChainInfo(arg0, arg1 any) *
 }
 
 // GetChainTip mocks base method.
-func (m *MockValidatorServiceClient) GetChainTip(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetChainTipRequest]) (*connect.Response[mainchainv1.GetChainTipResponse], error) {
+func (m *MockValidatorServiceClient) GetChainTip(arg0 context.Context, arg1 *mainchainv1.GetChainTipRequest) (*mainchainv1.GetChainTipResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetChainTip", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetChainTipResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetChainTipResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -118,10 +118,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetChainTip(arg0, arg1 any) *g
 }
 
 // GetCoinbasePSBT mocks base method.
-func (m *MockValidatorServiceClient) GetCoinbasePSBT(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetCoinbasePSBTRequest]) (*connect.Response[mainchainv1.GetCoinbasePSBTResponse], error) {
+func (m *MockValidatorServiceClient) GetCoinbasePSBT(arg0 context.Context, arg1 *mainchainv1.GetCoinbasePSBTRequest) (*mainchainv1.GetCoinbasePSBTResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCoinbasePSBT", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetCoinbasePSBTResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetCoinbasePSBTResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -133,10 +133,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetCoinbasePSBT(arg0, arg1 any
 }
 
 // GetCtip mocks base method.
-func (m *MockValidatorServiceClient) GetCtip(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetCtipRequest]) (*connect.Response[mainchainv1.GetCtipResponse], error) {
+func (m *MockValidatorServiceClient) GetCtip(arg0 context.Context, arg1 *mainchainv1.GetCtipRequest) (*mainchainv1.GetCtipResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCtip", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetCtipResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetCtipResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -148,10 +148,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetCtip(arg0, arg1 any) *gomoc
 }
 
 // GetSeenBmmRequests mocks base method.
-func (m *MockValidatorServiceClient) GetSeenBmmRequests(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetSeenBmmRequestsRequest]) (*connect.Response[mainchainv1.GetSeenBmmRequestsResponse], error) {
+func (m *MockValidatorServiceClient) GetSeenBmmRequests(arg0 context.Context, arg1 *mainchainv1.GetSeenBmmRequestsRequest) (*mainchainv1.GetSeenBmmRequestsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSeenBmmRequests", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetSeenBmmRequestsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetSeenBmmRequestsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -163,10 +163,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetSeenBmmRequests(arg0, arg1
 }
 
 // GetSidechainProposals mocks base method.
-func (m *MockValidatorServiceClient) GetSidechainProposals(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetSidechainProposalsRequest]) (*connect.Response[mainchainv1.GetSidechainProposalsResponse], error) {
+func (m *MockValidatorServiceClient) GetSidechainProposals(arg0 context.Context, arg1 *mainchainv1.GetSidechainProposalsRequest) (*mainchainv1.GetSidechainProposalsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSidechainProposals", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetSidechainProposalsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetSidechainProposalsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -178,10 +178,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetSidechainProposals(arg0, ar
 }
 
 // GetSidechains mocks base method.
-func (m *MockValidatorServiceClient) GetSidechains(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetSidechainsRequest]) (*connect.Response[mainchainv1.GetSidechainsResponse], error) {
+func (m *MockValidatorServiceClient) GetSidechains(arg0 context.Context, arg1 *mainchainv1.GetSidechainsRequest) (*mainchainv1.GetSidechainsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSidechains", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetSidechainsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetSidechainsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -193,10 +193,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetSidechains(arg0, arg1 any)
 }
 
 // GetTwoWayPegData mocks base method.
-func (m *MockValidatorServiceClient) GetTwoWayPegData(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetTwoWayPegDataRequest]) (*connect.Response[mainchainv1.GetTwoWayPegDataResponse], error) {
+func (m *MockValidatorServiceClient) GetTwoWayPegData(arg0 context.Context, arg1 *mainchainv1.GetTwoWayPegDataRequest) (*mainchainv1.GetTwoWayPegDataResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetTwoWayPegData", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetTwoWayPegDataResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetTwoWayPegDataResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -208,10 +208,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetTwoWayPegData(arg0, arg1 an
 }
 
 // GetWithdrawalBundleProposals mocks base method.
-func (m *MockValidatorServiceClient) GetWithdrawalBundleProposals(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetWithdrawalBundleProposalsRequest]) (*connect.Response[mainchainv1.GetWithdrawalBundleProposalsResponse], error) {
+func (m *MockValidatorServiceClient) GetWithdrawalBundleProposals(arg0 context.Context, arg1 *mainchainv1.GetWithdrawalBundleProposalsRequest) (*mainchainv1.GetWithdrawalBundleProposalsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWithdrawalBundleProposals", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetWithdrawalBundleProposalsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetWithdrawalBundleProposalsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -223,10 +223,10 @@ func (mr *MockValidatorServiceClientMockRecorder) GetWithdrawalBundleProposals(a
 }
 
 // Stop mocks base method.
-func (m *MockValidatorServiceClient) Stop(arg0 context.Context, arg1 *connect.Request[mainchainv1.StopRequest]) (*connect.Response[mainchainv1.StopResponse], error) {
+func (m *MockValidatorServiceClient) Stop(arg0 context.Context, arg1 *mainchainv1.StopRequest) (*mainchainv1.StopResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Stop", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.StopResponse])
+	ret0, _ := ret[0].(*mainchainv1.StopResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -238,10 +238,10 @@ func (mr *MockValidatorServiceClientMockRecorder) Stop(arg0, arg1 any) *gomock.C
 }
 
 // SubscribeEvents mocks base method.
-func (m *MockValidatorServiceClient) SubscribeEvents(arg0 context.Context, arg1 *connect.Request[mainchainv1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[mainchainv1.SubscribeEventsResponse], error) {
+func (m *MockValidatorServiceClient) SubscribeEvents(arg0 context.Context, arg1 *mainchainv1.SubscribeEventsRequest) (mainchainv1connect.ValidatorServiceSubscribeEventsClientStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubscribeEvents", arg0, arg1)
-	ret0, _ := ret[0].(*connect.ServerStreamForClient[mainchainv1.SubscribeEventsResponse])
+	ret0, _ := ret[0].(mainchainv1connect.ValidatorServiceSubscribeEventsClientStream)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -253,10 +253,10 @@ func (mr *MockValidatorServiceClientMockRecorder) SubscribeEvents(arg0, arg1 any
 }
 
 // SubscribeHeaderSyncProgress mocks base method.
-func (m *MockValidatorServiceClient) SubscribeHeaderSyncProgress(arg0 context.Context, arg1 *connect.Request[mainchainv1.SubscribeHeaderSyncProgressRequest]) (*connect.ServerStreamForClient[mainchainv1.SubscribeHeaderSyncProgressResponse], error) {
+func (m *MockValidatorServiceClient) SubscribeHeaderSyncProgress(arg0 context.Context, arg1 *mainchainv1.SubscribeHeaderSyncProgressRequest) (mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressClientStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubscribeHeaderSyncProgress", arg0, arg1)
-	ret0, _ := ret[0].(*connect.ServerStreamForClient[mainchainv1.SubscribeHeaderSyncProgressResponse])
+	ret0, _ := ret[0].(mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressClientStream)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -292,10 +292,10 @@ func (m *MockValidatorServiceHandler) EXPECT() *MockValidatorServiceHandlerMockR
 }
 
 // GetBlockHeaderInfo mocks base method.
-func (m *MockValidatorServiceHandler) GetBlockHeaderInfo(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetBlockHeaderInfoRequest]) (*connect.Response[mainchainv1.GetBlockHeaderInfoResponse], error) {
+func (m *MockValidatorServiceHandler) GetBlockHeaderInfo(arg0 context.Context, arg1 *mainchainv1.GetBlockHeaderInfoRequest) (*mainchainv1.GetBlockHeaderInfoResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBlockHeaderInfo", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetBlockHeaderInfoResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetBlockHeaderInfoResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -307,10 +307,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetBlockHeaderInfo(arg0, arg1
 }
 
 // GetBlockInfo mocks base method.
-func (m *MockValidatorServiceHandler) GetBlockInfo(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetBlockInfoRequest]) (*connect.Response[mainchainv1.GetBlockInfoResponse], error) {
+func (m *MockValidatorServiceHandler) GetBlockInfo(arg0 context.Context, arg1 *mainchainv1.GetBlockInfoRequest) (*mainchainv1.GetBlockInfoResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBlockInfo", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetBlockInfoResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetBlockInfoResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -322,10 +322,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetBlockInfo(arg0, arg1 any)
 }
 
 // GetBmmHStarCommitment mocks base method.
-func (m *MockValidatorServiceHandler) GetBmmHStarCommitment(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetBmmHStarCommitmentRequest]) (*connect.Response[mainchainv1.GetBmmHStarCommitmentResponse], error) {
+func (m *MockValidatorServiceHandler) GetBmmHStarCommitment(arg0 context.Context, arg1 *mainchainv1.GetBmmHStarCommitmentRequest) (*mainchainv1.GetBmmHStarCommitmentResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBmmHStarCommitment", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetBmmHStarCommitmentResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetBmmHStarCommitmentResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -337,10 +337,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetBmmHStarCommitment(arg0, a
 }
 
 // GetChainInfo mocks base method.
-func (m *MockValidatorServiceHandler) GetChainInfo(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetChainInfoRequest]) (*connect.Response[mainchainv1.GetChainInfoResponse], error) {
+func (m *MockValidatorServiceHandler) GetChainInfo(arg0 context.Context, arg1 *mainchainv1.GetChainInfoRequest) (*mainchainv1.GetChainInfoResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetChainInfo", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetChainInfoResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetChainInfoResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -352,10 +352,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetChainInfo(arg0, arg1 any)
 }
 
 // GetChainTip mocks base method.
-func (m *MockValidatorServiceHandler) GetChainTip(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetChainTipRequest]) (*connect.Response[mainchainv1.GetChainTipResponse], error) {
+func (m *MockValidatorServiceHandler) GetChainTip(arg0 context.Context, arg1 *mainchainv1.GetChainTipRequest) (*mainchainv1.GetChainTipResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetChainTip", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetChainTipResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetChainTipResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -367,10 +367,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetChainTip(arg0, arg1 any) *
 }
 
 // GetCoinbasePSBT mocks base method.
-func (m *MockValidatorServiceHandler) GetCoinbasePSBT(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetCoinbasePSBTRequest]) (*connect.Response[mainchainv1.GetCoinbasePSBTResponse], error) {
+func (m *MockValidatorServiceHandler) GetCoinbasePSBT(arg0 context.Context, arg1 *mainchainv1.GetCoinbasePSBTRequest) (*mainchainv1.GetCoinbasePSBTResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCoinbasePSBT", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetCoinbasePSBTResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetCoinbasePSBTResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -382,10 +382,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetCoinbasePSBT(arg0, arg1 an
 }
 
 // GetCtip mocks base method.
-func (m *MockValidatorServiceHandler) GetCtip(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetCtipRequest]) (*connect.Response[mainchainv1.GetCtipResponse], error) {
+func (m *MockValidatorServiceHandler) GetCtip(arg0 context.Context, arg1 *mainchainv1.GetCtipRequest) (*mainchainv1.GetCtipResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCtip", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetCtipResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetCtipResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -397,10 +397,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetCtip(arg0, arg1 any) *gomo
 }
 
 // GetSeenBmmRequests mocks base method.
-func (m *MockValidatorServiceHandler) GetSeenBmmRequests(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetSeenBmmRequestsRequest]) (*connect.Response[mainchainv1.GetSeenBmmRequestsResponse], error) {
+func (m *MockValidatorServiceHandler) GetSeenBmmRequests(arg0 context.Context, arg1 *mainchainv1.GetSeenBmmRequestsRequest) (*mainchainv1.GetSeenBmmRequestsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSeenBmmRequests", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetSeenBmmRequestsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetSeenBmmRequestsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -412,10 +412,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetSeenBmmRequests(arg0, arg1
 }
 
 // GetSidechainProposals mocks base method.
-func (m *MockValidatorServiceHandler) GetSidechainProposals(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetSidechainProposalsRequest]) (*connect.Response[mainchainv1.GetSidechainProposalsResponse], error) {
+func (m *MockValidatorServiceHandler) GetSidechainProposals(arg0 context.Context, arg1 *mainchainv1.GetSidechainProposalsRequest) (*mainchainv1.GetSidechainProposalsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSidechainProposals", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetSidechainProposalsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetSidechainProposalsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -427,10 +427,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetSidechainProposals(arg0, a
 }
 
 // GetSidechains mocks base method.
-func (m *MockValidatorServiceHandler) GetSidechains(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetSidechainsRequest]) (*connect.Response[mainchainv1.GetSidechainsResponse], error) {
+func (m *MockValidatorServiceHandler) GetSidechains(arg0 context.Context, arg1 *mainchainv1.GetSidechainsRequest) (*mainchainv1.GetSidechainsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSidechains", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetSidechainsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetSidechainsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -442,10 +442,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetSidechains(arg0, arg1 any)
 }
 
 // GetTwoWayPegData mocks base method.
-func (m *MockValidatorServiceHandler) GetTwoWayPegData(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetTwoWayPegDataRequest]) (*connect.Response[mainchainv1.GetTwoWayPegDataResponse], error) {
+func (m *MockValidatorServiceHandler) GetTwoWayPegData(arg0 context.Context, arg1 *mainchainv1.GetTwoWayPegDataRequest) (*mainchainv1.GetTwoWayPegDataResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetTwoWayPegData", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetTwoWayPegDataResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetTwoWayPegDataResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -457,10 +457,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetTwoWayPegData(arg0, arg1 a
 }
 
 // GetWithdrawalBundleProposals mocks base method.
-func (m *MockValidatorServiceHandler) GetWithdrawalBundleProposals(arg0 context.Context, arg1 *connect.Request[mainchainv1.GetWithdrawalBundleProposalsRequest]) (*connect.Response[mainchainv1.GetWithdrawalBundleProposalsResponse], error) {
+func (m *MockValidatorServiceHandler) GetWithdrawalBundleProposals(arg0 context.Context, arg1 *mainchainv1.GetWithdrawalBundleProposalsRequest) (*mainchainv1.GetWithdrawalBundleProposalsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWithdrawalBundleProposals", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.GetWithdrawalBundleProposalsResponse])
+	ret0, _ := ret[0].(*mainchainv1.GetWithdrawalBundleProposalsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -472,10 +472,10 @@ func (mr *MockValidatorServiceHandlerMockRecorder) GetWithdrawalBundleProposals(
 }
 
 // Stop mocks base method.
-func (m *MockValidatorServiceHandler) Stop(arg0 context.Context, arg1 *connect.Request[mainchainv1.StopRequest]) (*connect.Response[mainchainv1.StopResponse], error) {
+func (m *MockValidatorServiceHandler) Stop(arg0 context.Context, arg1 *mainchainv1.StopRequest) (*mainchainv1.StopResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Stop", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[mainchainv1.StopResponse])
+	ret0, _ := ret[0].(*mainchainv1.StopResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -487,7 +487,7 @@ func (mr *MockValidatorServiceHandlerMockRecorder) Stop(arg0, arg1 any) *gomock.
 }
 
 // SubscribeEvents mocks base method.
-func (m *MockValidatorServiceHandler) SubscribeEvents(arg0 context.Context, arg1 *connect.Request[mainchainv1.SubscribeEventsRequest], arg2 *connect.ServerStream[mainchainv1.SubscribeEventsResponse]) error {
+func (m *MockValidatorServiceHandler) SubscribeEvents(arg0 context.Context, arg1 *mainchainv1.SubscribeEventsRequest, arg2 mainchainv1connect.ValidatorServiceSubscribeEventsServerStream) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubscribeEvents", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
@@ -501,7 +501,7 @@ func (mr *MockValidatorServiceHandlerMockRecorder) SubscribeEvents(arg0, arg1, a
 }
 
 // SubscribeHeaderSyncProgress mocks base method.
-func (m *MockValidatorServiceHandler) SubscribeHeaderSyncProgress(arg0 context.Context, arg1 *connect.Request[mainchainv1.SubscribeHeaderSyncProgressRequest], arg2 *connect.ServerStream[mainchainv1.SubscribeHeaderSyncProgressResponse]) error {
+func (m *MockValidatorServiceHandler) SubscribeHeaderSyncProgress(arg0 context.Context, arg1 *mainchainv1.SubscribeHeaderSyncProgressRequest, arg2 mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressServerStream) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubscribeHeaderSyncProgress", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
diff --git a/bitwindow/server/tests/mocks/mock_walletmanager.go b/bitwindow/server/tests/mocks/mock_walletmanager.go
index a60a0ca013..6586453acb 100644
--- a/bitwindow/server/tests/mocks/mock_walletmanager.go
+++ b/bitwindow/server/tests/mocks/mock_walletmanager.go
@@ -13,8 +13,8 @@ import (
 	context "context"
 	reflect "reflect"
 
-	connect "connectrpc.com/connect"
 	walletmanagerv1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
+	walletmanagerv1connect "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect"
 	gomock "go.uber.org/mock/gomock"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 )
@@ -44,10 +44,10 @@ func (m *MockWalletManagerServiceClient) EXPECT() *MockWalletManagerServiceClien
 }
 
 // BroadcastElectrumTransaction mocks base method.
-func (m *MockWalletManagerServiceClient) BroadcastElectrumTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.BroadcastElectrumTransactionRequest]) (*connect.Response[walletmanagerv1.BroadcastElectrumTransactionResponse], error) {
+func (m *MockWalletManagerServiceClient) BroadcastElectrumTransaction(arg0 context.Context, arg1 *walletmanagerv1.BroadcastElectrumTransactionRequest) (*walletmanagerv1.BroadcastElectrumTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "BroadcastElectrumTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.BroadcastElectrumTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.BroadcastElectrumTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -59,10 +59,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) BroadcastElectrumTransacti
 }
 
 // BroadcastTransaction mocks base method.
-func (m *MockWalletManagerServiceClient) BroadcastTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.BroadcastTransactionRequest]) (*connect.Response[walletmanagerv1.BroadcastTransactionResponse], error) {
+func (m *MockWalletManagerServiceClient) BroadcastTransaction(arg0 context.Context, arg1 *walletmanagerv1.BroadcastTransactionRequest) (*walletmanagerv1.BroadcastTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "BroadcastTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.BroadcastTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.BroadcastTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -74,10 +74,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) BroadcastTransaction(arg0,
 }
 
 // BumpFee mocks base method.
-func (m *MockWalletManagerServiceClient) BumpFee(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.BumpFeeRequest]) (*connect.Response[walletmanagerv1.BumpFeeResponse], error) {
+func (m *MockWalletManagerServiceClient) BumpFee(arg0 context.Context, arg1 *walletmanagerv1.BumpFeeRequest) (*walletmanagerv1.BumpFeeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "BumpFee", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.BumpFeeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.BumpFeeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -89,10 +89,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) BumpFee(arg0, arg1 any) *g
 }
 
 // CancelTransaction mocks base method.
-func (m *MockWalletManagerServiceClient) CancelTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CancelTransactionRequest]) (*connect.Response[walletmanagerv1.CancelTransactionResponse], error) {
+func (m *MockWalletManagerServiceClient) CancelTransaction(arg0 context.Context, arg1 *walletmanagerv1.CancelTransactionRequest) (*walletmanagerv1.CancelTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CancelTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CancelTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CancelTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -104,10 +104,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CancelTransaction(arg0, ar
 }
 
 // ChangePassword mocks base method.
-func (m *MockWalletManagerServiceClient) ChangePassword(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ChangePasswordRequest]) (*connect.Response[walletmanagerv1.ChangePasswordResponse], error) {
+func (m *MockWalletManagerServiceClient) ChangePassword(arg0 context.Context, arg1 *walletmanagerv1.ChangePasswordRequest) (*walletmanagerv1.ChangePasswordResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ChangePassword", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ChangePasswordResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ChangePasswordResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -119,10 +119,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ChangePassword(arg0, arg1
 }
 
 // CloseDevice mocks base method.
-func (m *MockWalletManagerServiceClient) CloseDevice(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CloseDeviceRequest]) (*connect.Response[walletmanagerv1.CloseDeviceResponse], error) {
+func (m *MockWalletManagerServiceClient) CloseDevice(arg0 context.Context, arg1 *walletmanagerv1.CloseDeviceRequest) (*walletmanagerv1.CloseDeviceResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseDevice", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CloseDeviceResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CloseDeviceResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -134,10 +134,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CloseDevice(arg0, arg1 any
 }
 
 // CombinePsbt mocks base method.
-func (m *MockWalletManagerServiceClient) CombinePsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CombinePsbtRequest]) (*connect.Response[walletmanagerv1.CombinePsbtResponse], error) {
+func (m *MockWalletManagerServiceClient) CombinePsbt(arg0 context.Context, arg1 *walletmanagerv1.CombinePsbtRequest) (*walletmanagerv1.CombinePsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CombinePsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CombinePsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CombinePsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -149,10 +149,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CombinePsbt(arg0, arg1 any
 }
 
 // CreateBitcoinCoreWallet mocks base method.
-func (m *MockWalletManagerServiceClient) CreateBitcoinCoreWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateBitcoinCoreWalletRequest]) (*connect.Response[walletmanagerv1.CreateBitcoinCoreWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) CreateBitcoinCoreWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateBitcoinCoreWalletRequest) (*walletmanagerv1.CreateBitcoinCoreWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateBitcoinCoreWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateBitcoinCoreWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateBitcoinCoreWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -164,10 +164,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CreateBitcoinCoreWallet(ar
 }
 
 // CreateCpfp mocks base method.
-func (m *MockWalletManagerServiceClient) CreateCpfp(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateCpfpRequest]) (*connect.Response[walletmanagerv1.CreateCpfpResponse], error) {
+func (m *MockWalletManagerServiceClient) CreateCpfp(arg0 context.Context, arg1 *walletmanagerv1.CreateCpfpRequest) (*walletmanagerv1.CreateCpfpResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateCpfp", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateCpfpResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateCpfpResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -179,10 +179,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CreateCpfp(arg0, arg1 any)
 }
 
 // CreateDeposit mocks base method.
-func (m *MockWalletManagerServiceClient) CreateDeposit(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateDepositRequest]) (*connect.Response[walletmanagerv1.CreateDepositResponse], error) {
+func (m *MockWalletManagerServiceClient) CreateDeposit(arg0 context.Context, arg1 *walletmanagerv1.CreateDepositRequest) (*walletmanagerv1.CreateDepositResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateDeposit", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateDepositResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateDepositResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -194,10 +194,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CreateDeposit(arg0, arg1 a
 }
 
 // CreateElectrumWallet mocks base method.
-func (m *MockWalletManagerServiceClient) CreateElectrumWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateElectrumWalletRequest]) (*connect.Response[walletmanagerv1.CreateElectrumWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) CreateElectrumWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateElectrumWalletRequest) (*walletmanagerv1.CreateElectrumWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateElectrumWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateElectrumWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateElectrumWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -209,10 +209,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CreateElectrumWallet(arg0,
 }
 
 // CreateMultisigWallet mocks base method.
-func (m *MockWalletManagerServiceClient) CreateMultisigWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateMultisigWalletRequest]) (*connect.Response[walletmanagerv1.CreateMultisigWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) CreateMultisigWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateMultisigWalletRequest) (*walletmanagerv1.CreateMultisigWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateMultisigWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateMultisigWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateMultisigWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -224,10 +224,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CreateMultisigWallet(arg0,
 }
 
 // CreatePsbt mocks base method.
-func (m *MockWalletManagerServiceClient) CreatePsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreatePsbtRequest]) (*connect.Response[walletmanagerv1.CreatePsbtResponse], error) {
+func (m *MockWalletManagerServiceClient) CreatePsbt(arg0 context.Context, arg1 *walletmanagerv1.CreatePsbtRequest) (*walletmanagerv1.CreatePsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreatePsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreatePsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreatePsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -239,10 +239,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CreatePsbt(arg0, arg1 any)
 }
 
 // CreateWatchOnlyWallet mocks base method.
-func (m *MockWalletManagerServiceClient) CreateWatchOnlyWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateWatchOnlyWalletRequest]) (*connect.Response[walletmanagerv1.CreateWatchOnlyWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) CreateWatchOnlyWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateWatchOnlyWalletRequest) (*walletmanagerv1.CreateWatchOnlyWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateWatchOnlyWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateWatchOnlyWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateWatchOnlyWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -254,10 +254,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) CreateWatchOnlyWallet(arg0
 }
 
 // DecodeTransaction mocks base method.
-func (m *MockWalletManagerServiceClient) DecodeTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DecodeTransactionRequest]) (*connect.Response[walletmanagerv1.DecodeTransactionResponse], error) {
+func (m *MockWalletManagerServiceClient) DecodeTransaction(arg0 context.Context, arg1 *walletmanagerv1.DecodeTransactionRequest) (*walletmanagerv1.DecodeTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DecodeTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DecodeTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DecodeTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -269,10 +269,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) DecodeTransaction(arg0, ar
 }
 
 // DeleteAllWallets mocks base method.
-func (m *MockWalletManagerServiceClient) DeleteAllWallets(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeleteAllWalletsRequest]) (*connect.Response[walletmanagerv1.DeleteAllWalletsResponse], error) {
+func (m *MockWalletManagerServiceClient) DeleteAllWallets(arg0 context.Context, arg1 *walletmanagerv1.DeleteAllWalletsRequest) (*walletmanagerv1.DeleteAllWalletsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeleteAllWallets", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeleteAllWalletsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeleteAllWalletsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -284,10 +284,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) DeleteAllWallets(arg0, arg
 }
 
 // DeleteWallet mocks base method.
-func (m *MockWalletManagerServiceClient) DeleteWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeleteWalletRequest]) (*connect.Response[walletmanagerv1.DeleteWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) DeleteWallet(arg0 context.Context, arg1 *walletmanagerv1.DeleteWalletRequest) (*walletmanagerv1.DeleteWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeleteWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeleteWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeleteWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -299,10 +299,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) DeleteWallet(arg0, arg1 an
 }
 
 // DeriveAddresses mocks base method.
-func (m *MockWalletManagerServiceClient) DeriveAddresses(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeriveAddressesRequest]) (*connect.Response[walletmanagerv1.DeriveAddressesResponse], error) {
+func (m *MockWalletManagerServiceClient) DeriveAddresses(arg0 context.Context, arg1 *walletmanagerv1.DeriveAddressesRequest) (*walletmanagerv1.DeriveAddressesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeriveAddresses", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeriveAddressesResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeriveAddressesResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -314,10 +314,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) DeriveAddresses(arg0, arg1
 }
 
 // DeriveKeystore mocks base method.
-func (m *MockWalletManagerServiceClient) DeriveKeystore(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeriveKeystoreRequest]) (*connect.Response[walletmanagerv1.DeriveKeystoreResponse], error) {
+func (m *MockWalletManagerServiceClient) DeriveKeystore(arg0 context.Context, arg1 *walletmanagerv1.DeriveKeystoreRequest) (*walletmanagerv1.DeriveKeystoreResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeriveKeystore", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeriveKeystoreResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeriveKeystoreResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -329,10 +329,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) DeriveKeystore(arg0, arg1
 }
 
 // EncryptWallet mocks base method.
-func (m *MockWalletManagerServiceClient) EncryptWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EncryptWalletRequest]) (*connect.Response[walletmanagerv1.EncryptWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) EncryptWallet(arg0 context.Context, arg1 *walletmanagerv1.EncryptWalletRequest) (*walletmanagerv1.EncryptWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EncryptWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EncryptWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EncryptWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -344,10 +344,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) EncryptWallet(arg0, arg1 a
 }
 
 // EnsureCoreWallets mocks base method.
-func (m *MockWalletManagerServiceClient) EnsureCoreWallets(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EnsureCoreWalletsRequest]) (*connect.Response[walletmanagerv1.EnsureCoreWalletsResponse], error) {
+func (m *MockWalletManagerServiceClient) EnsureCoreWallets(arg0 context.Context, arg1 *walletmanagerv1.EnsureCoreWalletsRequest) (*walletmanagerv1.EnsureCoreWalletsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EnsureCoreWallets", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EnsureCoreWalletsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EnsureCoreWalletsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -359,10 +359,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) EnsureCoreWallets(arg0, ar
 }
 
 // EnumerateHardwareDevices mocks base method.
-func (m *MockWalletManagerServiceClient) EnumerateHardwareDevices(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EnumerateHardwareDevicesRequest]) (*connect.Response[walletmanagerv1.EnumerateHardwareDevicesResponse], error) {
+func (m *MockWalletManagerServiceClient) EnumerateHardwareDevices(arg0 context.Context, arg1 *walletmanagerv1.EnumerateHardwareDevicesRequest) (*walletmanagerv1.EnumerateHardwareDevicesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EnumerateHardwareDevices", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EnumerateHardwareDevicesResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EnumerateHardwareDevicesResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -374,10 +374,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) EnumerateHardwareDevices(a
 }
 
 // EstimateFee mocks base method.
-func (m *MockWalletManagerServiceClient) EstimateFee(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EstimateFeeRequest]) (*connect.Response[walletmanagerv1.EstimateFeeResponse], error) {
+func (m *MockWalletManagerServiceClient) EstimateFee(arg0 context.Context, arg1 *walletmanagerv1.EstimateFeeRequest) (*walletmanagerv1.EstimateFeeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EstimateFee", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EstimateFeeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EstimateFeeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -389,10 +389,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) EstimateFee(arg0, arg1 any
 }
 
 // FinalizePsbt mocks base method.
-func (m *MockWalletManagerServiceClient) FinalizePsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.FinalizePsbtRequest]) (*connect.Response[walletmanagerv1.FinalizePsbtResponse], error) {
+func (m *MockWalletManagerServiceClient) FinalizePsbt(arg0 context.Context, arg1 *walletmanagerv1.FinalizePsbtRequest) (*walletmanagerv1.FinalizePsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FinalizePsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.FinalizePsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.FinalizePsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -404,10 +404,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) FinalizePsbt(arg0, arg1 an
 }
 
 // GenerateWallet mocks base method.
-func (m *MockWalletManagerServiceClient) GenerateWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GenerateWalletRequest]) (*connect.Response[walletmanagerv1.GenerateWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) GenerateWallet(arg0 context.Context, arg1 *walletmanagerv1.GenerateWalletRequest) (*walletmanagerv1.GenerateWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GenerateWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GenerateWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GenerateWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -419,10 +419,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GenerateWallet(arg0, arg1
 }
 
 // GetAddressUnspent mocks base method.
-func (m *MockWalletManagerServiceClient) GetAddressUnspent(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetAddressUnspentRequest]) (*connect.Response[walletmanagerv1.GetAddressUnspentResponse], error) {
+func (m *MockWalletManagerServiceClient) GetAddressUnspent(arg0 context.Context, arg1 *walletmanagerv1.GetAddressUnspentRequest) (*walletmanagerv1.GetAddressUnspentResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAddressUnspent", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetAddressUnspentResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetAddressUnspentResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -434,10 +434,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetAddressUnspent(arg0, ar
 }
 
 // GetBalance mocks base method.
-func (m *MockWalletManagerServiceClient) GetBalance(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetBalanceRequest]) (*connect.Response[walletmanagerv1.GetBalanceResponse], error) {
+func (m *MockWalletManagerServiceClient) GetBalance(arg0 context.Context, arg1 *walletmanagerv1.GetBalanceRequest) (*walletmanagerv1.GetBalanceResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBalance", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetBalanceResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetBalanceResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -449,10 +449,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetBalance(arg0, arg1 any)
 }
 
 // GetCoreVariant mocks base method.
-func (m *MockWalletManagerServiceClient) GetCoreVariant(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetCoreVariantRequest]) (*connect.Response[walletmanagerv1.GetCoreVariantResponse], error) {
+func (m *MockWalletManagerServiceClient) GetCoreVariant(arg0 context.Context, arg1 *walletmanagerv1.GetCoreVariantRequest) (*walletmanagerv1.GetCoreVariantResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCoreVariant", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetCoreVariantResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetCoreVariantResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -464,10 +464,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetCoreVariant(arg0, arg1
 }
 
 // GetElectrumServer mocks base method.
-func (m *MockWalletManagerServiceClient) GetElectrumServer(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetElectrumServerRequest]) (*connect.Response[walletmanagerv1.GetElectrumServerResponse], error) {
+func (m *MockWalletManagerServiceClient) GetElectrumServer(arg0 context.Context, arg1 *walletmanagerv1.GetElectrumServerRequest) (*walletmanagerv1.GetElectrumServerResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetElectrumServer", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetElectrumServerResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetElectrumServerResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -479,10 +479,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetElectrumServer(arg0, ar
 }
 
 // GetHardwareXpub mocks base method.
-func (m *MockWalletManagerServiceClient) GetHardwareXpub(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetHardwareXpubRequest]) (*connect.Response[walletmanagerv1.GetHardwareXpubResponse], error) {
+func (m *MockWalletManagerServiceClient) GetHardwareXpub(arg0 context.Context, arg1 *walletmanagerv1.GetHardwareXpubRequest) (*walletmanagerv1.GetHardwareXpubResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetHardwareXpub", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetHardwareXpubResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetHardwareXpubResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -494,10 +494,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetHardwareXpub(arg0, arg1
 }
 
 // GetNewAddress mocks base method.
-func (m *MockWalletManagerServiceClient) GetNewAddress(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetNewAddressRequest]) (*connect.Response[walletmanagerv1.GetNewAddressResponse], error) {
+func (m *MockWalletManagerServiceClient) GetNewAddress(arg0 context.Context, arg1 *walletmanagerv1.GetNewAddressRequest) (*walletmanagerv1.GetNewAddressResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetNewAddress", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetNewAddressResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetNewAddressResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -509,10 +509,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetNewAddress(arg0, arg1 a
 }
 
 // GetNodeMode mocks base method.
-func (m *MockWalletManagerServiceClient) GetNodeMode(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetNodeModeRequest]) (*connect.Response[walletmanagerv1.GetNodeModeResponse], error) {
+func (m *MockWalletManagerServiceClient) GetNodeMode(arg0 context.Context, arg1 *walletmanagerv1.GetNodeModeRequest) (*walletmanagerv1.GetNodeModeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetNodeMode", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetNodeModeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetNodeModeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -524,10 +524,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetNodeMode(arg0, arg1 any
 }
 
 // GetSidechainDepositTotals mocks base method.
-func (m *MockWalletManagerServiceClient) GetSidechainDepositTotals(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetSidechainDepositTotalsRequest]) (*connect.Response[walletmanagerv1.GetSidechainDepositTotalsResponse], error) {
+func (m *MockWalletManagerServiceClient) GetSidechainDepositTotals(arg0 context.Context, arg1 *walletmanagerv1.GetSidechainDepositTotalsRequest) (*walletmanagerv1.GetSidechainDepositTotalsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSidechainDepositTotals", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetSidechainDepositTotalsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetSidechainDepositTotalsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -539,10 +539,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetSidechainDepositTotals(
 }
 
 // GetTorConfig mocks base method.
-func (m *MockWalletManagerServiceClient) GetTorConfig(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetTorConfigRequest]) (*connect.Response[walletmanagerv1.GetTorConfigResponse], error) {
+func (m *MockWalletManagerServiceClient) GetTorConfig(arg0 context.Context, arg1 *walletmanagerv1.GetTorConfigRequest) (*walletmanagerv1.GetTorConfigResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetTorConfig", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetTorConfigResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetTorConfigResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -554,10 +554,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetTorConfig(arg0, arg1 an
 }
 
 // GetTransactionDetails mocks base method.
-func (m *MockWalletManagerServiceClient) GetTransactionDetails(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetTransactionDetailsRequest]) (*connect.Response[walletmanagerv1.GetTransactionDetailsResponse], error) {
+func (m *MockWalletManagerServiceClient) GetTransactionDetails(arg0 context.Context, arg1 *walletmanagerv1.GetTransactionDetailsRequest) (*walletmanagerv1.GetTransactionDetailsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetTransactionDetails", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetTransactionDetailsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetTransactionDetailsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -569,10 +569,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetTransactionDetails(arg0
 }
 
 // GetWalletSeed mocks base method.
-func (m *MockWalletManagerServiceClient) GetWalletSeed(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetWalletSeedRequest]) (*connect.Response[walletmanagerv1.GetWalletSeedResponse], error) {
+func (m *MockWalletManagerServiceClient) GetWalletSeed(arg0 context.Context, arg1 *walletmanagerv1.GetWalletSeedRequest) (*walletmanagerv1.GetWalletSeedResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWalletSeed", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetWalletSeedResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetWalletSeedResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -584,10 +584,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetWalletSeed(arg0, arg1 a
 }
 
 // GetWalletStatus mocks base method.
-func (m *MockWalletManagerServiceClient) GetWalletStatus(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetWalletStatusRequest]) (*connect.Response[walletmanagerv1.GetWalletStatusResponse], error) {
+func (m *MockWalletManagerServiceClient) GetWalletStatus(arg0 context.Context, arg1 *walletmanagerv1.GetWalletStatusRequest) (*walletmanagerv1.GetWalletStatusResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWalletStatus", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetWalletStatusResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetWalletStatusResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -599,10 +599,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) GetWalletStatus(arg0, arg1
 }
 
 // ListCoreVariants mocks base method.
-func (m *MockWalletManagerServiceClient) ListCoreVariants(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListCoreVariantsRequest]) (*connect.Response[walletmanagerv1.ListCoreVariantsResponse], error) {
+func (m *MockWalletManagerServiceClient) ListCoreVariants(arg0 context.Context, arg1 *walletmanagerv1.ListCoreVariantsRequest) (*walletmanagerv1.ListCoreVariantsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListCoreVariants", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListCoreVariantsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListCoreVariantsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -614,10 +614,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListCoreVariants(arg0, arg
 }
 
 // ListDerivationPaths mocks base method.
-func (m *MockWalletManagerServiceClient) ListDerivationPaths(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListDerivationPathsRequest]) (*connect.Response[walletmanagerv1.ListDerivationPathsResponse], error) {
+func (m *MockWalletManagerServiceClient) ListDerivationPaths(arg0 context.Context, arg1 *walletmanagerv1.ListDerivationPathsRequest) (*walletmanagerv1.ListDerivationPathsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListDerivationPaths", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListDerivationPathsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListDerivationPathsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -629,10 +629,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListDerivationPaths(arg0,
 }
 
 // ListReceiveAddresses mocks base method.
-func (m *MockWalletManagerServiceClient) ListReceiveAddresses(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListReceiveAddressesRequest]) (*connect.Response[walletmanagerv1.ListReceiveAddressesResponse], error) {
+func (m *MockWalletManagerServiceClient) ListReceiveAddresses(arg0 context.Context, arg1 *walletmanagerv1.ListReceiveAddressesRequest) (*walletmanagerv1.ListReceiveAddressesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListReceiveAddresses", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListReceiveAddressesResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListReceiveAddressesResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -644,10 +644,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListReceiveAddresses(arg0,
 }
 
 // ListSidechainDeposits mocks base method.
-func (m *MockWalletManagerServiceClient) ListSidechainDeposits(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListSidechainDepositsRequest]) (*connect.Response[walletmanagerv1.ListSidechainDepositsResponse], error) {
+func (m *MockWalletManagerServiceClient) ListSidechainDeposits(arg0 context.Context, arg1 *walletmanagerv1.ListSidechainDepositsRequest) (*walletmanagerv1.ListSidechainDepositsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListSidechainDeposits", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListSidechainDepositsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListSidechainDepositsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -659,10 +659,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListSidechainDeposits(arg0
 }
 
 // ListTransactions mocks base method.
-func (m *MockWalletManagerServiceClient) ListTransactions(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListTransactionsRequest]) (*connect.Response[walletmanagerv1.ListTransactionsResponse], error) {
+func (m *MockWalletManagerServiceClient) ListTransactions(arg0 context.Context, arg1 *walletmanagerv1.ListTransactionsRequest) (*walletmanagerv1.ListTransactionsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListTransactions", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListTransactionsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListTransactionsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -674,10 +674,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListTransactions(arg0, arg
 }
 
 // ListUnspent mocks base method.
-func (m *MockWalletManagerServiceClient) ListUnspent(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListUnspentRequest]) (*connect.Response[walletmanagerv1.ListUnspentResponse], error) {
+func (m *MockWalletManagerServiceClient) ListUnspent(arg0 context.Context, arg1 *walletmanagerv1.ListUnspentRequest) (*walletmanagerv1.ListUnspentResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListUnspent", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListUnspentResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListUnspentResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -689,10 +689,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListUnspent(arg0, arg1 any
 }
 
 // ListWalletBackups mocks base method.
-func (m *MockWalletManagerServiceClient) ListWalletBackups(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListWalletBackupsRequest]) (*connect.Response[walletmanagerv1.ListWalletBackupsResponse], error) {
+func (m *MockWalletManagerServiceClient) ListWalletBackups(arg0 context.Context, arg1 *walletmanagerv1.ListWalletBackupsRequest) (*walletmanagerv1.ListWalletBackupsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListWalletBackups", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListWalletBackupsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListWalletBackupsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -704,10 +704,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListWalletBackups(arg0, ar
 }
 
 // ListWallets mocks base method.
-func (m *MockWalletManagerServiceClient) ListWallets(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListWalletsRequest]) (*connect.Response[walletmanagerv1.ListWalletsResponse], error) {
+func (m *MockWalletManagerServiceClient) ListWallets(arg0 context.Context, arg1 *walletmanagerv1.ListWalletsRequest) (*walletmanagerv1.ListWalletsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListWallets", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListWalletsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListWalletsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -719,10 +719,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ListWallets(arg0, arg1 any
 }
 
 // LockWallet mocks base method.
-func (m *MockWalletManagerServiceClient) LockWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.LockWalletRequest]) (*connect.Response[walletmanagerv1.LockWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) LockWallet(arg0 context.Context, arg1 *walletmanagerv1.LockWalletRequest) (*walletmanagerv1.LockWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "LockWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.LockWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.LockWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -734,10 +734,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) LockWallet(arg0, arg1 any)
 }
 
 // MultisigPsbtStatus mocks base method.
-func (m *MockWalletManagerServiceClient) MultisigPsbtStatus(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.MultisigPsbtStatusRequest]) (*connect.Response[walletmanagerv1.MultisigPsbtStatusResponse], error) {
+func (m *MockWalletManagerServiceClient) MultisigPsbtStatus(arg0 context.Context, arg1 *walletmanagerv1.MultisigPsbtStatusRequest) (*walletmanagerv1.MultisigPsbtStatusResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MultisigPsbtStatus", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.MultisigPsbtStatusResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.MultisigPsbtStatusResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -749,10 +749,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) MultisigPsbtStatus(arg0, a
 }
 
 // ParseMultisigConfig mocks base method.
-func (m *MockWalletManagerServiceClient) ParseMultisigConfig(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ParseMultisigConfigRequest]) (*connect.Response[walletmanagerv1.ParseMultisigConfigResponse], error) {
+func (m *MockWalletManagerServiceClient) ParseMultisigConfig(arg0 context.Context, arg1 *walletmanagerv1.ParseMultisigConfigRequest) (*walletmanagerv1.ParseMultisigConfigResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ParseMultisigConfig", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ParseMultisigConfigResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ParseMultisigConfigResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -764,10 +764,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ParseMultisigConfig(arg0,
 }
 
 // PreviewBumpFee mocks base method.
-func (m *MockWalletManagerServiceClient) PreviewBumpFee(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PreviewBumpFeeRequest]) (*connect.Response[walletmanagerv1.PreviewBumpFeeResponse], error) {
+func (m *MockWalletManagerServiceClient) PreviewBumpFee(arg0 context.Context, arg1 *walletmanagerv1.PreviewBumpFeeRequest) (*walletmanagerv1.PreviewBumpFeeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PreviewBumpFee", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PreviewBumpFeeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PreviewBumpFeeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -779,10 +779,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) PreviewBumpFee(arg0, arg1
 }
 
 // PreviewSend mocks base method.
-func (m *MockWalletManagerServiceClient) PreviewSend(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PreviewSendRequest]) (*connect.Response[walletmanagerv1.PreviewSendResponse], error) {
+func (m *MockWalletManagerServiceClient) PreviewSend(arg0 context.Context, arg1 *walletmanagerv1.PreviewSendRequest) (*walletmanagerv1.PreviewSendResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PreviewSend", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PreviewSendResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PreviewSendResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -794,10 +794,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) PreviewSend(arg0, arg1 any
 }
 
 // PreviewWalletFromEntropy mocks base method.
-func (m *MockWalletManagerServiceClient) PreviewWalletFromEntropy(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PreviewWalletFromEntropyRequest]) (*connect.Response[walletmanagerv1.PreviewWalletFromEntropyResponse], error) {
+func (m *MockWalletManagerServiceClient) PreviewWalletFromEntropy(arg0 context.Context, arg1 *walletmanagerv1.PreviewWalletFromEntropyRequest) (*walletmanagerv1.PreviewWalletFromEntropyResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PreviewWalletFromEntropy", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PreviewWalletFromEntropyResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PreviewWalletFromEntropyResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -809,10 +809,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) PreviewWalletFromEntropy(a
 }
 
 // PromptDevicePin mocks base method.
-func (m *MockWalletManagerServiceClient) PromptDevicePin(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PromptDevicePinRequest]) (*connect.Response[walletmanagerv1.PromptDevicePinResponse], error) {
+func (m *MockWalletManagerServiceClient) PromptDevicePin(arg0 context.Context, arg1 *walletmanagerv1.PromptDevicePinRequest) (*walletmanagerv1.PromptDevicePinResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PromptDevicePin", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PromptDevicePinResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PromptDevicePinResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -824,10 +824,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) PromptDevicePin(arg0, arg1
 }
 
 // RemoveEncryption mocks base method.
-func (m *MockWalletManagerServiceClient) RemoveEncryption(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RemoveEncryptionRequest]) (*connect.Response[walletmanagerv1.RemoveEncryptionResponse], error) {
+func (m *MockWalletManagerServiceClient) RemoveEncryption(arg0 context.Context, arg1 *walletmanagerv1.RemoveEncryptionRequest) (*walletmanagerv1.RemoveEncryptionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RemoveEncryption", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.RemoveEncryptionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.RemoveEncryptionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -839,10 +839,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) RemoveEncryption(arg0, arg
 }
 
 // RescanWallet mocks base method.
-func (m *MockWalletManagerServiceClient) RescanWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RescanWalletRequest]) (*connect.Response[walletmanagerv1.RescanWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) RescanWallet(arg0 context.Context, arg1 *walletmanagerv1.RescanWalletRequest) (*walletmanagerv1.RescanWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RescanWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.RescanWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.RescanWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -854,10 +854,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) RescanWallet(arg0, arg1 an
 }
 
 // RestoreWalletBackup mocks base method.
-func (m *MockWalletManagerServiceClient) RestoreWalletBackup(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RestoreWalletBackupRequest]) (*connect.Response[walletmanagerv1.RestoreWalletBackupResponse], error) {
+func (m *MockWalletManagerServiceClient) RestoreWalletBackup(arg0 context.Context, arg1 *walletmanagerv1.RestoreWalletBackupRequest) (*walletmanagerv1.RestoreWalletBackupResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RestoreWalletBackup", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.RestoreWalletBackupResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.RestoreWalletBackupResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -869,10 +869,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) RestoreWalletBackup(arg0,
 }
 
 // RestoreWalletBackupStream mocks base method.
-func (m *MockWalletManagerServiceClient) RestoreWalletBackupStream(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RestoreWalletBackupRequest]) (*connect.ServerStreamForClient[walletmanagerv1.RestoreWalletBackupProgressResponse], error) {
+func (m *MockWalletManagerServiceClient) RestoreWalletBackupStream(arg0 context.Context, arg1 *walletmanagerv1.RestoreWalletBackupRequest) (walletmanagerv1connect.WalletManagerServiceRestoreWalletBackupStreamClientStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RestoreWalletBackupStream", arg0, arg1)
-	ret0, _ := ret[0].(*connect.ServerStreamForClient[walletmanagerv1.RestoreWalletBackupProgressResponse])
+	ret0, _ := ret[0].(walletmanagerv1connect.WalletManagerServiceRestoreWalletBackupStreamClientStream)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -884,10 +884,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) RestoreWalletBackupStream(
 }
 
 // SendDevicePin mocks base method.
-func (m *MockWalletManagerServiceClient) SendDevicePin(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SendDevicePinRequest]) (*connect.Response[walletmanagerv1.SendDevicePinResponse], error) {
+func (m *MockWalletManagerServiceClient) SendDevicePin(arg0 context.Context, arg1 *walletmanagerv1.SendDevicePinRequest) (*walletmanagerv1.SendDevicePinResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendDevicePin", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SendDevicePinResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SendDevicePinResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -899,10 +899,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SendDevicePin(arg0, arg1 a
 }
 
 // SendTransaction mocks base method.
-func (m *MockWalletManagerServiceClient) SendTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SendTransactionRequest]) (*connect.Response[walletmanagerv1.SendTransactionResponse], error) {
+func (m *MockWalletManagerServiceClient) SendTransaction(arg0 context.Context, arg1 *walletmanagerv1.SendTransactionRequest) (*walletmanagerv1.SendTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SendTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SendTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -914,10 +914,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SendTransaction(arg0, arg1
 }
 
 // SetCoreVariant mocks base method.
-func (m *MockWalletManagerServiceClient) SetCoreVariant(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetCoreVariantRequest]) (*connect.Response[walletmanagerv1.SetCoreVariantResponse], error) {
+func (m *MockWalletManagerServiceClient) SetCoreVariant(arg0 context.Context, arg1 *walletmanagerv1.SetCoreVariantRequest) (*walletmanagerv1.SetCoreVariantResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetCoreVariant", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetCoreVariantResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetCoreVariantResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -929,10 +929,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SetCoreVariant(arg0, arg1
 }
 
 // SetElectrumServer mocks base method.
-func (m *MockWalletManagerServiceClient) SetElectrumServer(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetElectrumServerRequest]) (*connect.Response[walletmanagerv1.SetElectrumServerResponse], error) {
+func (m *MockWalletManagerServiceClient) SetElectrumServer(arg0 context.Context, arg1 *walletmanagerv1.SetElectrumServerRequest) (*walletmanagerv1.SetElectrumServerResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetElectrumServer", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetElectrumServerResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetElectrumServerResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -944,10 +944,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SetElectrumServer(arg0, ar
 }
 
 // SetFrozenCoins mocks base method.
-func (m *MockWalletManagerServiceClient) SetFrozenCoins(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error) {
+func (m *MockWalletManagerServiceClient) SetFrozenCoins(arg0 context.Context, arg1 *walletmanagerv1.SetFrozenCoinsRequest) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetFrozenCoins", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[emptypb.Empty])
+	ret0, _ := ret[0].(*emptypb.Empty)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -959,10 +959,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SetFrozenCoins(arg0, arg1
 }
 
 // SetNodeMode mocks base method.
-func (m *MockWalletManagerServiceClient) SetNodeMode(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetNodeModeRequest]) (*connect.Response[walletmanagerv1.SetNodeModeResponse], error) {
+func (m *MockWalletManagerServiceClient) SetNodeMode(arg0 context.Context, arg1 *walletmanagerv1.SetNodeModeRequest) (*walletmanagerv1.SetNodeModeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetNodeMode", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetNodeModeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetNodeModeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -974,10 +974,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SetNodeMode(arg0, arg1 any
 }
 
 // SetTorConfig mocks base method.
-func (m *MockWalletManagerServiceClient) SetTorConfig(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetTorConfigRequest]) (*connect.Response[walletmanagerv1.SetTorConfigResponse], error) {
+func (m *MockWalletManagerServiceClient) SetTorConfig(arg0 context.Context, arg1 *walletmanagerv1.SetTorConfigRequest) (*walletmanagerv1.SetTorConfigResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetTorConfig", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetTorConfigResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetTorConfigResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -989,10 +989,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SetTorConfig(arg0, arg1 an
 }
 
 // SignPsbt mocks base method.
-func (m *MockWalletManagerServiceClient) SignPsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SignPsbtRequest]) (*connect.Response[walletmanagerv1.SignPsbtResponse], error) {
+func (m *MockWalletManagerServiceClient) SignPsbt(arg0 context.Context, arg1 *walletmanagerv1.SignPsbtRequest) (*walletmanagerv1.SignPsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SignPsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SignPsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SignPsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1004,10 +1004,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SignPsbt(arg0, arg1 any) *
 }
 
 // SignPsbtWithCosigner mocks base method.
-func (m *MockWalletManagerServiceClient) SignPsbtWithCosigner(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SignPsbtWithCosignerRequest]) (*connect.Response[walletmanagerv1.SignPsbtWithCosignerResponse], error) {
+func (m *MockWalletManagerServiceClient) SignPsbtWithCosigner(arg0 context.Context, arg1 *walletmanagerv1.SignPsbtWithCosignerRequest) (*walletmanagerv1.SignPsbtWithCosignerResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SignPsbtWithCosigner", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SignPsbtWithCosignerResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SignPsbtWithCosignerResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1019,10 +1019,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SignPsbtWithCosigner(arg0,
 }
 
 // SignPsbtWithDevice mocks base method.
-func (m *MockWalletManagerServiceClient) SignPsbtWithDevice(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SignPsbtWithDeviceRequest]) (*connect.Response[walletmanagerv1.SignPsbtWithDeviceResponse], error) {
+func (m *MockWalletManagerServiceClient) SignPsbtWithDevice(arg0 context.Context, arg1 *walletmanagerv1.SignPsbtWithDeviceRequest) (*walletmanagerv1.SignPsbtWithDeviceResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SignPsbtWithDevice", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SignPsbtWithDeviceResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SignPsbtWithDeviceResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1034,10 +1034,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SignPsbtWithDevice(arg0, a
 }
 
 // SwitchWallet mocks base method.
-func (m *MockWalletManagerServiceClient) SwitchWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SwitchWalletRequest]) (*connect.Response[walletmanagerv1.SwitchWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) SwitchWallet(arg0 context.Context, arg1 *walletmanagerv1.SwitchWalletRequest) (*walletmanagerv1.SwitchWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SwitchWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SwitchWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SwitchWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1049,10 +1049,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) SwitchWallet(arg0, arg1 an
 }
 
 // UnlockWallet mocks base method.
-func (m *MockWalletManagerServiceClient) UnlockWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.UnlockWalletRequest]) (*connect.Response[walletmanagerv1.UnlockWalletResponse], error) {
+func (m *MockWalletManagerServiceClient) UnlockWallet(arg0 context.Context, arg1 *walletmanagerv1.UnlockWalletRequest) (*walletmanagerv1.UnlockWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UnlockWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.UnlockWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.UnlockWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1064,10 +1064,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) UnlockWallet(arg0, arg1 an
 }
 
 // UpdateWalletMetadata mocks base method.
-func (m *MockWalletManagerServiceClient) UpdateWalletMetadata(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.UpdateWalletMetadataRequest]) (*connect.Response[walletmanagerv1.UpdateWalletMetadataResponse], error) {
+func (m *MockWalletManagerServiceClient) UpdateWalletMetadata(arg0 context.Context, arg1 *walletmanagerv1.UpdateWalletMetadataRequest) (*walletmanagerv1.UpdateWalletMetadataResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UpdateWalletMetadata", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.UpdateWalletMetadataResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.UpdateWalletMetadataResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1079,10 +1079,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) UpdateWalletMetadata(arg0,
 }
 
 // ValidateDerivationPath mocks base method.
-func (m *MockWalletManagerServiceClient) ValidateDerivationPath(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ValidateDerivationPathRequest]) (*connect.Response[walletmanagerv1.ValidateDerivationPathResponse], error) {
+func (m *MockWalletManagerServiceClient) ValidateDerivationPath(arg0 context.Context, arg1 *walletmanagerv1.ValidateDerivationPathRequest) (*walletmanagerv1.ValidateDerivationPathResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ValidateDerivationPath", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ValidateDerivationPathResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ValidateDerivationPathResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1094,10 +1094,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ValidateDerivationPath(arg
 }
 
 // ValidateDescriptor mocks base method.
-func (m *MockWalletManagerServiceClient) ValidateDescriptor(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ValidateDescriptorRequest]) (*connect.Response[walletmanagerv1.ValidateDescriptorResponse], error) {
+func (m *MockWalletManagerServiceClient) ValidateDescriptor(arg0 context.Context, arg1 *walletmanagerv1.ValidateDescriptorRequest) (*walletmanagerv1.ValidateDescriptorResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ValidateDescriptor", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ValidateDescriptorResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ValidateDescriptorResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1109,10 +1109,10 @@ func (mr *MockWalletManagerServiceClientMockRecorder) ValidateDescriptor(arg0, a
 }
 
 // WatchWalletData mocks base method.
-func (m *MockWalletManagerServiceClient) WatchWalletData(arg0 context.Context, arg1 *connect.Request[emptypb.Empty]) (*connect.ServerStreamForClient[walletmanagerv1.WatchWalletDataResponse], error) {
+func (m *MockWalletManagerServiceClient) WatchWalletData(arg0 context.Context, arg1 *emptypb.Empty) (walletmanagerv1connect.WalletManagerServiceWatchWalletDataClientStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "WatchWalletData", arg0, arg1)
-	ret0, _ := ret[0].(*connect.ServerStreamForClient[walletmanagerv1.WatchWalletDataResponse])
+	ret0, _ := ret[0].(walletmanagerv1connect.WalletManagerServiceWatchWalletDataClientStream)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1148,10 +1148,10 @@ func (m *MockWalletManagerServiceHandler) EXPECT() *MockWalletManagerServiceHand
 }
 
 // BroadcastElectrumTransaction mocks base method.
-func (m *MockWalletManagerServiceHandler) BroadcastElectrumTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.BroadcastElectrumTransactionRequest]) (*connect.Response[walletmanagerv1.BroadcastElectrumTransactionResponse], error) {
+func (m *MockWalletManagerServiceHandler) BroadcastElectrumTransaction(arg0 context.Context, arg1 *walletmanagerv1.BroadcastElectrumTransactionRequest) (*walletmanagerv1.BroadcastElectrumTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "BroadcastElectrumTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.BroadcastElectrumTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.BroadcastElectrumTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1163,10 +1163,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) BroadcastElectrumTransact
 }
 
 // BroadcastTransaction mocks base method.
-func (m *MockWalletManagerServiceHandler) BroadcastTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.BroadcastTransactionRequest]) (*connect.Response[walletmanagerv1.BroadcastTransactionResponse], error) {
+func (m *MockWalletManagerServiceHandler) BroadcastTransaction(arg0 context.Context, arg1 *walletmanagerv1.BroadcastTransactionRequest) (*walletmanagerv1.BroadcastTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "BroadcastTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.BroadcastTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.BroadcastTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1178,10 +1178,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) BroadcastTransaction(arg0
 }
 
 // BumpFee mocks base method.
-func (m *MockWalletManagerServiceHandler) BumpFee(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.BumpFeeRequest]) (*connect.Response[walletmanagerv1.BumpFeeResponse], error) {
+func (m *MockWalletManagerServiceHandler) BumpFee(arg0 context.Context, arg1 *walletmanagerv1.BumpFeeRequest) (*walletmanagerv1.BumpFeeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "BumpFee", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.BumpFeeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.BumpFeeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1193,10 +1193,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) BumpFee(arg0, arg1 any) *
 }
 
 // CancelTransaction mocks base method.
-func (m *MockWalletManagerServiceHandler) CancelTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CancelTransactionRequest]) (*connect.Response[walletmanagerv1.CancelTransactionResponse], error) {
+func (m *MockWalletManagerServiceHandler) CancelTransaction(arg0 context.Context, arg1 *walletmanagerv1.CancelTransactionRequest) (*walletmanagerv1.CancelTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CancelTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CancelTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CancelTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1208,10 +1208,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CancelTransaction(arg0, a
 }
 
 // ChangePassword mocks base method.
-func (m *MockWalletManagerServiceHandler) ChangePassword(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ChangePasswordRequest]) (*connect.Response[walletmanagerv1.ChangePasswordResponse], error) {
+func (m *MockWalletManagerServiceHandler) ChangePassword(arg0 context.Context, arg1 *walletmanagerv1.ChangePasswordRequest) (*walletmanagerv1.ChangePasswordResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ChangePassword", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ChangePasswordResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ChangePasswordResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1223,10 +1223,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ChangePassword(arg0, arg1
 }
 
 // CloseDevice mocks base method.
-func (m *MockWalletManagerServiceHandler) CloseDevice(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CloseDeviceRequest]) (*connect.Response[walletmanagerv1.CloseDeviceResponse], error) {
+func (m *MockWalletManagerServiceHandler) CloseDevice(arg0 context.Context, arg1 *walletmanagerv1.CloseDeviceRequest) (*walletmanagerv1.CloseDeviceResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseDevice", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CloseDeviceResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CloseDeviceResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1238,10 +1238,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CloseDevice(arg0, arg1 an
 }
 
 // CombinePsbt mocks base method.
-func (m *MockWalletManagerServiceHandler) CombinePsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CombinePsbtRequest]) (*connect.Response[walletmanagerv1.CombinePsbtResponse], error) {
+func (m *MockWalletManagerServiceHandler) CombinePsbt(arg0 context.Context, arg1 *walletmanagerv1.CombinePsbtRequest) (*walletmanagerv1.CombinePsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CombinePsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CombinePsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CombinePsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1253,10 +1253,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CombinePsbt(arg0, arg1 an
 }
 
 // CreateBitcoinCoreWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) CreateBitcoinCoreWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateBitcoinCoreWalletRequest]) (*connect.Response[walletmanagerv1.CreateBitcoinCoreWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) CreateBitcoinCoreWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateBitcoinCoreWalletRequest) (*walletmanagerv1.CreateBitcoinCoreWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateBitcoinCoreWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateBitcoinCoreWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateBitcoinCoreWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1268,10 +1268,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CreateBitcoinCoreWallet(a
 }
 
 // CreateCpfp mocks base method.
-func (m *MockWalletManagerServiceHandler) CreateCpfp(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateCpfpRequest]) (*connect.Response[walletmanagerv1.CreateCpfpResponse], error) {
+func (m *MockWalletManagerServiceHandler) CreateCpfp(arg0 context.Context, arg1 *walletmanagerv1.CreateCpfpRequest) (*walletmanagerv1.CreateCpfpResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateCpfp", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateCpfpResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateCpfpResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1283,10 +1283,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CreateCpfp(arg0, arg1 any
 }
 
 // CreateDeposit mocks base method.
-func (m *MockWalletManagerServiceHandler) CreateDeposit(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateDepositRequest]) (*connect.Response[walletmanagerv1.CreateDepositResponse], error) {
+func (m *MockWalletManagerServiceHandler) CreateDeposit(arg0 context.Context, arg1 *walletmanagerv1.CreateDepositRequest) (*walletmanagerv1.CreateDepositResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateDeposit", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateDepositResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateDepositResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1298,10 +1298,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CreateDeposit(arg0, arg1
 }
 
 // CreateElectrumWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) CreateElectrumWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateElectrumWalletRequest]) (*connect.Response[walletmanagerv1.CreateElectrumWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) CreateElectrumWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateElectrumWalletRequest) (*walletmanagerv1.CreateElectrumWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateElectrumWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateElectrumWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateElectrumWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1313,10 +1313,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CreateElectrumWallet(arg0
 }
 
 // CreateMultisigWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) CreateMultisigWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateMultisigWalletRequest]) (*connect.Response[walletmanagerv1.CreateMultisigWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) CreateMultisigWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateMultisigWalletRequest) (*walletmanagerv1.CreateMultisigWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateMultisigWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateMultisigWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateMultisigWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1328,10 +1328,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CreateMultisigWallet(arg0
 }
 
 // CreatePsbt mocks base method.
-func (m *MockWalletManagerServiceHandler) CreatePsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreatePsbtRequest]) (*connect.Response[walletmanagerv1.CreatePsbtResponse], error) {
+func (m *MockWalletManagerServiceHandler) CreatePsbt(arg0 context.Context, arg1 *walletmanagerv1.CreatePsbtRequest) (*walletmanagerv1.CreatePsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreatePsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreatePsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreatePsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1343,10 +1343,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CreatePsbt(arg0, arg1 any
 }
 
 // CreateWatchOnlyWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) CreateWatchOnlyWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.CreateWatchOnlyWalletRequest]) (*connect.Response[walletmanagerv1.CreateWatchOnlyWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) CreateWatchOnlyWallet(arg0 context.Context, arg1 *walletmanagerv1.CreateWatchOnlyWalletRequest) (*walletmanagerv1.CreateWatchOnlyWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateWatchOnlyWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.CreateWatchOnlyWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.CreateWatchOnlyWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1358,10 +1358,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) CreateWatchOnlyWallet(arg
 }
 
 // DecodeTransaction mocks base method.
-func (m *MockWalletManagerServiceHandler) DecodeTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DecodeTransactionRequest]) (*connect.Response[walletmanagerv1.DecodeTransactionResponse], error) {
+func (m *MockWalletManagerServiceHandler) DecodeTransaction(arg0 context.Context, arg1 *walletmanagerv1.DecodeTransactionRequest) (*walletmanagerv1.DecodeTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DecodeTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DecodeTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DecodeTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1373,10 +1373,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) DecodeTransaction(arg0, a
 }
 
 // DeleteAllWallets mocks base method.
-func (m *MockWalletManagerServiceHandler) DeleteAllWallets(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeleteAllWalletsRequest]) (*connect.Response[walletmanagerv1.DeleteAllWalletsResponse], error) {
+func (m *MockWalletManagerServiceHandler) DeleteAllWallets(arg0 context.Context, arg1 *walletmanagerv1.DeleteAllWalletsRequest) (*walletmanagerv1.DeleteAllWalletsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeleteAllWallets", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeleteAllWalletsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeleteAllWalletsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1388,10 +1388,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) DeleteAllWallets(arg0, ar
 }
 
 // DeleteWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) DeleteWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeleteWalletRequest]) (*connect.Response[walletmanagerv1.DeleteWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) DeleteWallet(arg0 context.Context, arg1 *walletmanagerv1.DeleteWalletRequest) (*walletmanagerv1.DeleteWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeleteWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeleteWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeleteWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1403,10 +1403,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) DeleteWallet(arg0, arg1 a
 }
 
 // DeriveAddresses mocks base method.
-func (m *MockWalletManagerServiceHandler) DeriveAddresses(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeriveAddressesRequest]) (*connect.Response[walletmanagerv1.DeriveAddressesResponse], error) {
+func (m *MockWalletManagerServiceHandler) DeriveAddresses(arg0 context.Context, arg1 *walletmanagerv1.DeriveAddressesRequest) (*walletmanagerv1.DeriveAddressesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeriveAddresses", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeriveAddressesResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeriveAddressesResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1418,10 +1418,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) DeriveAddresses(arg0, arg
 }
 
 // DeriveKeystore mocks base method.
-func (m *MockWalletManagerServiceHandler) DeriveKeystore(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.DeriveKeystoreRequest]) (*connect.Response[walletmanagerv1.DeriveKeystoreResponse], error) {
+func (m *MockWalletManagerServiceHandler) DeriveKeystore(arg0 context.Context, arg1 *walletmanagerv1.DeriveKeystoreRequest) (*walletmanagerv1.DeriveKeystoreResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeriveKeystore", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.DeriveKeystoreResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.DeriveKeystoreResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1433,10 +1433,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) DeriveKeystore(arg0, arg1
 }
 
 // EncryptWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) EncryptWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EncryptWalletRequest]) (*connect.Response[walletmanagerv1.EncryptWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) EncryptWallet(arg0 context.Context, arg1 *walletmanagerv1.EncryptWalletRequest) (*walletmanagerv1.EncryptWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EncryptWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EncryptWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EncryptWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1448,10 +1448,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) EncryptWallet(arg0, arg1
 }
 
 // EnsureCoreWallets mocks base method.
-func (m *MockWalletManagerServiceHandler) EnsureCoreWallets(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EnsureCoreWalletsRequest]) (*connect.Response[walletmanagerv1.EnsureCoreWalletsResponse], error) {
+func (m *MockWalletManagerServiceHandler) EnsureCoreWallets(arg0 context.Context, arg1 *walletmanagerv1.EnsureCoreWalletsRequest) (*walletmanagerv1.EnsureCoreWalletsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EnsureCoreWallets", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EnsureCoreWalletsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EnsureCoreWalletsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1463,10 +1463,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) EnsureCoreWallets(arg0, a
 }
 
 // EnumerateHardwareDevices mocks base method.
-func (m *MockWalletManagerServiceHandler) EnumerateHardwareDevices(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EnumerateHardwareDevicesRequest]) (*connect.Response[walletmanagerv1.EnumerateHardwareDevicesResponse], error) {
+func (m *MockWalletManagerServiceHandler) EnumerateHardwareDevices(arg0 context.Context, arg1 *walletmanagerv1.EnumerateHardwareDevicesRequest) (*walletmanagerv1.EnumerateHardwareDevicesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EnumerateHardwareDevices", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EnumerateHardwareDevicesResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EnumerateHardwareDevicesResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1478,10 +1478,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) EnumerateHardwareDevices(
 }
 
 // EstimateFee mocks base method.
-func (m *MockWalletManagerServiceHandler) EstimateFee(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.EstimateFeeRequest]) (*connect.Response[walletmanagerv1.EstimateFeeResponse], error) {
+func (m *MockWalletManagerServiceHandler) EstimateFee(arg0 context.Context, arg1 *walletmanagerv1.EstimateFeeRequest) (*walletmanagerv1.EstimateFeeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EstimateFee", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.EstimateFeeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.EstimateFeeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1493,10 +1493,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) EstimateFee(arg0, arg1 an
 }
 
 // FinalizePsbt mocks base method.
-func (m *MockWalletManagerServiceHandler) FinalizePsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.FinalizePsbtRequest]) (*connect.Response[walletmanagerv1.FinalizePsbtResponse], error) {
+func (m *MockWalletManagerServiceHandler) FinalizePsbt(arg0 context.Context, arg1 *walletmanagerv1.FinalizePsbtRequest) (*walletmanagerv1.FinalizePsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FinalizePsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.FinalizePsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.FinalizePsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1508,10 +1508,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) FinalizePsbt(arg0, arg1 a
 }
 
 // GenerateWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) GenerateWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GenerateWalletRequest]) (*connect.Response[walletmanagerv1.GenerateWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) GenerateWallet(arg0 context.Context, arg1 *walletmanagerv1.GenerateWalletRequest) (*walletmanagerv1.GenerateWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GenerateWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GenerateWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GenerateWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1523,10 +1523,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GenerateWallet(arg0, arg1
 }
 
 // GetAddressUnspent mocks base method.
-func (m *MockWalletManagerServiceHandler) GetAddressUnspent(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetAddressUnspentRequest]) (*connect.Response[walletmanagerv1.GetAddressUnspentResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetAddressUnspent(arg0 context.Context, arg1 *walletmanagerv1.GetAddressUnspentRequest) (*walletmanagerv1.GetAddressUnspentResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAddressUnspent", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetAddressUnspentResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetAddressUnspentResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1538,10 +1538,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetAddressUnspent(arg0, a
 }
 
 // GetBalance mocks base method.
-func (m *MockWalletManagerServiceHandler) GetBalance(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetBalanceRequest]) (*connect.Response[walletmanagerv1.GetBalanceResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetBalance(arg0 context.Context, arg1 *walletmanagerv1.GetBalanceRequest) (*walletmanagerv1.GetBalanceResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetBalance", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetBalanceResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetBalanceResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1553,10 +1553,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetBalance(arg0, arg1 any
 }
 
 // GetCoreVariant mocks base method.
-func (m *MockWalletManagerServiceHandler) GetCoreVariant(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetCoreVariantRequest]) (*connect.Response[walletmanagerv1.GetCoreVariantResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetCoreVariant(arg0 context.Context, arg1 *walletmanagerv1.GetCoreVariantRequest) (*walletmanagerv1.GetCoreVariantResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCoreVariant", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetCoreVariantResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetCoreVariantResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1568,10 +1568,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetCoreVariant(arg0, arg1
 }
 
 // GetElectrumServer mocks base method.
-func (m *MockWalletManagerServiceHandler) GetElectrumServer(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetElectrumServerRequest]) (*connect.Response[walletmanagerv1.GetElectrumServerResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetElectrumServer(arg0 context.Context, arg1 *walletmanagerv1.GetElectrumServerRequest) (*walletmanagerv1.GetElectrumServerResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetElectrumServer", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetElectrumServerResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetElectrumServerResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1583,10 +1583,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetElectrumServer(arg0, a
 }
 
 // GetHardwareXpub mocks base method.
-func (m *MockWalletManagerServiceHandler) GetHardwareXpub(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetHardwareXpubRequest]) (*connect.Response[walletmanagerv1.GetHardwareXpubResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetHardwareXpub(arg0 context.Context, arg1 *walletmanagerv1.GetHardwareXpubRequest) (*walletmanagerv1.GetHardwareXpubResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetHardwareXpub", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetHardwareXpubResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetHardwareXpubResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1598,10 +1598,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetHardwareXpub(arg0, arg
 }
 
 // GetNewAddress mocks base method.
-func (m *MockWalletManagerServiceHandler) GetNewAddress(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetNewAddressRequest]) (*connect.Response[walletmanagerv1.GetNewAddressResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetNewAddress(arg0 context.Context, arg1 *walletmanagerv1.GetNewAddressRequest) (*walletmanagerv1.GetNewAddressResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetNewAddress", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetNewAddressResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetNewAddressResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1613,10 +1613,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetNewAddress(arg0, arg1
 }
 
 // GetNodeMode mocks base method.
-func (m *MockWalletManagerServiceHandler) GetNodeMode(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetNodeModeRequest]) (*connect.Response[walletmanagerv1.GetNodeModeResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetNodeMode(arg0 context.Context, arg1 *walletmanagerv1.GetNodeModeRequest) (*walletmanagerv1.GetNodeModeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetNodeMode", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetNodeModeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetNodeModeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1628,10 +1628,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetNodeMode(arg0, arg1 an
 }
 
 // GetSidechainDepositTotals mocks base method.
-func (m *MockWalletManagerServiceHandler) GetSidechainDepositTotals(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetSidechainDepositTotalsRequest]) (*connect.Response[walletmanagerv1.GetSidechainDepositTotalsResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetSidechainDepositTotals(arg0 context.Context, arg1 *walletmanagerv1.GetSidechainDepositTotalsRequest) (*walletmanagerv1.GetSidechainDepositTotalsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSidechainDepositTotals", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetSidechainDepositTotalsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetSidechainDepositTotalsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1643,10 +1643,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetSidechainDepositTotals
 }
 
 // GetTorConfig mocks base method.
-func (m *MockWalletManagerServiceHandler) GetTorConfig(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetTorConfigRequest]) (*connect.Response[walletmanagerv1.GetTorConfigResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetTorConfig(arg0 context.Context, arg1 *walletmanagerv1.GetTorConfigRequest) (*walletmanagerv1.GetTorConfigResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetTorConfig", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetTorConfigResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetTorConfigResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1658,10 +1658,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetTorConfig(arg0, arg1 a
 }
 
 // GetTransactionDetails mocks base method.
-func (m *MockWalletManagerServiceHandler) GetTransactionDetails(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetTransactionDetailsRequest]) (*connect.Response[walletmanagerv1.GetTransactionDetailsResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetTransactionDetails(arg0 context.Context, arg1 *walletmanagerv1.GetTransactionDetailsRequest) (*walletmanagerv1.GetTransactionDetailsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetTransactionDetails", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetTransactionDetailsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetTransactionDetailsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1673,10 +1673,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetTransactionDetails(arg
 }
 
 // GetWalletSeed mocks base method.
-func (m *MockWalletManagerServiceHandler) GetWalletSeed(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetWalletSeedRequest]) (*connect.Response[walletmanagerv1.GetWalletSeedResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetWalletSeed(arg0 context.Context, arg1 *walletmanagerv1.GetWalletSeedRequest) (*walletmanagerv1.GetWalletSeedResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWalletSeed", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetWalletSeedResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetWalletSeedResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1688,10 +1688,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetWalletSeed(arg0, arg1
 }
 
 // GetWalletStatus mocks base method.
-func (m *MockWalletManagerServiceHandler) GetWalletStatus(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.GetWalletStatusRequest]) (*connect.Response[walletmanagerv1.GetWalletStatusResponse], error) {
+func (m *MockWalletManagerServiceHandler) GetWalletStatus(arg0 context.Context, arg1 *walletmanagerv1.GetWalletStatusRequest) (*walletmanagerv1.GetWalletStatusResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWalletStatus", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.GetWalletStatusResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.GetWalletStatusResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1703,10 +1703,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) GetWalletStatus(arg0, arg
 }
 
 // ListCoreVariants mocks base method.
-func (m *MockWalletManagerServiceHandler) ListCoreVariants(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListCoreVariantsRequest]) (*connect.Response[walletmanagerv1.ListCoreVariantsResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListCoreVariants(arg0 context.Context, arg1 *walletmanagerv1.ListCoreVariantsRequest) (*walletmanagerv1.ListCoreVariantsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListCoreVariants", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListCoreVariantsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListCoreVariantsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1718,10 +1718,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListCoreVariants(arg0, ar
 }
 
 // ListDerivationPaths mocks base method.
-func (m *MockWalletManagerServiceHandler) ListDerivationPaths(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListDerivationPathsRequest]) (*connect.Response[walletmanagerv1.ListDerivationPathsResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListDerivationPaths(arg0 context.Context, arg1 *walletmanagerv1.ListDerivationPathsRequest) (*walletmanagerv1.ListDerivationPathsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListDerivationPaths", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListDerivationPathsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListDerivationPathsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1733,10 +1733,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListDerivationPaths(arg0,
 }
 
 // ListReceiveAddresses mocks base method.
-func (m *MockWalletManagerServiceHandler) ListReceiveAddresses(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListReceiveAddressesRequest]) (*connect.Response[walletmanagerv1.ListReceiveAddressesResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListReceiveAddresses(arg0 context.Context, arg1 *walletmanagerv1.ListReceiveAddressesRequest) (*walletmanagerv1.ListReceiveAddressesResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListReceiveAddresses", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListReceiveAddressesResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListReceiveAddressesResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1748,10 +1748,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListReceiveAddresses(arg0
 }
 
 // ListSidechainDeposits mocks base method.
-func (m *MockWalletManagerServiceHandler) ListSidechainDeposits(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListSidechainDepositsRequest]) (*connect.Response[walletmanagerv1.ListSidechainDepositsResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListSidechainDeposits(arg0 context.Context, arg1 *walletmanagerv1.ListSidechainDepositsRequest) (*walletmanagerv1.ListSidechainDepositsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListSidechainDeposits", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListSidechainDepositsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListSidechainDepositsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1763,10 +1763,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListSidechainDeposits(arg
 }
 
 // ListTransactions mocks base method.
-func (m *MockWalletManagerServiceHandler) ListTransactions(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListTransactionsRequest]) (*connect.Response[walletmanagerv1.ListTransactionsResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListTransactions(arg0 context.Context, arg1 *walletmanagerv1.ListTransactionsRequest) (*walletmanagerv1.ListTransactionsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListTransactions", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListTransactionsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListTransactionsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1778,10 +1778,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListTransactions(arg0, ar
 }
 
 // ListUnspent mocks base method.
-func (m *MockWalletManagerServiceHandler) ListUnspent(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListUnspentRequest]) (*connect.Response[walletmanagerv1.ListUnspentResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListUnspent(arg0 context.Context, arg1 *walletmanagerv1.ListUnspentRequest) (*walletmanagerv1.ListUnspentResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListUnspent", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListUnspentResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListUnspentResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1793,10 +1793,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListUnspent(arg0, arg1 an
 }
 
 // ListWalletBackups mocks base method.
-func (m *MockWalletManagerServiceHandler) ListWalletBackups(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListWalletBackupsRequest]) (*connect.Response[walletmanagerv1.ListWalletBackupsResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListWalletBackups(arg0 context.Context, arg1 *walletmanagerv1.ListWalletBackupsRequest) (*walletmanagerv1.ListWalletBackupsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListWalletBackups", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListWalletBackupsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListWalletBackupsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1808,10 +1808,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListWalletBackups(arg0, a
 }
 
 // ListWallets mocks base method.
-func (m *MockWalletManagerServiceHandler) ListWallets(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ListWalletsRequest]) (*connect.Response[walletmanagerv1.ListWalletsResponse], error) {
+func (m *MockWalletManagerServiceHandler) ListWallets(arg0 context.Context, arg1 *walletmanagerv1.ListWalletsRequest) (*walletmanagerv1.ListWalletsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListWallets", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ListWalletsResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ListWalletsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1823,10 +1823,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ListWallets(arg0, arg1 an
 }
 
 // LockWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) LockWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.LockWalletRequest]) (*connect.Response[walletmanagerv1.LockWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) LockWallet(arg0 context.Context, arg1 *walletmanagerv1.LockWalletRequest) (*walletmanagerv1.LockWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "LockWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.LockWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.LockWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1838,10 +1838,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) LockWallet(arg0, arg1 any
 }
 
 // MultisigPsbtStatus mocks base method.
-func (m *MockWalletManagerServiceHandler) MultisigPsbtStatus(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.MultisigPsbtStatusRequest]) (*connect.Response[walletmanagerv1.MultisigPsbtStatusResponse], error) {
+func (m *MockWalletManagerServiceHandler) MultisigPsbtStatus(arg0 context.Context, arg1 *walletmanagerv1.MultisigPsbtStatusRequest) (*walletmanagerv1.MultisigPsbtStatusResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MultisigPsbtStatus", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.MultisigPsbtStatusResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.MultisigPsbtStatusResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1853,10 +1853,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) MultisigPsbtStatus(arg0,
 }
 
 // ParseMultisigConfig mocks base method.
-func (m *MockWalletManagerServiceHandler) ParseMultisigConfig(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ParseMultisigConfigRequest]) (*connect.Response[walletmanagerv1.ParseMultisigConfigResponse], error) {
+func (m *MockWalletManagerServiceHandler) ParseMultisigConfig(arg0 context.Context, arg1 *walletmanagerv1.ParseMultisigConfigRequest) (*walletmanagerv1.ParseMultisigConfigResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ParseMultisigConfig", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ParseMultisigConfigResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ParseMultisigConfigResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1868,10 +1868,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ParseMultisigConfig(arg0,
 }
 
 // PreviewBumpFee mocks base method.
-func (m *MockWalletManagerServiceHandler) PreviewBumpFee(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PreviewBumpFeeRequest]) (*connect.Response[walletmanagerv1.PreviewBumpFeeResponse], error) {
+func (m *MockWalletManagerServiceHandler) PreviewBumpFee(arg0 context.Context, arg1 *walletmanagerv1.PreviewBumpFeeRequest) (*walletmanagerv1.PreviewBumpFeeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PreviewBumpFee", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PreviewBumpFeeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PreviewBumpFeeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1883,10 +1883,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) PreviewBumpFee(arg0, arg1
 }
 
 // PreviewSend mocks base method.
-func (m *MockWalletManagerServiceHandler) PreviewSend(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PreviewSendRequest]) (*connect.Response[walletmanagerv1.PreviewSendResponse], error) {
+func (m *MockWalletManagerServiceHandler) PreviewSend(arg0 context.Context, arg1 *walletmanagerv1.PreviewSendRequest) (*walletmanagerv1.PreviewSendResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PreviewSend", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PreviewSendResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PreviewSendResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1898,10 +1898,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) PreviewSend(arg0, arg1 an
 }
 
 // PreviewWalletFromEntropy mocks base method.
-func (m *MockWalletManagerServiceHandler) PreviewWalletFromEntropy(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PreviewWalletFromEntropyRequest]) (*connect.Response[walletmanagerv1.PreviewWalletFromEntropyResponse], error) {
+func (m *MockWalletManagerServiceHandler) PreviewWalletFromEntropy(arg0 context.Context, arg1 *walletmanagerv1.PreviewWalletFromEntropyRequest) (*walletmanagerv1.PreviewWalletFromEntropyResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PreviewWalletFromEntropy", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PreviewWalletFromEntropyResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PreviewWalletFromEntropyResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1913,10 +1913,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) PreviewWalletFromEntropy(
 }
 
 // PromptDevicePin mocks base method.
-func (m *MockWalletManagerServiceHandler) PromptDevicePin(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.PromptDevicePinRequest]) (*connect.Response[walletmanagerv1.PromptDevicePinResponse], error) {
+func (m *MockWalletManagerServiceHandler) PromptDevicePin(arg0 context.Context, arg1 *walletmanagerv1.PromptDevicePinRequest) (*walletmanagerv1.PromptDevicePinResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PromptDevicePin", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.PromptDevicePinResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.PromptDevicePinResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1928,10 +1928,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) PromptDevicePin(arg0, arg
 }
 
 // RemoveEncryption mocks base method.
-func (m *MockWalletManagerServiceHandler) RemoveEncryption(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RemoveEncryptionRequest]) (*connect.Response[walletmanagerv1.RemoveEncryptionResponse], error) {
+func (m *MockWalletManagerServiceHandler) RemoveEncryption(arg0 context.Context, arg1 *walletmanagerv1.RemoveEncryptionRequest) (*walletmanagerv1.RemoveEncryptionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RemoveEncryption", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.RemoveEncryptionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.RemoveEncryptionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1943,10 +1943,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) RemoveEncryption(arg0, ar
 }
 
 // RescanWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) RescanWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RescanWalletRequest]) (*connect.Response[walletmanagerv1.RescanWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) RescanWallet(arg0 context.Context, arg1 *walletmanagerv1.RescanWalletRequest) (*walletmanagerv1.RescanWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RescanWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.RescanWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.RescanWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1958,10 +1958,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) RescanWallet(arg0, arg1 a
 }
 
 // RestoreWalletBackup mocks base method.
-func (m *MockWalletManagerServiceHandler) RestoreWalletBackup(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RestoreWalletBackupRequest]) (*connect.Response[walletmanagerv1.RestoreWalletBackupResponse], error) {
+func (m *MockWalletManagerServiceHandler) RestoreWalletBackup(arg0 context.Context, arg1 *walletmanagerv1.RestoreWalletBackupRequest) (*walletmanagerv1.RestoreWalletBackupResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RestoreWalletBackup", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.RestoreWalletBackupResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.RestoreWalletBackupResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1973,7 +1973,7 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) RestoreWalletBackup(arg0,
 }
 
 // RestoreWalletBackupStream mocks base method.
-func (m *MockWalletManagerServiceHandler) RestoreWalletBackupStream(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.RestoreWalletBackupRequest], arg2 *connect.ServerStream[walletmanagerv1.RestoreWalletBackupProgressResponse]) error {
+func (m *MockWalletManagerServiceHandler) RestoreWalletBackupStream(arg0 context.Context, arg1 *walletmanagerv1.RestoreWalletBackupRequest, arg2 walletmanagerv1connect.WalletManagerServiceRestoreWalletBackupStreamServerStream) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RestoreWalletBackupStream", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
@@ -1987,10 +1987,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) RestoreWalletBackupStream
 }
 
 // SendDevicePin mocks base method.
-func (m *MockWalletManagerServiceHandler) SendDevicePin(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SendDevicePinRequest]) (*connect.Response[walletmanagerv1.SendDevicePinResponse], error) {
+func (m *MockWalletManagerServiceHandler) SendDevicePin(arg0 context.Context, arg1 *walletmanagerv1.SendDevicePinRequest) (*walletmanagerv1.SendDevicePinResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendDevicePin", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SendDevicePinResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SendDevicePinResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2002,10 +2002,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SendDevicePin(arg0, arg1
 }
 
 // SendTransaction mocks base method.
-func (m *MockWalletManagerServiceHandler) SendTransaction(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SendTransactionRequest]) (*connect.Response[walletmanagerv1.SendTransactionResponse], error) {
+func (m *MockWalletManagerServiceHandler) SendTransaction(arg0 context.Context, arg1 *walletmanagerv1.SendTransactionRequest) (*walletmanagerv1.SendTransactionResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendTransaction", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SendTransactionResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SendTransactionResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2017,10 +2017,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SendTransaction(arg0, arg
 }
 
 // SetCoreVariant mocks base method.
-func (m *MockWalletManagerServiceHandler) SetCoreVariant(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetCoreVariantRequest]) (*connect.Response[walletmanagerv1.SetCoreVariantResponse], error) {
+func (m *MockWalletManagerServiceHandler) SetCoreVariant(arg0 context.Context, arg1 *walletmanagerv1.SetCoreVariantRequest) (*walletmanagerv1.SetCoreVariantResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetCoreVariant", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetCoreVariantResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetCoreVariantResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2032,10 +2032,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SetCoreVariant(arg0, arg1
 }
 
 // SetElectrumServer mocks base method.
-func (m *MockWalletManagerServiceHandler) SetElectrumServer(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetElectrumServerRequest]) (*connect.Response[walletmanagerv1.SetElectrumServerResponse], error) {
+func (m *MockWalletManagerServiceHandler) SetElectrumServer(arg0 context.Context, arg1 *walletmanagerv1.SetElectrumServerRequest) (*walletmanagerv1.SetElectrumServerResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetElectrumServer", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetElectrumServerResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetElectrumServerResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2047,10 +2047,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SetElectrumServer(arg0, a
 }
 
 // SetFrozenCoins mocks base method.
-func (m *MockWalletManagerServiceHandler) SetFrozenCoins(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error) {
+func (m *MockWalletManagerServiceHandler) SetFrozenCoins(arg0 context.Context, arg1 *walletmanagerv1.SetFrozenCoinsRequest) (*emptypb.Empty, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetFrozenCoins", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[emptypb.Empty])
+	ret0, _ := ret[0].(*emptypb.Empty)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2062,10 +2062,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SetFrozenCoins(arg0, arg1
 }
 
 // SetNodeMode mocks base method.
-func (m *MockWalletManagerServiceHandler) SetNodeMode(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetNodeModeRequest]) (*connect.Response[walletmanagerv1.SetNodeModeResponse], error) {
+func (m *MockWalletManagerServiceHandler) SetNodeMode(arg0 context.Context, arg1 *walletmanagerv1.SetNodeModeRequest) (*walletmanagerv1.SetNodeModeResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetNodeMode", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetNodeModeResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetNodeModeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2077,10 +2077,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SetNodeMode(arg0, arg1 an
 }
 
 // SetTorConfig mocks base method.
-func (m *MockWalletManagerServiceHandler) SetTorConfig(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SetTorConfigRequest]) (*connect.Response[walletmanagerv1.SetTorConfigResponse], error) {
+func (m *MockWalletManagerServiceHandler) SetTorConfig(arg0 context.Context, arg1 *walletmanagerv1.SetTorConfigRequest) (*walletmanagerv1.SetTorConfigResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetTorConfig", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SetTorConfigResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SetTorConfigResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2092,10 +2092,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SetTorConfig(arg0, arg1 a
 }
 
 // SignPsbt mocks base method.
-func (m *MockWalletManagerServiceHandler) SignPsbt(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SignPsbtRequest]) (*connect.Response[walletmanagerv1.SignPsbtResponse], error) {
+func (m *MockWalletManagerServiceHandler) SignPsbt(arg0 context.Context, arg1 *walletmanagerv1.SignPsbtRequest) (*walletmanagerv1.SignPsbtResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SignPsbt", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SignPsbtResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SignPsbtResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2107,10 +2107,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SignPsbt(arg0, arg1 any)
 }
 
 // SignPsbtWithCosigner mocks base method.
-func (m *MockWalletManagerServiceHandler) SignPsbtWithCosigner(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SignPsbtWithCosignerRequest]) (*connect.Response[walletmanagerv1.SignPsbtWithCosignerResponse], error) {
+func (m *MockWalletManagerServiceHandler) SignPsbtWithCosigner(arg0 context.Context, arg1 *walletmanagerv1.SignPsbtWithCosignerRequest) (*walletmanagerv1.SignPsbtWithCosignerResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SignPsbtWithCosigner", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SignPsbtWithCosignerResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SignPsbtWithCosignerResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2122,10 +2122,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SignPsbtWithCosigner(arg0
 }
 
 // SignPsbtWithDevice mocks base method.
-func (m *MockWalletManagerServiceHandler) SignPsbtWithDevice(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SignPsbtWithDeviceRequest]) (*connect.Response[walletmanagerv1.SignPsbtWithDeviceResponse], error) {
+func (m *MockWalletManagerServiceHandler) SignPsbtWithDevice(arg0 context.Context, arg1 *walletmanagerv1.SignPsbtWithDeviceRequest) (*walletmanagerv1.SignPsbtWithDeviceResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SignPsbtWithDevice", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SignPsbtWithDeviceResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SignPsbtWithDeviceResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2137,10 +2137,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SignPsbtWithDevice(arg0,
 }
 
 // SwitchWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) SwitchWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.SwitchWalletRequest]) (*connect.Response[walletmanagerv1.SwitchWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) SwitchWallet(arg0 context.Context, arg1 *walletmanagerv1.SwitchWalletRequest) (*walletmanagerv1.SwitchWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SwitchWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.SwitchWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.SwitchWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2152,10 +2152,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) SwitchWallet(arg0, arg1 a
 }
 
 // UnlockWallet mocks base method.
-func (m *MockWalletManagerServiceHandler) UnlockWallet(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.UnlockWalletRequest]) (*connect.Response[walletmanagerv1.UnlockWalletResponse], error) {
+func (m *MockWalletManagerServiceHandler) UnlockWallet(arg0 context.Context, arg1 *walletmanagerv1.UnlockWalletRequest) (*walletmanagerv1.UnlockWalletResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UnlockWallet", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.UnlockWalletResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.UnlockWalletResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2167,10 +2167,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) UnlockWallet(arg0, arg1 a
 }
 
 // UpdateWalletMetadata mocks base method.
-func (m *MockWalletManagerServiceHandler) UpdateWalletMetadata(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.UpdateWalletMetadataRequest]) (*connect.Response[walletmanagerv1.UpdateWalletMetadataResponse], error) {
+func (m *MockWalletManagerServiceHandler) UpdateWalletMetadata(arg0 context.Context, arg1 *walletmanagerv1.UpdateWalletMetadataRequest) (*walletmanagerv1.UpdateWalletMetadataResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UpdateWalletMetadata", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.UpdateWalletMetadataResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.UpdateWalletMetadataResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2182,10 +2182,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) UpdateWalletMetadata(arg0
 }
 
 // ValidateDerivationPath mocks base method.
-func (m *MockWalletManagerServiceHandler) ValidateDerivationPath(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ValidateDerivationPathRequest]) (*connect.Response[walletmanagerv1.ValidateDerivationPathResponse], error) {
+func (m *MockWalletManagerServiceHandler) ValidateDerivationPath(arg0 context.Context, arg1 *walletmanagerv1.ValidateDerivationPathRequest) (*walletmanagerv1.ValidateDerivationPathResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ValidateDerivationPath", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ValidateDerivationPathResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ValidateDerivationPathResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2197,10 +2197,10 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ValidateDerivationPath(ar
 }
 
 // ValidateDescriptor mocks base method.
-func (m *MockWalletManagerServiceHandler) ValidateDescriptor(arg0 context.Context, arg1 *connect.Request[walletmanagerv1.ValidateDescriptorRequest]) (*connect.Response[walletmanagerv1.ValidateDescriptorResponse], error) {
+func (m *MockWalletManagerServiceHandler) ValidateDescriptor(arg0 context.Context, arg1 *walletmanagerv1.ValidateDescriptorRequest) (*walletmanagerv1.ValidateDescriptorResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ValidateDescriptor", arg0, arg1)
-	ret0, _ := ret[0].(*connect.Response[walletmanagerv1.ValidateDescriptorResponse])
+	ret0, _ := ret[0].(*walletmanagerv1.ValidateDescriptorResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2212,7 +2212,7 @@ func (mr *MockWalletManagerServiceHandlerMockRecorder) ValidateDescriptor(arg0,
 }
 
 // WatchWalletData mocks base method.
-func (m *MockWalletManagerServiceHandler) WatchWalletData(arg0 context.Context, arg1 *connect.Request[emptypb.Empty], arg2 *connect.ServerStream[walletmanagerv1.WatchWalletDataResponse]) error {
+func (m *MockWalletManagerServiceHandler) WatchWalletData(arg0 context.Context, arg1 *emptypb.Empty, arg2 walletmanagerv1connect.WalletManagerServiceWatchWalletDataServerStream) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "WatchWalletData", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
diff --git a/coinnews/server/api/api.go b/coinnews/server/api/api.go
index 4852c93df2..a1755c6c77 100644
--- a/coinnews/server/api/api.go
+++ b/coinnews/server/api/api.go
@@ -11,7 +11,7 @@ import (
 	"errors"
 	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -27,49 +27,49 @@ type Handler struct {
 	Log zerolog.Logger
 }
 
-func (h *Handler) ListFrontPage(ctx context.Context, req *connect.Request[pb.ListFrontPageRequest]) (*connect.Response[pb.ListFrontPageResponse], error) {
-	filter, err := feedFilter(req.Msg.Limit, req.Msg.Offset, store.SortScoreDesc, req.Msg.Subtype, req.Msg.TopicHex)
+func (h *Handler) ListFrontPage(ctx context.Context, req *pb.ListFrontPageRequest) (*pb.ListFrontPageResponse, error) {
+	filter, err := feedFilter(req.Limit, req.Offset, store.SortScoreDesc, req.Subtype, req.TopicHex)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	items, err := store.ListFeed(ctx, h.DB, filter)
 	if err != nil {
 		return nil, h.errInternal(err)
 	}
-	return connect.NewResponse(&pb.ListFrontPageResponse{Items: marshalItems(items)}), nil
+	return &pb.ListFrontPageResponse{Items: marshalItems(items)}, nil
 }
 
-func (h *Handler) ListNewFeed(ctx context.Context, req *connect.Request[pb.ListNewFeedRequest]) (*connect.Response[pb.ListNewFeedResponse], error) {
-	filter, err := feedFilter(req.Msg.Limit, req.Msg.Offset, store.SortNewest, req.Msg.Subtype, req.Msg.TopicHex)
+func (h *Handler) ListNewFeed(ctx context.Context, req *pb.ListNewFeedRequest) (*pb.ListNewFeedResponse, error) {
+	filter, err := feedFilter(req.Limit, req.Offset, store.SortNewest, req.Subtype, req.TopicHex)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	items, err := store.ListFeed(ctx, h.DB, filter)
 	if err != nil {
 		return nil, h.errInternal(err)
 	}
-	return connect.NewResponse(&pb.ListNewFeedResponse{Items: marshalItems(items)}), nil
+	return &pb.ListNewFeedResponse{Items: marshalItems(items)}, nil
 }
 
-func (h *Handler) GetItem(ctx context.Context, req *connect.Request[pb.GetItemRequest]) (*connect.Response[pb.GetItemResponse], error) {
-	id, err := codec.ParseItemID(req.Msg.ItemIdHex)
+func (h *Handler) GetItem(ctx context.Context, req *pb.GetItemRequest) (*pb.GetItemResponse, error) {
+	id, err := codec.ParseItemID(req.ItemIdHex)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	fi, err := store.GetItem(ctx, h.DB, id)
 	if errors.Is(err, sql.ErrNoRows) {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("item %s not found", id))
+		return nil, connect.Errorf(connect.CodeNotFound, "item %s not found", id)
 	}
 	if err != nil {
 		return nil, h.errInternal(err)
 	}
-	return connect.NewResponse(&pb.GetItemResponse{Item: marshalItem(fi)}), nil
+	return &pb.GetItemResponse{Item: marshalItem(fi)}, nil
 }
 
-func (h *Handler) ListThread(ctx context.Context, req *connect.Request[pb.ListThreadRequest]) (*connect.Response[pb.ListThreadResponse], error) {
-	id, err := codec.ParseItemID(req.Msg.RootIdHex)
+func (h *Handler) ListThread(ctx context.Context, req *pb.ListThreadRequest) (*pb.ListThreadResponse, error) {
+	id, err := codec.ParseItemID(req.RootIdHex)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	rows, err := store.ListThread(ctx, h.DB, id)
 	if err != nil {
@@ -79,41 +79,41 @@ func (h *Handler) ListThread(ctx context.Context, req *connect.Request[pb.ListTh
 	for i, r := range rows {
 		out[i] = marshalComment(r)
 	}
-	return connect.NewResponse(&pb.ListThreadResponse{Comments: out}), nil
+	return &pb.ListThreadResponse{Comments: out}, nil
 }
 
-func (h *Handler) ListByAuthor(ctx context.Context, req *connect.Request[pb.ListByAuthorRequest]) (*connect.Response[pb.ListByAuthorResponse], error) {
-	xpkBytes, err := hex.DecodeString(req.Msg.AuthorXpkHex)
+func (h *Handler) ListByAuthor(ctx context.Context, req *pb.ListByAuthorRequest) (*pb.ListByAuthorResponse, error) {
+	xpkBytes, err := hex.DecodeString(req.AuthorXpkHex)
 	if err != nil || len(xpkBytes) != 32 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("author_xpk_hex must be 32 bytes hex"))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "author_xpk_hex must be 32 bytes hex")
 	}
 	var xpk [32]byte
 	copy(xpk[:], xpkBytes)
-	items, err := store.ListByAuthor(ctx, h.DB, xpk, req.Msg.Limit, req.Msg.Offset)
+	items, err := store.ListByAuthor(ctx, h.DB, xpk, req.Limit, req.Offset)
 	if err != nil {
 		return nil, h.errInternal(err)
 	}
-	return connect.NewResponse(&pb.ListByAuthorResponse{Items: marshalItems(items)}), nil
+	return &pb.ListByAuthorResponse{Items: marshalItems(items)}, nil
 }
 
-func (h *Handler) ListByTopic(ctx context.Context, req *connect.Request[pb.ListByTopicRequest]) (*connect.Response[pb.ListByTopicResponse], error) {
-	topic, err := parseTopic(req.Msg.TopicHex)
+func (h *Handler) ListByTopic(ctx context.Context, req *pb.ListByTopicRequest) (*pb.ListByTopicResponse, error) {
+	topic, err := parseTopic(req.TopicHex)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	items, err := store.ListFeed(ctx, h.DB, store.FeedFilter{
 		Topic:  &topic,
 		Sort:   store.SortNewest,
-		Limit:  req.Msg.Limit,
-		Offset: req.Msg.Offset,
+		Limit:  req.Limit,
+		Offset: req.Offset,
 	})
 	if err != nil {
 		return nil, h.errInternal(err)
 	}
-	return connect.NewResponse(&pb.ListByTopicResponse{Items: marshalItems(items)}), nil
+	return &pb.ListByTopicResponse{Items: marshalItems(items)}, nil
 }
 
-func (h *Handler) ListTopics(ctx context.Context, _ *connect.Request[emptypb.Empty]) (*connect.Response[pb.ListTopicsResponse], error) {
+func (h *Handler) ListTopics(ctx context.Context, _ *emptypb.Empty) (*pb.ListTopicsResponse, error) {
 	topics, err := store.ListTopics(ctx, h.DB)
 	if err != nil {
 		return nil, h.errInternal(err)
@@ -128,7 +128,7 @@ func (h *Handler) ListTopics(ctx context.Context, _ *connect.Request[emptypb.Emp
 			Txid:          t.TxID,
 		}
 	}
-	return connect.NewResponse(&pb.ListTopicsResponse{Topics: out}), nil
+	return &pb.ListTopicsResponse{Topics: out}, nil
 }
 
 func feedFilter(limit, offset uint32, sort store.FeedSort, sub *pb.Subtype, topicHex *string) (store.FeedFilter, error) {
@@ -208,5 +208,5 @@ func marshalComment(c store.CommentRow) *pb.Comment {
 
 func (h *Handler) errInternal(err error) error {
 	h.Log.Error().Err(err).Msg("api call failed")
-	return connect.NewError(connect.CodeInternal, errors.New("internal error"))
+	return connect.NewError(connect.CodeInternal, "internal error")
 }
diff --git a/coinnews/server/api/api_test.go b/coinnews/server/api/api_test.go
index c0ddde84e3..769777b29d 100644
--- a/coinnews/server/api/api_test.go
+++ b/coinnews/server/api/api_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -67,21 +67,21 @@ func TestHandler_ListTopicsAndFeed(t *testing.T) {
 		}},
 	}))
 
-	topicsRes, err := h.ListTopics(ctx, connect.NewRequest(&emptypb.Empty{}))
+	topicsRes, err := h.ListTopics(ctx, &emptypb.Empty{})
 	require.NoError(t, err)
-	require.Len(t, topicsRes.Msg.Topics, 1)
-	assert.Equal(t, "Bitcoin", topicsRes.Msg.Topics[0].Name)
-	assert.Equal(t, "42544321", topicsRes.Msg.Topics[0].TopicHex)
+	require.Len(t, topicsRes.Topics, 1)
+	assert.Equal(t, "Bitcoin", topicsRes.Topics[0].Name)
+	assert.Equal(t, "42544321", topicsRes.Topics[0].TopicHex)
 
-	frontRes, err := h.ListFrontPage(ctx, connect.NewRequest(&pb.ListFrontPageRequest{Limit: 10}))
+	frontRes, err := h.ListFrontPage(ctx, &pb.ListFrontPageRequest{Limit: 10})
 	require.NoError(t, err)
-	require.Len(t, frontRes.Msg.Items, 1)
-	assert.Equal(t, "hello", frontRes.Msg.Items[0].Headline)
-	assert.Equal(t, "https://example.com/x", frontRes.Msg.Items[0].Url)
+	require.Len(t, frontRes.Items, 1)
+	assert.Equal(t, "hello", frontRes.Items[0].Headline)
+	assert.Equal(t, "https://example.com/x", frontRes.Items[0].Url)
 
-	newRes, err := h.ListNewFeed(ctx, connect.NewRequest(&pb.ListNewFeedRequest{Limit: 10}))
+	newRes, err := h.ListNewFeed(ctx, &pb.ListNewFeedRequest{Limit: 10})
 	require.NoError(t, err)
-	require.Len(t, newRes.Msg.Items, 1)
+	require.Len(t, newRes.Items, 1)
 }
 
 func TestHandler_GetItem_NotFound(t *testing.T) {
@@ -89,9 +89,9 @@ func TestHandler_GetItem_NotFound(t *testing.T) {
 	h := newHandler(t)
 	missing := make([]byte, codec.ItemIDLen)
 	missing[0] = 0xde
-	_, err := h.GetItem(context.Background(), connect.NewRequest(&pb.GetItemRequest{
+	_, err := h.GetItem(context.Background(), &pb.GetItemRequest{
 		ItemIdHex: hex.EncodeToString(missing),
-	}))
+	})
 	require.Error(t, err)
 	var ce *connect.Error
 	require.ErrorAs(t, err, &ce)
@@ -101,9 +101,9 @@ func TestHandler_GetItem_NotFound(t *testing.T) {
 func TestHandler_GetItem_BadID(t *testing.T) {
 	t.Parallel()
 	h := newHandler(t)
-	_, err := h.GetItem(context.Background(), connect.NewRequest(&pb.GetItemRequest{
+	_, err := h.GetItem(context.Background(), &pb.GetItemRequest{
 		ItemIdHex: "not-hex",
-	}))
+	})
 	require.Error(t, err)
 	var ce *connect.Error
 	require.ErrorAs(t, err, &ce)
@@ -129,19 +129,19 @@ func TestHandler_GetItem_RoundTrip(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, feed, 1)
 
-	got, err := h.GetItem(ctx, connect.NewRequest(&pb.GetItemRequest{
+	got, err := h.GetItem(ctx, &pb.GetItemRequest{
 		ItemIdHex: hex.EncodeToString(feed[0].ItemID[:]),
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "hn-clone", got.Msg.Item.Headline)
+	assert.Equal(t, "hn-clone", got.Item.Headline)
 }
 
 func TestHandler_ListByAuthor_BadHex(t *testing.T) {
 	t.Parallel()
 	h := newHandler(t)
-	_, err := h.ListByAuthor(context.Background(), connect.NewRequest(&pb.ListByAuthorRequest{
+	_, err := h.ListByAuthor(context.Background(), &pb.ListByAuthorRequest{
 		AuthorXpkHex: "deadbeef", // not 32 bytes
-	}))
+	})
 	require.Error(t, err)
 	var ce *connect.Error
 	require.ErrorAs(t, err, &ce)
@@ -177,20 +177,20 @@ func TestHandler_ListByAuthor_OK(t *testing.T) {
 		},
 	}))
 
-	res, err := h.ListByAuthor(ctx, connect.NewRequest(&pb.ListByAuthorRequest{
+	res, err := h.ListByAuthor(ctx, &pb.ListByAuthorRequest{
 		AuthorXpkHex: hex.EncodeToString(xpk[:]),
 		Limit:        10,
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, res.Msg.Items, 1, "story author list pulls in stories the author commented on")
+	require.Len(t, res.Items, 1, "story author list pulls in stories the author commented on")
 }
 
 func TestHandler_ListByTopic_BadHex(t *testing.T) {
 	t.Parallel()
 	h := newHandler(t)
-	_, err := h.ListByTopic(context.Background(), connect.NewRequest(&pb.ListByTopicRequest{
+	_, err := h.ListByTopic(context.Background(), &pb.ListByTopicRequest{
 		TopicHex: "zz",
-	}))
+	})
 	require.Error(t, err)
 	var ce *connect.Error
 	require.ErrorAs(t, err, &ce)
@@ -202,10 +202,10 @@ func TestHandler_FeedBadTopicHex(t *testing.T) {
 	h := newHandler(t)
 	topicHex := "zz"
 
-	_, err := h.ListFrontPage(context.Background(), connect.NewRequest(&pb.ListFrontPageRequest{TopicHex: &topicHex}))
+	_, err := h.ListFrontPage(context.Background(), &pb.ListFrontPageRequest{TopicHex: &topicHex})
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 
-	_, err = h.ListNewFeed(context.Background(), connect.NewRequest(&pb.ListNewFeedRequest{TopicHex: &topicHex}))
+	_, err = h.ListNewFeed(context.Background(), &pb.ListNewFeedRequest{TopicHex: &topicHex})
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
 
@@ -237,12 +237,12 @@ func TestHandler_ListThread(t *testing.T) {
 		},
 	}))
 
-	res, err := h.ListThread(ctx, connect.NewRequest(&pb.ListThreadRequest{
+	res, err := h.ListThread(ctx, &pb.ListThreadRequest{
 		RootIdHex: hex.EncodeToString(feed[0].ItemID[:]),
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, res.Msg.Comments, 1)
-	assert.Equal(t, "+1", res.Msg.Comments[0].Body)
+	require.Len(t, res.Comments, 1)
+	assert.Equal(t, "+1", res.Comments[0].Body)
 }
 
 func TestHandler_InternalErrorHidesTheCause(t *testing.T) {
@@ -252,7 +252,7 @@ func TestHandler_InternalErrorHidesTheCause(t *testing.T) {
 	h.Log = zerolog.New(&logged)
 	require.NoError(t, h.DB.Close())
 
-	_, err := h.ListTopics(context.Background(), connect.NewRequest(&emptypb.Empty{}))
+	_, err := h.ListTopics(context.Background(), &emptypb.Empty{})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 	var ce *connect.Error
diff --git a/coinnews/server/buf.go.gen.yaml b/coinnews/server/buf.go.gen.yaml
index 189c6fdbc3..fd206fc72c 100644
--- a/coinnews/server/buf.go.gen.yaml
+++ b/coinnews/server/buf.go.gen.yaml
@@ -8,7 +8,7 @@ plugins:
   - remote: buf.build/protocolbuffers/go:v1.36.10
     out: gen
     opt: paths=source_relative
-  - remote: buf.build/connectrpc/go:v1.19.0
+  - remote: buf.build/connectrpc/go:v2.0.1
     out: gen
     opt: paths=source_relative
 inputs:
diff --git a/coinnews/server/gen/coinnews/v1/coinnewsv1connect/coinnews.connect.go b/coinnews/server/gen/coinnews/v1/coinnewsv1connect/coinnews.connect.go
index 3d44f87fee..820a657a61 100644
--- a/coinnews/server/gen/coinnews/v1/coinnewsv1connect/coinnews.connect.go
+++ b/coinnews/server/gen/coinnews/v1/coinnewsv1connect/coinnews.connect.go
@@ -5,293 +5,314 @@
 package coinnewsv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/coinnews/server/gen/coinnews/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// CoinNewsServiceName is the fully-qualified name of the CoinNewsService service.
 	CoinNewsServiceName = "coinnews.v1.CoinNewsService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// CoinNewsServiceListFrontPageProcedure is the fully-qualified name of the CoinNewsService's
+	// CoinNewsServiceListFrontPageProcedure is the procedure name of the CoinNewsService's
 	// ListFrontPage RPC.
 	CoinNewsServiceListFrontPageProcedure = "/coinnews.v1.CoinNewsService/ListFrontPage"
-	// CoinNewsServiceListNewFeedProcedure is the fully-qualified name of the CoinNewsService's
-	// ListNewFeed RPC.
+	// CoinNewsServiceListNewFeedProcedure is the procedure name of the CoinNewsService's ListNewFeed
+	// RPC.
 	CoinNewsServiceListNewFeedProcedure = "/coinnews.v1.CoinNewsService/ListNewFeed"
-	// CoinNewsServiceGetItemProcedure is the fully-qualified name of the CoinNewsService's GetItem RPC.
+	// CoinNewsServiceGetItemProcedure is the procedure name of the CoinNewsService's GetItem RPC.
 	CoinNewsServiceGetItemProcedure = "/coinnews.v1.CoinNewsService/GetItem"
-	// CoinNewsServiceListThreadProcedure is the fully-qualified name of the CoinNewsService's
-	// ListThread RPC.
+	// CoinNewsServiceListThreadProcedure is the procedure name of the CoinNewsService's ListThread RPC.
 	CoinNewsServiceListThreadProcedure = "/coinnews.v1.CoinNewsService/ListThread"
-	// CoinNewsServiceListByAuthorProcedure is the fully-qualified name of the CoinNewsService's
-	// ListByAuthor RPC.
+	// CoinNewsServiceListByAuthorProcedure is the procedure name of the CoinNewsService's ListByAuthor
+	// RPC.
 	CoinNewsServiceListByAuthorProcedure = "/coinnews.v1.CoinNewsService/ListByAuthor"
-	// CoinNewsServiceListByTopicProcedure is the fully-qualified name of the CoinNewsService's
-	// ListByTopic RPC.
+	// CoinNewsServiceListByTopicProcedure is the procedure name of the CoinNewsService's ListByTopic
+	// RPC.
 	CoinNewsServiceListByTopicProcedure = "/coinnews.v1.CoinNewsService/ListByTopic"
-	// CoinNewsServiceListTopicsProcedure is the fully-qualified name of the CoinNewsService's
-	// ListTopics RPC.
+	// CoinNewsServiceListTopicsProcedure is the procedure name of the CoinNewsService's ListTopics RPC.
 	CoinNewsServiceListTopicsProcedure = "/coinnews.v1.CoinNewsService/ListTopics"
 )
 
+var (
+	coinNewsServiceListFrontPageSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods().ByName("ListFrontPage"),
+			Procedure:  CoinNewsServiceListFrontPageProcedure,
+		}
+	})
+	coinNewsServiceListNewFeedSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods().ByName("ListNewFeed"),
+			Procedure:  CoinNewsServiceListNewFeedProcedure,
+		}
+	})
+	coinNewsServiceGetItemSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods().ByName("GetItem"),
+			Procedure:  CoinNewsServiceGetItemProcedure,
+		}
+	})
+	coinNewsServiceListThreadSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods().ByName("ListThread"),
+			Procedure:  CoinNewsServiceListThreadProcedure,
+		}
+	})
+	coinNewsServiceListByAuthorSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods().ByName("ListByAuthor"),
+			Procedure:  CoinNewsServiceListByAuthorProcedure,
+		}
+	})
+	coinNewsServiceListByTopicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods().ByName("ListByTopic"),
+			Procedure:  CoinNewsServiceListByTopicProcedure,
+		}
+	})
+	coinNewsServiceListTopicsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods().ByName("ListTopics"),
+			Procedure:  CoinNewsServiceListTopicsProcedure,
+		}
+	})
+)
+
 // CoinNewsServiceClient is a client for the coinnews.v1.CoinNewsService service.
 type CoinNewsServiceClient interface {
-	// List the front-page items, ranked by HN score (spec §13).
-	ListFrontPage(context.Context, *connect.Request[v1.ListFrontPageRequest]) (*connect.Response[v1.ListFrontPageResponse], error)
-	// Newest items, ordered by canonical scan order DESC.
-	ListNewFeed(context.Context, *connect.Request[v1.ListNewFeedRequest]) (*connect.Response[v1.ListNewFeedResponse], error)
-	// One item by its hex-encoded ItemID.
-	GetItem(context.Context, *connect.Request[v1.GetItemRequest]) (*connect.Response[v1.GetItemResponse], error)
-	// Every comment under a root item, depth-first.
-	ListThread(context.Context, *connect.Request[v1.ListThreadRequest]) (*connect.Response[v1.ListThreadResponse], error)
-	// Items authored by `author_xpk_hex` (32-byte x-only pubkey).
-	ListByAuthor(context.Context, *connect.Request[v1.ListByAuthorRequest]) (*connect.Response[v1.ListByAuthorResponse], error)
-	// Items in `topic_hex` (4-byte topic).
-	ListByTopic(context.Context, *connect.Request[v1.ListByTopicRequest]) (*connect.Response[v1.ListByTopicResponse], error)
-	// All known topics. Display-only metadata; topic IDs are canonical.
-	ListTopics(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error)
+	ListFrontPage(context.Context, *v1.ListFrontPageRequest) (*v1.ListFrontPageResponse, error)
+	ListNewFeed(context.Context, *v1.ListNewFeedRequest) (*v1.ListNewFeedResponse, error)
+	GetItem(context.Context, *v1.GetItemRequest) (*v1.GetItemResponse, error)
+	ListThread(context.Context, *v1.ListThreadRequest) (*v1.ListThreadResponse, error)
+	ListByAuthor(context.Context, *v1.ListByAuthorRequest) (*v1.ListByAuthorResponse, error)
+	ListByTopic(context.Context, *v1.ListByTopicRequest) (*v1.ListByTopicResponse, error)
+	ListTopics(context.Context, *emptypb.Empty) (*v1.ListTopicsResponse, error)
 }
 
-// NewCoinNewsServiceClient constructs a client for the coinnews.v1.CoinNewsService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewCoinNewsServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) CoinNewsServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	coinNewsServiceMethods := v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods()
-	return &coinNewsServiceClient{
-		listFrontPage: connect.NewClient[v1.ListFrontPageRequest, v1.ListFrontPageResponse](
-			httpClient,
-			baseURL+CoinNewsServiceListFrontPageProcedure,
-			connect.WithSchema(coinNewsServiceMethods.ByName("ListFrontPage")),
-			connect.WithClientOptions(opts...),
-		),
-		listNewFeed: connect.NewClient[v1.ListNewFeedRequest, v1.ListNewFeedResponse](
-			httpClient,
-			baseURL+CoinNewsServiceListNewFeedProcedure,
-			connect.WithSchema(coinNewsServiceMethods.ByName("ListNewFeed")),
-			connect.WithClientOptions(opts...),
-		),
-		getItem: connect.NewClient[v1.GetItemRequest, v1.GetItemResponse](
-			httpClient,
-			baseURL+CoinNewsServiceGetItemProcedure,
-			connect.WithSchema(coinNewsServiceMethods.ByName("GetItem")),
-			connect.WithClientOptions(opts...),
-		),
-		listThread: connect.NewClient[v1.ListThreadRequest, v1.ListThreadResponse](
-			httpClient,
-			baseURL+CoinNewsServiceListThreadProcedure,
-			connect.WithSchema(coinNewsServiceMethods.ByName("ListThread")),
-			connect.WithClientOptions(opts...),
-		),
-		listByAuthor: connect.NewClient[v1.ListByAuthorRequest, v1.ListByAuthorResponse](
-			httpClient,
-			baseURL+CoinNewsServiceListByAuthorProcedure,
-			connect.WithSchema(coinNewsServiceMethods.ByName("ListByAuthor")),
-			connect.WithClientOptions(opts...),
-		),
-		listByTopic: connect.NewClient[v1.ListByTopicRequest, v1.ListByTopicResponse](
-			httpClient,
-			baseURL+CoinNewsServiceListByTopicProcedure,
-			connect.WithSchema(coinNewsServiceMethods.ByName("ListByTopic")),
-			connect.WithClientOptions(opts...),
-		),
-		listTopics: connect.NewClient[emptypb.Empty, v1.ListTopicsResponse](
-			httpClient,
-			baseURL+CoinNewsServiceListTopicsProcedure,
-			connect.WithSchema(coinNewsServiceMethods.ByName("ListTopics")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// NewCoinNewsServiceClient constructs a client for the coinnews.v1.CoinNewsService service.
+// Multiple service clients may share a single connect.Client.
+func NewCoinNewsServiceClient(client *connect.Client) CoinNewsServiceClient {
+	return &coinNewsServiceClient{client: client}
 }
 
-// coinNewsServiceClient implements CoinNewsServiceClient.
-type coinNewsServiceClient struct {
-	listFrontPage *connect.Client[v1.ListFrontPageRequest, v1.ListFrontPageResponse]
-	listNewFeed   *connect.Client[v1.ListNewFeedRequest, v1.ListNewFeedResponse]
-	getItem       *connect.Client[v1.GetItemRequest, v1.GetItemResponse]
-	listThread    *connect.Client[v1.ListThreadRequest, v1.ListThreadResponse]
-	listByAuthor  *connect.Client[v1.ListByAuthorRequest, v1.ListByAuthorResponse]
-	listByTopic   *connect.Client[v1.ListByTopicRequest, v1.ListByTopicResponse]
-	listTopics    *connect.Client[emptypb.Empty, v1.ListTopicsResponse]
+// CoinNewsServiceHandler is an implementation of the coinnews.v1.CoinNewsService service.
+type CoinNewsServiceHandler interface {
+	ListFrontPage(context.Context, *v1.ListFrontPageRequest) (*v1.ListFrontPageResponse, error)
+	ListNewFeed(context.Context, *v1.ListNewFeedRequest) (*v1.ListNewFeedResponse, error)
+	GetItem(context.Context, *v1.GetItemRequest) (*v1.GetItemResponse, error)
+	ListThread(context.Context, *v1.ListThreadRequest) (*v1.ListThreadResponse, error)
+	ListByAuthor(context.Context, *v1.ListByAuthorRequest) (*v1.ListByAuthorResponse, error)
+	ListByTopic(context.Context, *v1.ListByTopicRequest) (*v1.ListByTopicResponse, error)
+	ListTopics(context.Context, *emptypb.Empty) (*v1.ListTopicsResponse, error)
 }
 
-// ListFrontPage calls coinnews.v1.CoinNewsService.ListFrontPage.
-func (c *coinNewsServiceClient) ListFrontPage(ctx context.Context, req *connect.Request[v1.ListFrontPageRequest]) (*connect.Response[v1.ListFrontPageResponse], error) {
-	return c.listFrontPage.CallUnary(ctx, req)
+// RegisterCoinNewsServiceHandler registers svc as the coinnews.v1.CoinNewsService implementation on
+// server.
+func RegisterCoinNewsServiceHandler(server *connect.Server, svc CoinNewsServiceHandler) {
+	adapter := coinNewsServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: coinNewsServiceListFrontPageSpec(), Handler: adapter.listFrontPage},
+		connect.Method{Spec: coinNewsServiceListNewFeedSpec(), Handler: adapter.listNewFeed},
+		connect.Method{Spec: coinNewsServiceGetItemSpec(), Handler: adapter.getItem},
+		connect.Method{Spec: coinNewsServiceListThreadSpec(), Handler: adapter.listThread},
+		connect.Method{Spec: coinNewsServiceListByAuthorSpec(), Handler: adapter.listByAuthor},
+		connect.Method{Spec: coinNewsServiceListByTopicSpec(), Handler: adapter.listByTopic},
+		connect.Method{Spec: coinNewsServiceListTopicsSpec(), Handler: adapter.listTopics},
+	)
 }
 
-// ListNewFeed calls coinnews.v1.CoinNewsService.ListNewFeed.
-func (c *coinNewsServiceClient) ListNewFeed(ctx context.Context, req *connect.Request[v1.ListNewFeedRequest]) (*connect.Response[v1.ListNewFeedResponse], error) {
-	return c.listNewFeed.CallUnary(ctx, req)
+// UnimplementedCoinNewsServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedCoinNewsServiceHandler struct{}
+
+func (UnimplementedCoinNewsServiceHandler) ListFrontPage(context.Context, *v1.ListFrontPageRequest) (*v1.ListFrontPageResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinnews.v1.CoinNewsService.ListFrontPage is not implemented")
 }
 
-// GetItem calls coinnews.v1.CoinNewsService.GetItem.
-func (c *coinNewsServiceClient) GetItem(ctx context.Context, req *connect.Request[v1.GetItemRequest]) (*connect.Response[v1.GetItemResponse], error) {
-	return c.getItem.CallUnary(ctx, req)
+func (UnimplementedCoinNewsServiceHandler) ListNewFeed(context.Context, *v1.ListNewFeedRequest) (*v1.ListNewFeedResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinnews.v1.CoinNewsService.ListNewFeed is not implemented")
 }
 
-// ListThread calls coinnews.v1.CoinNewsService.ListThread.
-func (c *coinNewsServiceClient) ListThread(ctx context.Context, req *connect.Request[v1.ListThreadRequest]) (*connect.Response[v1.ListThreadResponse], error) {
-	return c.listThread.CallUnary(ctx, req)
+func (UnimplementedCoinNewsServiceHandler) GetItem(context.Context, *v1.GetItemRequest) (*v1.GetItemResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinnews.v1.CoinNewsService.GetItem is not implemented")
 }
 
-// ListByAuthor calls coinnews.v1.CoinNewsService.ListByAuthor.
-func (c *coinNewsServiceClient) ListByAuthor(ctx context.Context, req *connect.Request[v1.ListByAuthorRequest]) (*connect.Response[v1.ListByAuthorResponse], error) {
-	return c.listByAuthor.CallUnary(ctx, req)
+func (UnimplementedCoinNewsServiceHandler) ListThread(context.Context, *v1.ListThreadRequest) (*v1.ListThreadResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinnews.v1.CoinNewsService.ListThread is not implemented")
 }
 
-// ListByTopic calls coinnews.v1.CoinNewsService.ListByTopic.
-func (c *coinNewsServiceClient) ListByTopic(ctx context.Context, req *connect.Request[v1.ListByTopicRequest]) (*connect.Response[v1.ListByTopicResponse], error) {
-	return c.listByTopic.CallUnary(ctx, req)
+func (UnimplementedCoinNewsServiceHandler) ListByAuthor(context.Context, *v1.ListByAuthorRequest) (*v1.ListByAuthorResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinnews.v1.CoinNewsService.ListByAuthor is not implemented")
 }
 
-// ListTopics calls coinnews.v1.CoinNewsService.ListTopics.
-func (c *coinNewsServiceClient) ListTopics(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error) {
-	return c.listTopics.CallUnary(ctx, req)
+func (UnimplementedCoinNewsServiceHandler) ListByTopic(context.Context, *v1.ListByTopicRequest) (*v1.ListByTopicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinnews.v1.CoinNewsService.ListByTopic is not implemented")
 }
 
-// CoinNewsServiceHandler is an implementation of the coinnews.v1.CoinNewsService service.
-type CoinNewsServiceHandler interface {
-	// List the front-page items, ranked by HN score (spec §13).
-	ListFrontPage(context.Context, *connect.Request[v1.ListFrontPageRequest]) (*connect.Response[v1.ListFrontPageResponse], error)
-	// Newest items, ordered by canonical scan order DESC.
-	ListNewFeed(context.Context, *connect.Request[v1.ListNewFeedRequest]) (*connect.Response[v1.ListNewFeedResponse], error)
-	// One item by its hex-encoded ItemID.
-	GetItem(context.Context, *connect.Request[v1.GetItemRequest]) (*connect.Response[v1.GetItemResponse], error)
-	// Every comment under a root item, depth-first.
-	ListThread(context.Context, *connect.Request[v1.ListThreadRequest]) (*connect.Response[v1.ListThreadResponse], error)
-	// Items authored by `author_xpk_hex` (32-byte x-only pubkey).
-	ListByAuthor(context.Context, *connect.Request[v1.ListByAuthorRequest]) (*connect.Response[v1.ListByAuthorResponse], error)
-	// Items in `topic_hex` (4-byte topic).
-	ListByTopic(context.Context, *connect.Request[v1.ListByTopicRequest]) (*connect.Response[v1.ListByTopicResponse], error)
-	// All known topics. Display-only metadata; topic IDs are canonical.
-	ListTopics(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error)
+func (UnimplementedCoinNewsServiceHandler) ListTopics(context.Context, *emptypb.Empty) (*v1.ListTopicsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinnews.v1.CoinNewsService.ListTopics is not implemented")
 }
 
-// NewCoinNewsServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewCoinNewsServiceHandler(svc CoinNewsServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	coinNewsServiceMethods := v1.File_coinnews_v1_coinnews_proto.Services().ByName("CoinNewsService").Methods()
-	coinNewsServiceListFrontPageHandler := connect.NewUnaryHandler(
-		CoinNewsServiceListFrontPageProcedure,
-		svc.ListFrontPage,
-		connect.WithSchema(coinNewsServiceMethods.ByName("ListFrontPage")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinNewsServiceListNewFeedHandler := connect.NewUnaryHandler(
-		CoinNewsServiceListNewFeedProcedure,
-		svc.ListNewFeed,
-		connect.WithSchema(coinNewsServiceMethods.ByName("ListNewFeed")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinNewsServiceGetItemHandler := connect.NewUnaryHandler(
-		CoinNewsServiceGetItemProcedure,
-		svc.GetItem,
-		connect.WithSchema(coinNewsServiceMethods.ByName("GetItem")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinNewsServiceListThreadHandler := connect.NewUnaryHandler(
-		CoinNewsServiceListThreadProcedure,
-		svc.ListThread,
-		connect.WithSchema(coinNewsServiceMethods.ByName("ListThread")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinNewsServiceListByAuthorHandler := connect.NewUnaryHandler(
-		CoinNewsServiceListByAuthorProcedure,
-		svc.ListByAuthor,
-		connect.WithSchema(coinNewsServiceMethods.ByName("ListByAuthor")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinNewsServiceListByTopicHandler := connect.NewUnaryHandler(
-		CoinNewsServiceListByTopicProcedure,
-		svc.ListByTopic,
-		connect.WithSchema(coinNewsServiceMethods.ByName("ListByTopic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinNewsServiceListTopicsHandler := connect.NewUnaryHandler(
-		CoinNewsServiceListTopicsProcedure,
-		svc.ListTopics,
-		connect.WithSchema(coinNewsServiceMethods.ByName("ListTopics")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/coinnews.v1.CoinNewsService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case CoinNewsServiceListFrontPageProcedure:
-			coinNewsServiceListFrontPageHandler.ServeHTTP(w, r)
-		case CoinNewsServiceListNewFeedProcedure:
-			coinNewsServiceListNewFeedHandler.ServeHTTP(w, r)
-		case CoinNewsServiceGetItemProcedure:
-			coinNewsServiceGetItemHandler.ServeHTTP(w, r)
-		case CoinNewsServiceListThreadProcedure:
-			coinNewsServiceListThreadHandler.ServeHTTP(w, r)
-		case CoinNewsServiceListByAuthorProcedure:
-			coinNewsServiceListByAuthorHandler.ServeHTTP(w, r)
-		case CoinNewsServiceListByTopicProcedure:
-			coinNewsServiceListByTopicHandler.ServeHTTP(w, r)
-		case CoinNewsServiceListTopicsProcedure:
-			coinNewsServiceListTopicsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type coinNewsServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedCoinNewsServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedCoinNewsServiceHandler struct{}
+func (c *coinNewsServiceClient) ListFrontPage(ctx context.Context, req *v1.ListFrontPageRequest) (*v1.ListFrontPageResponse, error) {
+	var res v1.ListFrontPageResponse
+	if err := c.client.CallUnary(ctx, coinNewsServiceListFrontPageSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinNewsServiceClient) ListNewFeed(ctx context.Context, req *v1.ListNewFeedRequest) (*v1.ListNewFeedResponse, error) {
+	var res v1.ListNewFeedResponse
+	if err := c.client.CallUnary(ctx, coinNewsServiceListNewFeedSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinNewsServiceClient) GetItem(ctx context.Context, req *v1.GetItemRequest) (*v1.GetItemResponse, error) {
+	var res v1.GetItemResponse
+	if err := c.client.CallUnary(ctx, coinNewsServiceGetItemSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinNewsServiceClient) ListThread(ctx context.Context, req *v1.ListThreadRequest) (*v1.ListThreadResponse, error) {
+	var res v1.ListThreadResponse
+	if err := c.client.CallUnary(ctx, coinNewsServiceListThreadSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinNewsServiceClient) ListByAuthor(ctx context.Context, req *v1.ListByAuthorRequest) (*v1.ListByAuthorResponse, error) {
+	var res v1.ListByAuthorResponse
+	if err := c.client.CallUnary(ctx, coinNewsServiceListByAuthorSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinNewsServiceClient) ListByTopic(ctx context.Context, req *v1.ListByTopicRequest) (*v1.ListByTopicResponse, error) {
+	var res v1.ListByTopicResponse
+	if err := c.client.CallUnary(ctx, coinNewsServiceListByTopicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedCoinNewsServiceHandler) ListFrontPage(context.Context, *connect.Request[v1.ListFrontPageRequest]) (*connect.Response[v1.ListFrontPageResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinnews.v1.CoinNewsService.ListFrontPage is not implemented"))
+func (c *coinNewsServiceClient) ListTopics(ctx context.Context, req *emptypb.Empty) (*v1.ListTopicsResponse, error) {
+	var res v1.ListTopicsResponse
+	if err := c.client.CallUnary(ctx, coinNewsServiceListTopicsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinNewsServiceHandler) ListNewFeed(context.Context, *connect.Request[v1.ListNewFeedRequest]) (*connect.Response[v1.ListNewFeedResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinnews.v1.CoinNewsService.ListNewFeed is not implemented"))
+type coinNewsServiceHandler struct{ svc CoinNewsServiceHandler }
+
+func (h coinNewsServiceHandler) listFrontPage(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListFrontPageRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListFrontPage(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinNewsServiceHandler) GetItem(context.Context, *connect.Request[v1.GetItemRequest]) (*connect.Response[v1.GetItemResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinnews.v1.CoinNewsService.GetItem is not implemented"))
+func (h coinNewsServiceHandler) listNewFeed(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListNewFeedRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListNewFeed(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinNewsServiceHandler) ListThread(context.Context, *connect.Request[v1.ListThreadRequest]) (*connect.Response[v1.ListThreadResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinnews.v1.CoinNewsService.ListThread is not implemented"))
+func (h coinNewsServiceHandler) getItem(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetItemRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetItem(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinNewsServiceHandler) ListByAuthor(context.Context, *connect.Request[v1.ListByAuthorRequest]) (*connect.Response[v1.ListByAuthorResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinnews.v1.CoinNewsService.ListByAuthor is not implemented"))
+func (h coinNewsServiceHandler) listThread(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListThreadRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListThread(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinNewsServiceHandler) ListByTopic(context.Context, *connect.Request[v1.ListByTopicRequest]) (*connect.Response[v1.ListByTopicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinnews.v1.CoinNewsService.ListByTopic is not implemented"))
+func (h coinNewsServiceHandler) listByAuthor(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListByAuthorRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListByAuthor(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinNewsServiceHandler) ListTopics(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[v1.ListTopicsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinnews.v1.CoinNewsService.ListTopics is not implemented"))
+func (h coinNewsServiceHandler) listByTopic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListByTopicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListByTopic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinNewsServiceHandler) listTopics(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTopics(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/coinnews/server/go.mod b/coinnews/server/go.mod
index e0cf288486..9fb1cb7bc5 100644
--- a/coinnews/server/go.mod
+++ b/coinnews/server/go.mod
@@ -4,13 +4,13 @@ go 1.27.0
 
 require (
 	connectrpc.com/connect v1.19.0
-	connectrpc.com/grpcreflect v1.3.0
+	connectrpc.com/connect/v2 v2.0.1
+	connectrpc.com/grpcreflect/v2 v2.0.0
 	github.com/LayerTwo-Labs/sidesail/coinnews/codec v0.0.0
 	github.com/mattn/go-sqlite3 v1.14.32
 	github.com/rs/zerolog v1.34.0
 	github.com/stretchr/testify v1.11.1
-	golang.org/x/net v0.46.0
-	google.golang.org/protobuf v1.36.10
+	google.golang.org/protobuf v1.36.11
 )
 
 require (
@@ -23,7 +23,6 @@ require (
 	github.com/mattn/go-isatty v0.0.19 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	golang.org/x/sys v0.37.0 // indirect
-	golang.org/x/text v0.30.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/coinnews/server/go.sum b/coinnews/server/go.sum
index 3bcd9982e3..527782732f 100644
--- a/coinnews/server/go.sum
+++ b/coinnews/server/go.sum
@@ -1,7 +1,9 @@
 connectrpc.com/connect v1.19.0 h1:LuqUbq01PqbtL0o7vn0WMRXzR2nNsiINe5zfcJ24pJM=
 connectrpc.com/connect v1.19.0/go.mod h1:tN20fjdGlewnSFeZxLKb0xwIZ6ozc3OQs2hTXy4du9w=
-connectrpc.com/grpcreflect v1.3.0 h1:Y4V+ACf8/vOb1XOc251Qun7jMB75gCUNw6llvB9csXc=
-connectrpc.com/grpcreflect v1.3.0/go.mod h1:nfloOtCS8VUQOQ1+GTdFzVg2CJo4ZGaat8JIovCtDYs=
+connectrpc.com/connect/v2 v2.0.1 h1:WTAycxe87UqxSM5oxS30d1dalZ+C5xz8Ec8O6zVYkHQ=
+connectrpc.com/connect/v2 v2.0.1/go.mod h1:N32OLrstcPUzkykFynnefFro3+xzSdOrZlK2jHmS/xo=
+connectrpc.com/grpcreflect/v2 v2.0.0 h1:Ah7U5kSd/kslH5KFNS8jh/e3u6UYVoX7lwkjcIfSq6A=
+connectrpc.com/grpcreflect/v2 v2.0.0/go.mod h1:V7Hj+ibxuZH3667Ng2zKKvxJQJIri20iG50vzG7i8GM=
 github.com/btcsuite/btcd/btcec/v2 v2.3.6 h1:IzlsEr9olcSRKB/n7c4351F3xHKxS2lma+1UFGCYd4E=
 github.com/btcsuite/btcd/btcec/v2 v2.3.6/go.mod h1:m22FrOAiuxl/tht9wIqAoGHcbnCCaPWyauO8y2LGGtQ=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ=
@@ -31,17 +33,13 @@ github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
 github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
-golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
 golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
-golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
-google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
-google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/coinnews/server/main.go b/coinnews/server/main.go
index 78460dc0eb..f84cd37afa 100644
--- a/coinnews/server/main.go
+++ b/coinnews/server/main.go
@@ -15,7 +15,9 @@ import (
 	"syscall"
 	"time"
 
-	"connectrpc.com/grpcreflect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
+	"connectrpc.com/grpcreflect/v2"
 	"github.com/rs/zerolog"
 
 	"github.com/LayerTwo-Labs/sidesail/coinnews/server/api"
@@ -96,21 +98,9 @@ func main() {
 		}()
 	}
 
-	mux := http.NewServeMux()
-	path, handler := connectrpc.NewCoinNewsServiceHandler(&api.Handler{DB: db, Log: log.With().Str("component", "api").Logger()})
-	mux.Handle(path, handler)
-
-	// Server reflection lets grpcurl/buf curl and other generic
-	// clients discover the service without a local copy of the proto.
-	reflector := grpcreflect.NewStaticReflector(connectrpc.CoinNewsServiceName)
-	mux.Handle(grpcreflect.NewHandlerV1(reflector))
-	mux.Handle(grpcreflect.NewHandlerV1Alpha(reflector))
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("ok\n"))
-	})
+	mux := newMux(&api.Handler{DB: db, Log: log.With().Str("component", "api").Logger()})
 
-	log.Info().Str("listen", *listen).Str("rpc_path", path).Msg("coinnews-server: starting")
+	log.Info().Str("listen", *listen).Str("rpc_path", "/"+connectrpc.CoinNewsServiceName+"/").Msg("coinnews-server: starting")
 	srv := &http.Server{
 		Addr:              *listen,
 		Handler:           corsMiddleware(mux),
@@ -133,6 +123,21 @@ func main() {
 	log.Info().Msg("coinnews-server: shutdown clean")
 }
 
+func newMux(handler *api.Handler) *http.ServeMux {
+	mux := http.NewServeMux()
+	server := connect.NewServer()
+	connectrpc.RegisterCoinNewsServiceHandler(server, handler)
+	grpcreflect.Register(server, grpcreflect.WithNamer(grpcreflect.NamerFunc(func() []string {
+		return []string{connectrpc.CoinNewsServiceName}
+	})))
+	connecthttp.Mount(mux, server, connecthttp.WithReadMaxBytes(0))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte("ok\n"))
+	})
+	return mux
+}
+
 // corsMiddleware allows the Next.js frontend (different host in
 // production) to call the RPC server in the browser. Permissive on
 // purpose — this server is read-only public data.
diff --git a/coinnews/server/main_test.go b/coinnews/server/main_test.go
index b07b09a88a..86140c696f 100644
--- a/coinnews/server/main_test.go
+++ b/coinnews/server/main_test.go
@@ -1,10 +1,21 @@
 package main
 
 import (
+	"net/http/httptest"
 	"testing"
 
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
+	"connectrpc.com/grpcreflect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/types/known/emptypb"
+
+	"github.com/LayerTwo-Labs/sidesail/coinnews/server/api"
+	pb "github.com/LayerTwo-Labs/sidesail/coinnews/server/gen/coinnews/v1"
+	"github.com/LayerTwo-Labs/sidesail/coinnews/server/gen/coinnews/v1/coinnewsv1connect"
+	"github.com/LayerTwo-Labs/sidesail/coinnews/server/store"
 )
 
 func TestEnvUintUnsetReturnsFallback(t *testing.T) {
@@ -39,3 +50,51 @@ func TestEnvUintAcceptsMaxUint32(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, uint64(4294967295), n)
 }
+
+func TestCoinNewsV1Client(t *testing.T) {
+	db, err := store.Open(t.Context(), t.TempDir()+"/coinnews.db")
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, db.Close()) })
+	server := httptest.NewUnstartedServer(corsMiddleware(newMux(&api.Handler{DB: db})))
+	server.EnableHTTP2 = true
+	server.StartTLS()
+	t.Cleanup(server.Close)
+
+	for _, protocol := range []struct {
+		name    string
+		options []connectv1.ClientOption
+	}{
+		{name: "Connect"},
+		{name: "JSON", options: []connectv1.ClientOption{connectv1.WithProtoJSON()}},
+		{name: "gRPC", options: []connectv1.ClientOption{connectv1.WithGRPC()}},
+		{name: "gRPCWeb", options: []connectv1.ClientOption{connectv1.WithGRPCWeb()}},
+	} {
+		t.Run(protocol.name, func(t *testing.T) {
+			client := connectv1.NewClient[emptypb.Empty, pb.ListTopicsResponse](
+				server.Client(), server.URL+coinnewsv1connect.CoinNewsServiceListTopicsProcedure, protocol.options...,
+			)
+			response, err := client.CallUnary(t.Context(), connectv1.NewRequest(&emptypb.Empty{}))
+			require.NoError(t, err)
+			assert.Empty(t, response.Msg.Topics)
+			assert.Equal(t, "*", response.Header().Get("Access-Control-Allow-Origin"))
+
+			author := connectv1.NewClient[pb.ListByAuthorRequest, pb.ListByAuthorResponse](
+				server.Client(), server.URL+coinnewsv1connect.CoinNewsServiceListByAuthorProcedure, protocol.options...,
+			)
+			_, err = author.CallUnary(t.Context(), connectv1.NewRequest(&pb.ListByAuthorRequest{AuthorXpkHex: "invalid"}))
+			var rpcError *connectv1.Error
+			require.ErrorAs(t, err, &rpcError)
+			assert.Equal(t, connectv1.CodeInvalidArgument, rpcError.Code())
+			assert.Equal(t, "author_xpk_hex must be 32 bytes hex", rpcError.Message())
+		})
+	}
+
+	reflection := grpcreflect.NewClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL)))
+	stream := reflection.NewStream(t.Context())
+	names, err := stream.ListServices()
+	require.NoError(t, err)
+	require.Len(t, names, 1)
+	assert.Equal(t, coinnewsv1connect.CoinNewsServiceName, string(names[0]))
+	err = stream.Close()
+	require.NoError(t, err)
+}
diff --git a/dc-hub/server/api/explorer/api_explorer.go b/dc-hub/server/api/explorer/api_explorer.go
index 93168dbfa6..e650a42b64 100644
--- a/dc-hub/server/api/explorer/api_explorer.go
+++ b/dc-hub/server/api/explorer/api_explorer.go
@@ -4,9 +4,11 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	btcpb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
 	"github.com/rs/zerolog"
@@ -75,9 +77,11 @@ type Server struct {
 	truthcoin *jsonrpc.Client
 }
 
-func (s *Server) GetChainTips(ctx context.Context, req *connect.Request[pb.GetChainTipsRequest]) (*connect.Response[pb.GetChainTipsResponse], error) {
+func (s *Server) GetChainTips(ctx context.Context, req *pb.GetChainTipsRequest) (response *pb.GetChainTipsResponse, err error) {
+	ctx, callInfo := connect.NewClientContext(ctx)
+	defer func() { err = forwardError(ctx, callInfo, err) }()
 	info, err := s.mainchain.GetBlockchainInfo(
-		ctx, connect.NewRequest(&btcpb.GetBlockchainInfoRequest{}),
+		ctx, connectv1.NewRequest(&btcpb.GetBlockchainInfoRequest{}),
 	)
 	if err != nil {
 		return nil, fmt.Errorf("get blockchain info: %w", err)
@@ -86,7 +90,7 @@ func (s *Server) GetChainTips(ctx context.Context, req *connect.Request[pb.GetCh
 	zerolog.Ctx(ctx).Debug().
 		Msgf("fetching best mainchain block: %q", info.Msg.BestBlockHash)
 
-	bestMainchainBlock, err := s.mainchain.GetBlock(ctx, connect.NewRequest(&btcpb.GetBlockRequest{
+	bestMainchainBlock, err := s.mainchain.GetBlock(ctx, connectv1.NewRequest(&btcpb.GetBlockRequest{
 		Hash:      info.Msg.BestBlockHash,
 		Verbosity: btcpb.GetBlockRequest_VERBOSITY_BLOCK_INFO,
 	}))
@@ -171,13 +175,15 @@ func (s *Server) GetChainTips(ctx context.Context, req *connect.Request[pb.GetCh
 		zerolog.Ctx(ctx).Err(err).Msg("failed to get sidechain tips")
 	}
 
-	return connect.NewResponse(res), nil
+	return res, nil
 }
 
 // ListSidechains reports BIP300 sidechain slot proposals that are still being
 // voted on, plus the sidechains that are currently activated. Everything is
 // sourced from the CUSF mainchain enforcer.
-func (s *Server) ListSidechains(ctx context.Context, req *connect.Request[pb.ListSidechainsRequest]) (*connect.Response[pb.ListSidechainsResponse], error) {
+func (s *Server) ListSidechains(ctx context.Context, req *pb.ListSidechainsRequest) (response *pb.ListSidechainsResponse, err error) {
+	ctx, callInfo := connect.NewClientContext(ctx)
+	defer func() { err = forwardError(ctx, callInfo, err) }()
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("connect to enforcer: %w", err)
@@ -188,26 +194,26 @@ func (s *Server) ListSidechains(ctx context.Context, req *connect.Request[pb.Lis
 	// in that case we leave the threshold as zero ("unknown") rather than
 	// guessing.
 	var consts *validatorpb.GetChainInfoResponse_Bip300Constants
-	if info, err := validator.GetChainInfo(ctx, connect.NewRequest(&validatorpb.GetChainInfoRequest{})); err != nil {
+	if info, err := validator.GetChainInfo(ctx, &validatorpb.GetChainInfoRequest{}); err != nil {
 		return nil, fmt.Errorf("get chain info from enforcer: %w", err)
 	} else {
-		consts = info.Msg.GetBip300Constants()
+		consts = info.GetBip300Constants()
 	}
 
-	activeResp, err := validator.GetSidechains(ctx, connect.NewRequest(&validatorpb.GetSidechainsRequest{}))
+	activeResp, err := validator.GetSidechains(ctx, &validatorpb.GetSidechainsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("list active sidechains from enforcer: %w", err)
 	}
 
-	proposalsResp, err := validator.GetSidechainProposals(ctx, connect.NewRequest(&validatorpb.GetSidechainProposalsRequest{}))
+	proposalsResp, err := validator.GetSidechainProposals(ctx, &validatorpb.GetSidechainProposalsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("list sidechain proposals from enforcer: %w", err)
 	}
 
 	res := &pb.ListSidechainsResponse{}
 
-	activeSlots := make(map[uint32]bool, len(activeResp.Msg.GetSidechains()))
-	for _, sc := range activeResp.Msg.GetSidechains() {
+	activeSlots := make(map[uint32]bool, len(activeResp.GetSidechains()))
+	for _, sc := range activeResp.GetSidechains() {
 		slot := sc.GetSidechainNumber().GetValue()
 		activeSlots[slot] = true
 		res.Active = append(res.Active, &pb.ActiveSidechain{
@@ -219,7 +225,7 @@ func (s *Server) ListSidechains(ctx context.Context, req *connect.Request[pb.Lis
 		})
 	}
 
-	for _, p := range proposalsResp.Msg.GetSidechainProposals() {
+	for _, p := range proposalsResp.GetSidechainProposals() {
 		slot := p.GetSidechainNumber().GetValue()
 		var description string
 		if v0 := p.GetDeclaration().GetV0(); v0 != nil {
@@ -237,7 +243,7 @@ func (s *Server) ListSidechains(ctx context.Context, req *connect.Request[pb.Lis
 		})
 	}
 
-	return connect.NewResponse(res), nil
+	return res, nil
 }
 
 // activationThreshold returns the number of ACKs a proposal needs to activate.
@@ -268,12 +274,12 @@ func (s *Server) sidechainActivation(ctx context.Context) (func(slot uint32) boo
 		return nil, fmt.Errorf("connect to enforcer: %w", err)
 	}
 
-	sidechains, err := validator.GetSidechains(ctx, connect.NewRequest(&validatorpb.GetSidechainsRequest{}))
+	sidechains, err := validator.GetSidechains(ctx, &validatorpb.GetSidechainsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("list active sidechains from enforcer: %w", err)
 	}
 
-	active := lo.SliceToMap(sidechains.Msg.Sidechains, func(sc *validatorpb.GetSidechainsResponse_SidechainInfo) (uint32, bool) {
+	active := lo.SliceToMap(sidechains.Sidechains, func(sc *validatorpb.GetSidechainsResponse_SidechainInfo) (uint32, bool) {
 		return sc.GetSidechainNumber().GetValue(), true
 	})
 
@@ -300,13 +306,13 @@ func (s *Server) sidechainProposals(ctx context.Context) (map[uint32]proposalSta
 	}
 
 	var consts *validatorpb.GetChainInfoResponse_Bip300Constants
-	if info, err := validator.GetChainInfo(ctx, connect.NewRequest(&validatorpb.GetChainInfoRequest{})); err != nil {
+	if info, err := validator.GetChainInfo(ctx, &validatorpb.GetChainInfoRequest{}); err != nil {
 		return nil, fmt.Errorf("get chain info from enforcer: %w", err)
 	} else {
-		consts = info.Msg.GetBip300Constants()
+		consts = info.GetBip300Constants()
 	}
 
-	proposals, err := validator.GetSidechainProposals(ctx, connect.NewRequest(&validatorpb.GetSidechainProposalsRequest{}))
+	proposals, err := validator.GetSidechainProposals(ctx, &validatorpb.GetSidechainProposalsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("list sidechain proposals from enforcer: %w", err)
 	}
@@ -314,8 +320,8 @@ func (s *Server) sidechainProposals(ctx context.Context) (map[uint32]proposalSta
 	threshold := activationThreshold(consts, false /* slot is inactive here */)
 	maxAge := proposalMaxAge(consts, false)
 
-	out := make(map[uint32]proposalStatus, len(proposals.Msg.GetSidechainProposals()))
-	for _, p := range proposals.Msg.GetSidechainProposals() {
+	out := make(map[uint32]proposalStatus, len(proposals.GetSidechainProposals()))
+	for _, p := range proposals.GetSidechainProposals() {
 		var remaining uint32
 		if age := p.GetProposalAge().GetValue(); maxAge > age {
 			remaining = maxAge - age
@@ -424,7 +430,7 @@ func (s *Server) getBestSidechainMainchainBlock(
 		return bestMainchainBlock, nil
 	}
 
-	fetched, err := s.mainchain.GetBlock(ctx, connect.NewRequest(&btcpb.GetBlockRequest{
+	fetched, err := s.mainchain.GetBlock(ctx, connectv1.NewRequest(&btcpb.GetBlockRequest{
 		Hash:      hash,
 		Verbosity: btcpb.GetBlockRequest_VERBOSITY_BLOCK_INFO,
 	}))
@@ -434,3 +440,31 @@ func (s *Server) getBestSidechainMainchainBlock(
 
 	return fetched.Msg, nil
 }
+
+func forwardError(ctx context.Context, info *connect.CallInfo, err error) error {
+	if err == nil {
+		return nil
+	}
+	if result, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range info.ResponseHeader().All() {
+			result.ResponseHeader().SetValues(key, values)
+		}
+		for key, values := range info.ResponseTrailer().All() {
+			result.ResponseTrailer().SetValues(key, values)
+		}
+	}
+	var bitcoinError *connectv1.Error
+	if !errors.As(err, &bitcoinError) {
+		return connector.ForwardError(err)
+	}
+	result := connect.NewError(connect.Code(bitcoinError.Code()), bitcoinError.Message()).WithCause(err)
+	for _, detail := range bitcoinError.Details() {
+		result = result.WithDetail(&connect.ErrorDetail{Type: detail.Type(), Value: detail.Bytes()})
+	}
+	if info, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range bitcoinError.Meta() {
+			info.ResponseHeader().SetValues(key, values)
+		}
+	}
+	return result
+}
diff --git a/dc-hub/server/api/faucet/api_faucet.go b/dc-hub/server/api/faucet/api_faucet.go
index 117568ccbc..a0aa3a5d78 100644
--- a/dc-hub/server/api/faucet/api_faucet.go
+++ b/dc-hub/server/api/faucet/api_faucet.go
@@ -2,14 +2,14 @@ package api_faucet
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"math"
 	"strings"
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	pb "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/hub/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/hub/v1/hubv1connect"
 	btcpb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
@@ -58,55 +58,55 @@ func (s *Server) resetIfWindowElapsed(now time.Time) {
 }
 
 // DispenseCoins implements faucetv1connect.FaucetServiceHandler.
-func (s *Server) DispenseCoins(ctx context.Context, c *connect.Request[pb.DispenseCoinsRequest]) (*connect.Response[pb.DispenseCoinsResponse], error) {
+func (s *Server) DispenseCoins(ctx context.Context, c *pb.DispenseCoinsRequest) (*pb.DispenseCoinsResponse, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	s.resetIfWindowElapsed(time.Now())
 
-	amount, err := s.validateDispenseArgs(c.Msg)
+	amount, err := s.validateDispenseArgs(c)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	if s.totalDispensed+amount.ToBTC() > MaxCoinsPer5Min {
-		return nil, connect.NewError(connect.CodeResourceExhausted, fmt.Errorf(
+		return nil, connect.Errorf(connect.CodeResourceExhausted,
 			"the faucet has hit its dispensation limit, try again in %s",
 			formatDuration(time.Until(s.windowEnds)),
-		))
+		)
 	}
 
-	s.recordDispensation(c.Msg.Destination, amount.ToBTC())
+	s.recordDispensation(c.Destination, amount.ToBTC())
 
-	txid, err := s.bitcoind.SendToAddress(ctx, &connect.Request[btcpb.SendToAddressRequest]{
+	txid, err := s.bitcoind.SendToAddress(ctx, &connectv1.Request[btcpb.SendToAddressRequest]{
 		Msg: &btcpb.SendToAddressRequest{
-			Address: c.Msg.Destination,
+			Address: c.Destination,
 			Amount:  amount.ToBTC(),
 			Comment: "faucet-dispensation",
 		},
 	})
 	if err != nil {
-		s.undoDispensation(c.Msg.Destination, amount.ToBTC())
+		s.undoDispensation(c.Destination, amount.ToBTC())
 	}
 
 	switch {
 	case err != nil && strings.Contains(err.Error(), "Insufficient funds"):
 		msg := "The faucet is out of funds. Please try again later."
-		return nil, connect.NewError(connect.CodeResourceExhausted, errors.New(msg))
+		return nil, connect.NewError(connect.CodeResourceExhausted, msg)
 
 	case err != nil && isInvalidAddressError(err):
 		return nil, connect.NewError(connect.CodeInvalidArgument,
-			errors.New("The bitcoin-address is not valid"))
+			"The bitcoin-address is not valid")
 
 	case err != nil:
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("dispense coins: %w", err))
+		return nil, connect.Errorf(connect.CodeInternal, "dispense coins: %s", err).WithCause(err)
 	}
 
-	fmt.Printf("sent %.8f to %s in %s\n", amount.ToBTC(), c.Msg.Destination, txid.Msg.Txid)
+	fmt.Printf("sent %.8f to %s in %s\n", amount.ToBTC(), c.Destination, txid.Msg.Txid)
 
-	return connect.NewResponse(&pb.DispenseCoinsResponse{
+	return &pb.DispenseCoinsResponse{
 		Txid: txid.Msg.Txid,
-	}), nil
+	}, nil
 }
 
 // formatDuration renders d as a user-friendly string like
@@ -168,14 +168,14 @@ func (s *Server) validateDispenseArgs(req *pb.DispenseCoinsRequest) (btcutil.Amo
 }
 
 // ListClaims implements faucetv1connect.FaucetServiceHandler.
-func (s *Server) ListClaims(ctx context.Context, req *connect.Request[pb.ListClaimsRequest]) (*connect.Response[pb.ListClaimsResponse], error) {
-	txs, err := s.bitcoind.ListTransactions(ctx, &connect.Request[btcpb.ListTransactionsRequest]{
+func (s *Server) ListClaims(ctx context.Context, req *pb.ListClaimsRequest) (*pb.ListClaimsResponse, error) {
+	txs, err := s.bitcoind.ListTransactions(ctx, &connectv1.Request[btcpb.ListTransactionsRequest]{
 		Msg: &btcpb.ListTransactionsRequest{
 			Count: 1000,
 		},
 	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("list transactions: %w", err))
+		return nil, connect.Errorf(connect.CodeInternal, "list transactions: %s", err).WithCause(err)
 	}
 
 	transactions := lo.Filter(txs.Msg.Transactions, func(tx *btcpb.GetTransactionResponse, index int) bool {
@@ -192,28 +192,28 @@ func (s *Server) ListClaims(ctx context.Context, req *connect.Request[pb.ListCla
 		return tx
 	})
 
-	return connect.NewResponse(&pb.ListClaimsResponse{
+	return &pb.ListClaimsResponse{
 		Transactions: transactions,
-	}), nil
+	}, nil
 }
 
 // GetStatus implements faucetv1connect.FaucetServiceHandler. It reports the
 // faucet's balance and whether it currently has enough funds to serve requests.
-func (s *Server) GetStatus(ctx context.Context, req *connect.Request[pb.GetStatusRequest]) (*connect.Response[pb.GetStatusResponse], error) {
+func (s *Server) GetStatus(ctx context.Context, req *pb.GetStatusRequest) (*pb.GetStatusResponse, error) {
 
 	const minHealthyBalance = 10
 
-	balances, err := s.bitcoind.GetBalances(ctx, &connect.Request[btcpb.GetBalancesRequest]{})
+	balances, err := s.bitcoind.GetBalances(ctx, &connectv1.Request[btcpb.GetBalancesRequest]{})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get balances: %w", err))
+		return nil, connect.Errorf(connect.CodeInternal, "get balances: %s", err).WithCause(err)
 	}
 
 	mine := balances.Msg.GetMine()
 	available := mine.GetTrusted()
 
-	return connect.NewResponse(&pb.GetStatusResponse{
+	return &pb.GetStatusResponse{
 		Available: available,
 		Pending:   mine.GetUntrustedPending() + mine.GetImmature(),
 		Healthy:   available > minHealthyBalance,
-	}), nil
+	}, nil
 }
diff --git a/dc-hub/server/api/faucet/api_faucet_test.go b/dc-hub/server/api/faucet/api_faucet_test.go
index 003896f709..6246823c31 100644
--- a/dc-hub/server/api/faucet/api_faucet_test.go
+++ b/dc-hub/server/api/faucet/api_faucet_test.go
@@ -4,7 +4,8 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	pb "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/hub/v1"
 	btcpb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
 	"github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
@@ -15,16 +16,16 @@ type fakeBitcoind struct {
 	sent []float64
 }
 
-func (f *fakeBitcoind) SendToAddress(_ context.Context, req *connect.Request[btcpb.SendToAddressRequest]) (*connect.Response[btcpb.SendToAddressResponse], error) {
+func (f *fakeBitcoind) SendToAddress(_ context.Context, req *connectv1.Request[btcpb.SendToAddressRequest]) (*connectv1.Response[btcpb.SendToAddressResponse], error) {
 	f.sent = append(f.sent, req.Msg.Amount)
-	return connect.NewResponse(&btcpb.SendToAddressResponse{Txid: "txid"}), nil
+	return connectv1.NewResponse(&btcpb.SendToAddressResponse{Txid: "txid"}), nil
 }
 
 func dispense(s *Server, amount float64) error {
-	_, err := s.DispenseCoins(context.Background(), connect.NewRequest(&pb.DispenseCoinsRequest{
+	_, err := s.DispenseCoins(context.Background(), &pb.DispenseCoinsRequest{
 		Destination: "bc1qdestination",
 		Amount:      amount,
-	}))
+	})
 	return err
 }
 
diff --git a/dc-hub/server/api/faucet/validation/validation.go b/dc-hub/server/api/faucet/validation/validation.go
index 8582fe19d6..b3851c5834 100644
--- a/dc-hub/server/api/faucet/validation/validation.go
+++ b/dc-hub/server/api/faucet/validation/validation.go
@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"sync"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/bufbuild/protovalidate-go"
 	"google.golang.org/protobuf/proto"
 )
@@ -27,27 +27,38 @@ func Validator() (protovalidate.Validator, error) {
 	return validator, nil
 }
 
-// Interceptor returns a Connect server interceptor that validates incoming requests,
-// returning an error if they don't comply.
-//
-// Docs: https://github.com/bufbuild/protovalidate
-func Interceptor() connect.UnaryInterceptorFunc {
-	return func(next connect.UnaryFunc) connect.UnaryFunc {
-		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
+// Interceptor checks unary request constraints.
+func Interceptor() connect.ServerInterceptor {
+	return func(next connect.ServerFunc) connect.ServerFunc {
+		return func(ctx context.Context, spec connect.Spec, stream connect.ServerStream) error {
+			if spec.StreamType != connect.StreamTypeUnary {
+				return next(ctx, spec, stream)
+			}
 			validator, err := Validator()
 			if err != nil {
-				return nil, err
+				return err
 			}
 
-			if msg, ok := req.Any().(proto.Message); ok {
-				if err := validator.Validate(msg); err != nil {
-					return nil, handleValidationError(err)
-				}
-			}
+			return next(ctx, spec, &requestStream{ServerStream: stream, validator: validator})
+		}
+	}
+}
 
-			return next(ctx, req)
+type requestStream struct {
+	connect.ServerStream
+	validator protovalidate.Validator
+}
+
+func (s *requestStream) Receive(msg any) error {
+	if err := s.ServerStream.Receive(msg); err != nil {
+		return err
+	}
+	if message, ok := msg.(proto.Message); ok {
+		if err := s.validator.Validate(message); err != nil {
+			return handleValidationError(err)
 		}
 	}
+	return nil
 }
 
 func handleValidationError(err error) error {
@@ -56,5 +67,5 @@ func handleValidationError(err error) error {
 		return err
 	}
 
-	return connect.NewError(connect.CodeInvalidArgument, validationErr)
+	return connect.NewError(connect.CodeInvalidArgument, validationErr.Error()).WithCause(validationErr)
 }
diff --git a/dc-hub/server/api/validator/api_validator.go b/dc-hub/server/api/validator/api_validator.go
index f2bc74bdbd..bde2705d1c 100644
--- a/dc-hub/server/api/validator/api_validator.go
+++ b/dc-hub/server/api/validator/api_validator.go
@@ -3,8 +3,9 @@ package validator
 import (
 	"context"
 	"errors"
+	"io"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	"github.com/LayerTwo-Labs/sidesail/dc-hub/server/connector"
 	mainchainv1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1"
@@ -30,132 +31,196 @@ type Server struct {
 }
 
 // GetBlockHeaderInfo implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetBlockHeaderInfo(ctx context.Context, req *connect.Request[mainchainv1.GetBlockHeaderInfoRequest]) (*connect.Response[mainchainv1.GetBlockHeaderInfoResponse], error) {
+func (s *Server) GetBlockHeaderInfo(ctx context.Context, req *mainchainv1.GetBlockHeaderInfoRequest) (*mainchainv1.GetBlockHeaderInfoResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetBlockHeaderInfo(ctx, req)
+	return proxyCall(ctx, req, validator.GetBlockHeaderInfo)
 }
 
 // GetBlockInfo implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetBlockInfo(ctx context.Context, req *connect.Request[mainchainv1.GetBlockInfoRequest]) (*connect.Response[mainchainv1.GetBlockInfoResponse], error) {
+func (s *Server) GetBlockInfo(ctx context.Context, req *mainchainv1.GetBlockInfoRequest) (*mainchainv1.GetBlockInfoResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetBlockInfo(ctx, req)
+	return proxyCall(ctx, req, validator.GetBlockInfo)
 }
 
 // GetBmmHStarCommitment implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetBmmHStarCommitment(ctx context.Context, req *connect.Request[mainchainv1.GetBmmHStarCommitmentRequest]) (*connect.Response[mainchainv1.GetBmmHStarCommitmentResponse], error) {
+func (s *Server) GetBmmHStarCommitment(ctx context.Context, req *mainchainv1.GetBmmHStarCommitmentRequest) (*mainchainv1.GetBmmHStarCommitmentResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetBmmHStarCommitment(ctx, req)
+	return proxyCall(ctx, req, validator.GetBmmHStarCommitment)
 }
 
 // GetChainInfo implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetChainInfo(ctx context.Context, req *connect.Request[mainchainv1.GetChainInfoRequest]) (*connect.Response[mainchainv1.GetChainInfoResponse], error) {
+func (s *Server) GetChainInfo(ctx context.Context, req *mainchainv1.GetChainInfoRequest) (*mainchainv1.GetChainInfoResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetChainInfo(ctx, req)
+	return proxyCall(ctx, req, validator.GetChainInfo)
 }
 
 // GetChainTip implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetChainTip(ctx context.Context, req *connect.Request[mainchainv1.GetChainTipRequest]) (*connect.Response[mainchainv1.GetChainTipResponse], error) {
+func (s *Server) GetChainTip(ctx context.Context, req *mainchainv1.GetChainTipRequest) (*mainchainv1.GetChainTipResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetChainTip(ctx, req)
+	return proxyCall(ctx, req, validator.GetChainTip)
 }
 
 // GetCoinbasePSBT implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetCoinbasePSBT(ctx context.Context, req *connect.Request[mainchainv1.GetCoinbasePSBTRequest]) (*connect.Response[mainchainv1.GetCoinbasePSBTResponse], error) {
+func (s *Server) GetCoinbasePSBT(ctx context.Context, req *mainchainv1.GetCoinbasePSBTRequest) (*mainchainv1.GetCoinbasePSBTResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetCoinbasePSBT(ctx, req)
+	return proxyCall(ctx, req, validator.GetCoinbasePSBT)
 }
 
 // GetCtip implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetCtip(ctx context.Context, req *connect.Request[mainchainv1.GetCtipRequest]) (*connect.Response[mainchainv1.GetCtipResponse], error) {
+func (s *Server) GetCtip(ctx context.Context, req *mainchainv1.GetCtipRequest) (*mainchainv1.GetCtipResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetCtip(ctx, req)
+	return proxyCall(ctx, req, validator.GetCtip)
 }
 
 // GetSidechainProposals implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetSidechainProposals(ctx context.Context, req *connect.Request[mainchainv1.GetSidechainProposalsRequest]) (*connect.Response[mainchainv1.GetSidechainProposalsResponse], error) {
+func (s *Server) GetSidechainProposals(ctx context.Context, req *mainchainv1.GetSidechainProposalsRequest) (*mainchainv1.GetSidechainProposalsResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetSidechainProposals(ctx, req)
+	return proxyCall(ctx, req, validator.GetSidechainProposals)
 }
 
 // GetSidechains implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetSidechains(ctx context.Context, req *connect.Request[mainchainv1.GetSidechainsRequest]) (*connect.Response[mainchainv1.GetSidechainsResponse], error) {
+func (s *Server) GetSidechains(ctx context.Context, req *mainchainv1.GetSidechainsRequest) (*mainchainv1.GetSidechainsResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetSidechains(ctx, req)
+	return proxyCall(ctx, req, validator.GetSidechains)
 }
 
 // GetTwoWayPegData implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) GetTwoWayPegData(ctx context.Context, req *connect.Request[mainchainv1.GetTwoWayPegDataRequest]) (*connect.Response[mainchainv1.GetTwoWayPegDataResponse], error) {
+func (s *Server) GetTwoWayPegData(ctx context.Context, req *mainchainv1.GetTwoWayPegDataRequest) (*mainchainv1.GetTwoWayPegDataResponse, error) {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return validator.GetTwoWayPegData(ctx, req)
+	return proxyCall(ctx, req, validator.GetTwoWayPegData)
 }
 
 // SubscribeEvents implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) SubscribeEvents(ctx context.Context, req *connect.Request[mainchainv1.SubscribeEventsRequest], stream *connect.ServerStream[mainchainv1.SubscribeEventsResponse]) error {
+func (s *Server) SubscribeEvents(ctx context.Context, req *mainchainv1.SubscribeEventsRequest, stream mainchainv1connect.ValidatorServiceSubscribeEventsServerStream) error {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return err
 	}
-	clientStream, err := validator.SubscribeEvents(ctx, req)
+	callCtx, info := clientContext(ctx)
+	clientStream, err := validator.SubscribeEvents(callCtx, req)
 	if err != nil {
-		return err
+		copyResponseMetadata(ctx, info)
+		return connector.ForwardError(err)
 	}
-	for clientStream.Receive() {
-		if err := stream.Send(clientStream.Msg()); err != nil {
-			return err
-		}
-	}
-	return clientStream.Err()
+	return forwardStream(ctx, info, clientStream, stream)
 }
 
 // SubscribeHeaderSyncProgress implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) SubscribeHeaderSyncProgress(ctx context.Context, req *connect.Request[mainchainv1.SubscribeHeaderSyncProgressRequest], stream *connect.ServerStream[mainchainv1.SubscribeHeaderSyncProgressResponse]) error {
+func (s *Server) SubscribeHeaderSyncProgress(ctx context.Context, req *mainchainv1.SubscribeHeaderSyncProgressRequest, stream mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressServerStream) error {
 	validator, err := s.validator.Get(ctx)
 	if err != nil {
 		return err
 	}
-	clientStream, err := validator.SubscribeHeaderSyncProgress(ctx, req)
+	callCtx, info := clientContext(ctx)
+	clientStream, err := validator.SubscribeHeaderSyncProgress(callCtx, req)
 	if err != nil {
-		return err
+		copyResponseMetadata(ctx, info)
+		return connector.ForwardError(err)
 	}
-	for clientStream.Receive() {
-		if err := stream.Send(clientStream.Msg()); err != nil {
-			return err
+	return forwardStream(ctx, info, clientStream, stream)
+}
+
+// Stop implements mainchainv1connect.ValidatorServiceHandler
+func (s *Server) Stop(ctx context.Context, req *mainchainv1.StopRequest) (*mainchainv1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodePermissionDenied, "this is not your enforcer, you cannot shut it down. piss off, as the brits say")
+}
+
+func clientContext(ctx context.Context) (context.Context, *connect.CallInfo) {
+	callCtx, info := connect.NewClientContext(ctx)
+	if request, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range request.RequestHeader().All() {
+			info.RequestHeader().SetValues(key, values)
 		}
 	}
-	return clientStream.Err()
+	return callCtx, info
 }
 
-// Stop implements mainchainv1connect.ValidatorServiceHandler
-func (s *Server) Stop(ctx context.Context, req *connect.Request[mainchainv1.StopRequest]) (*connect.Response[mainchainv1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodePermissionDenied, errors.New("this is not your enforcer, you cannot shut it down. piss off, as the brits say"))
+func copyResponseHeader(ctx context.Context, info *connect.CallInfo) {
+	if result, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range info.ResponseHeader().All() {
+			result.ResponseHeader().SetValues(key, values)
+		}
+	}
+}
+
+func copyResponseTrailer(ctx context.Context, info *connect.CallInfo) {
+	if result, ok := connect.CallInfoForServerContext(ctx); ok {
+		for key, values := range info.ResponseTrailer().All() {
+			result.ResponseTrailer().SetValues(key, values)
+		}
+	}
+}
+
+func copyResponseMetadata(ctx context.Context, info *connect.CallInfo) {
+	copyResponseHeader(ctx, info)
+	copyResponseTrailer(ctx, info)
+}
+
+func proxyCall[Request, Response any](ctx context.Context, req *Request, call func(context.Context, *Request) (*Response, error)) (*Response, error) {
+	callCtx, info := clientContext(ctx)
+	response, err := call(callCtx, req)
+	copyResponseMetadata(ctx, info)
+	return response, connector.ForwardError(err)
+}
+
+type streamReader[Res any] interface {
+	Receive() (*Res, error)
+	Close() error
+}
+
+type streamWriter[Res any] interface {
+	Send(*Res) error
+}
+
+// forwardStream copies the upstream header before the first message and the trailer at the end.
+func forwardStream[Res any](ctx context.Context, info *connect.CallInfo, in streamReader[Res], out streamWriter[Res]) (err error) {
+	defer func() {
+		err = errors.Join(err, in.Close())
+		copyResponseTrailer(ctx, info)
+	}()
+	for first := true; ; first = false {
+		msg, err := in.Receive()
+		if first {
+			copyResponseHeader(ctx, info)
+		}
+		if errors.Is(err, io.EOF) {
+			return nil
+		}
+		if err != nil {
+			return connector.ForwardError(err)
+		}
+		if err := out.Send(msg); err != nil {
+			return err
+		}
+	}
 }
diff --git a/dc-hub/server/api/validator/api_validator_test.go b/dc-hub/server/api/validator/api_validator_test.go
new file mode 100644
index 0000000000..02b194ca29
--- /dev/null
+++ b/dc-hub/server/api/validator/api_validator_test.go
@@ -0,0 +1,121 @@
+package validator
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	"github.com/LayerTwo-Labs/sidesail/dc-hub/server/connector"
+	mainchainv1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1"
+	"github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect"
+)
+
+type metadataValidator struct {
+	mainchainv1connect.UnimplementedValidatorServiceHandler
+	fail bool
+}
+
+func setTestMetadata(ctx context.Context) error {
+	info, ok := connect.CallInfoForServerContext(ctx)
+	if !ok {
+		return errors.New("the call info is absent")
+	}
+	info.ResponseHeader().SetValues("X-Test-Header", []string{"header one", "header two"})
+	info.ResponseTrailer().SetValues("X-Test-Trailer", []string{"trailer one", "trailer two"})
+	return nil
+}
+
+func (s metadataValidator) GetChainTip(ctx context.Context, _ *mainchainv1.GetChainTipRequest) (*mainchainv1.GetChainTipResponse, error) {
+	if err := setTestMetadata(ctx); err != nil {
+		return nil, err
+	}
+	if s.fail {
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "upstream failed")
+	}
+	return &mainchainv1.GetChainTipResponse{}, nil
+}
+
+func (s metadataValidator) SubscribeHeaderSyncProgress(ctx context.Context, _ *mainchainv1.SubscribeHeaderSyncProgressRequest, stream mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressServerStream) error {
+	if err := setTestMetadata(ctx); err != nil {
+		return err
+	}
+	if err := stream.Send(&mainchainv1.SubscribeHeaderSyncProgressResponse{CurrentHeight: wrapperspb.UInt32(42)}); err != nil {
+		return err
+	}
+	if s.fail {
+		return connect.NewError(connect.CodeFailedPrecondition, "upstream failed")
+	}
+	return nil
+}
+
+func serve(t *testing.T, handler mainchainv1connect.ValidatorServiceHandler) mainchainv1connect.ValidatorServiceClient {
+	t.Helper()
+	server := connect.NewServer()
+	mainchainv1connect.RegisterValidatorServiceHandler(server, handler)
+	mux := http.NewServeMux()
+	connecthttp.Mount(mux, server)
+	httpServer := httptest.NewServer(mux)
+	t.Cleanup(httpServer.Close)
+	return mainchainv1connect.NewValidatorServiceClient(connect.NewClient(connecthttp.NewTransport(httpServer.Client(), httpServer.URL)))
+}
+
+func metadataProxy(t *testing.T, fail bool) mainchainv1connect.ValidatorServiceClient {
+	t.Helper()
+	upstream := serve(t, metadataValidator{fail: fail})
+	validator := connector.New("validator", func(context.Context) (mainchainv1connect.ValidatorServiceClient, error) {
+		return upstream, nil
+	})
+	return serve(t, New(validator))
+}
+
+func assertTestMetadata(t *testing.T, info *connect.CallInfo) {
+	t.Helper()
+	assert.Equal(t, []string{"header one", "header two"}, info.ResponseHeader().Values("X-Test-Header"))
+	assert.Equal(t, []string{"trailer one", "trailer two"}, info.ResponseTrailer().Values("X-Test-Trailer"))
+}
+
+func TestProxyUnaryMetadata(t *testing.T) {
+	for _, fail := range []bool{false, true} {
+		t.Run(map[bool]string{false: "success", true: "failure"}[fail], func(t *testing.T) {
+			ctx, info := connect.NewClientContext(t.Context())
+			_, err := metadataProxy(t, fail).GetChainTip(ctx, &mainchainv1.GetChainTipRequest{})
+			if fail {
+				assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
+			} else {
+				require.NoError(t, err)
+			}
+			assertTestMetadata(t, info)
+		})
+	}
+}
+
+func TestProxyStreamMetadata(t *testing.T) {
+	for _, fail := range []bool{false, true} {
+		t.Run(map[bool]string{false: "success", true: "failure"}[fail], func(t *testing.T) {
+			ctx, info := connect.NewClientContext(t.Context())
+			stream, err := metadataProxy(t, fail).SubscribeHeaderSyncProgress(ctx, &mainchainv1.SubscribeHeaderSyncProgressRequest{})
+			require.NoError(t, err)
+			t.Cleanup(func() { require.NoError(t, stream.Close()) })
+
+			msg, err := stream.Receive()
+			require.NoError(t, err)
+			assert.Equal(t, uint32(42), msg.GetCurrentHeight().GetValue())
+			_, err = stream.Receive()
+			if fail {
+				assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
+			} else {
+				require.ErrorIs(t, err, io.EOF)
+			}
+			assertTestMetadata(t, info)
+		})
+	}
+}
diff --git a/dc-hub/server/buf.go.gen.yaml b/dc-hub/server/buf.go.gen.yaml
index 44005fb3ff..4b80b7873f 100644
--- a/dc-hub/server/buf.go.gen.yaml
+++ b/dc-hub/server/buf.go.gen.yaml
@@ -15,14 +15,14 @@ managed:
 
 plugins:
   # Base types for Go. Generates message and enum types.
-  - remote: buf.build/protocolbuffers/go
+  - remote: buf.build/protocolbuffers/go:v1.36.11
     out: gen
     opt:
       - paths=source_relative
 
   # Generates client and server stubs for connectrpc.com/connect.
   # Compatible with the gRPC, gRPC-Web, and Connect RPC protocols.
-  - remote: buf.build/connectrpc/go
+  - remote: buf.build/connectrpc/go:v2.0.1
     out: gen
     opt:
       - paths=source_relative
diff --git a/dc-hub/server/connector/connector.go b/dc-hub/server/connector/connector.go
index 8f26d707eb..4000d8029d 100644
--- a/dc-hub/server/connector/connector.go
+++ b/dc-hub/server/connector/connector.go
@@ -2,10 +2,10 @@ package connector
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"sync"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 )
 
@@ -51,10 +51,10 @@ func (s *Service[T]) Connect(ctx context.Context) (T, error) {
 	if err != nil {
 		s.setConnected(ctx, false)
 		var zero T
-		return zero, connect.NewError(
+		return zero, connect.Errorf(
 			connect.CodeUnavailable,
-			fmt.Errorf("%s does not accept connections: %w", s.name, err),
-		)
+			"%s does not accept connections: %s", s.name, err,
+		).WithCause(err)
 	} else {
 		s.mu.Lock()
 		s.client = client
@@ -75,3 +75,16 @@ func (s *Service[T]) setConnected(ctx context.Context, val bool) {
 			Msgf("%s changed connected to: %t", s.name, val)
 	}
 }
+
+// ForwardError keeps a remote RPC error public at a proxy route.
+func ForwardError(err error) error {
+	var remote *connect.Error
+	if !errors.As(err, &remote) || !remote.IsRemote() {
+		return err
+	}
+	result := connect.NewError(remote.Code(), remote.Message()).WithCause(err)
+	for _, detail := range remote.Details() {
+		result = result.WithDetail(detail)
+	}
+	return result
+}
diff --git a/dc-hub/server/dial/dial.go b/dc-hub/server/dial/dial.go
index 85a0a1079a..dd86f555bc 100644
--- a/dc-hub/server/dial/dial.go
+++ b/dc-hub/server/dial/dial.go
@@ -10,7 +10,8 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	validatordpb "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1"
 	validatordrpc "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect"
 	"github.com/rs/zerolog"
@@ -25,10 +26,10 @@ func EnforcerValidator(ctx context.Context, url string) (
 		return nil, errors.New("empty validator url")
 	}
 
-	client := validatordrpc.NewValidatorServiceClient(
-		getSharedClient(ctx), url, connect.WithGRPC(),
-	)
-	_, err := client.GetSidechains(ctx, connect.NewRequest(&validatordpb.GetSidechainsRequest{}))
+	client := validatordrpc.NewValidatorServiceClient(connect.NewClient(connecthttp.NewTransport(
+		getSharedClient(ctx), url, connecthttp.WithReadMaxBytes(0), connecthttp.WithGRPC(),
+	)))
+	_, err := client.GetSidechains(ctx, &validatordpb.GetSidechainsRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("validator: get sidechains: %w", err)
 	}
diff --git a/dc-hub/server/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go b/dc-hub/server/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go
index fd79d8e151..35b015aec7 100644
--- a/dc-hub/server/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go
+++ b/dc-hub/server/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go
@@ -1,5 +1,3 @@
-// CUSF crypto service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/crypto/v1/crypto.proto
@@ -7,220 +5,240 @@
 package cryptov1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/crypto/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// CryptoServiceName is the fully-qualified name of the CryptoService service.
 	CryptoServiceName = "cusf.crypto.v1.CryptoService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// CryptoServiceHmacSha512Procedure is the fully-qualified name of the CryptoService's HmacSha512
-	// RPC.
+	// CryptoServiceHmacSha512Procedure is the procedure name of the CryptoService's HmacSha512 RPC.
 	CryptoServiceHmacSha512Procedure = "/cusf.crypto.v1.CryptoService/HmacSha512"
-	// CryptoServiceRipemd160Procedure is the fully-qualified name of the CryptoService's Ripemd160 RPC.
+	// CryptoServiceRipemd160Procedure is the procedure name of the CryptoService's Ripemd160 RPC.
 	CryptoServiceRipemd160Procedure = "/cusf.crypto.v1.CryptoService/Ripemd160"
-	// CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure is the fully-qualified name of the
-	// CryptoService's Secp256k1SecretKeyToPublicKey RPC.
+	// CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure is the procedure name of the CryptoService's
+	// Secp256k1SecretKeyToPublicKey RPC.
 	CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure = "/cusf.crypto.v1.CryptoService/Secp256k1SecretKeyToPublicKey"
-	// CryptoServiceSecp256K1SignProcedure is the fully-qualified name of the CryptoService's
-	// Secp256k1Sign RPC.
+	// CryptoServiceSecp256K1SignProcedure is the procedure name of the CryptoService's Secp256k1Sign
+	// RPC.
 	CryptoServiceSecp256K1SignProcedure = "/cusf.crypto.v1.CryptoService/Secp256k1Sign"
-	// CryptoServiceSecp256K1VerifyProcedure is the fully-qualified name of the CryptoService's
+	// CryptoServiceSecp256K1VerifyProcedure is the procedure name of the CryptoService's
 	// Secp256k1Verify RPC.
 	CryptoServiceSecp256K1VerifyProcedure = "/cusf.crypto.v1.CryptoService/Secp256k1Verify"
 )
 
+var (
+	cryptoServiceHmacSha512Spec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("HmacSha512"),
+			Procedure:  CryptoServiceHmacSha512Procedure,
+		}
+	})
+	cryptoServiceRipemd160Spec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Ripemd160"),
+			Procedure:  CryptoServiceRipemd160Procedure,
+		}
+	})
+	cryptoServiceSecp256K1SecretKeyToPublicKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Secp256k1SecretKeyToPublicKey"),
+			Procedure:  CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure,
+		}
+	})
+	cryptoServiceSecp256K1SignSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Secp256k1Sign"),
+			Procedure:  CryptoServiceSecp256K1SignProcedure,
+		}
+	})
+	cryptoServiceSecp256K1VerifySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Secp256k1Verify"),
+			Procedure:  CryptoServiceSecp256K1VerifyProcedure,
+		}
+	})
+)
+
 // CryptoServiceClient is a client for the cusf.crypto.v1.CryptoService service.
 type CryptoServiceClient interface {
-	HmacSha512(context.Context, *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error)
-	Ripemd160(context.Context, *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error)
-	Secp256K1SecretKeyToPublicKey(context.Context, *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error)
-	Secp256K1Sign(context.Context, *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error)
-	Secp256K1Verify(context.Context, *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error)
+	HmacSha512(context.Context, *v1.HmacSha512Request) (*v1.HmacSha512Response, error)
+	Ripemd160(context.Context, *v1.Ripemd160Request) (*v1.Ripemd160Response, error)
+	Secp256K1SecretKeyToPublicKey(context.Context, *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error)
+	Secp256K1Sign(context.Context, *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error)
+	Secp256K1Verify(context.Context, *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error)
 }
 
-// NewCryptoServiceClient constructs a client for the cusf.crypto.v1.CryptoService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewCryptoServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) CryptoServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	cryptoServiceMethods := v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods()
-	return &cryptoServiceClient{
-		hmacSha512: connect.NewClient[v1.HmacSha512Request, v1.HmacSha512Response](
-			httpClient,
-			baseURL+CryptoServiceHmacSha512Procedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("HmacSha512")),
-			connect.WithClientOptions(opts...),
-		),
-		ripemd160: connect.NewClient[v1.Ripemd160Request, v1.Ripemd160Response](
-			httpClient,
-			baseURL+CryptoServiceRipemd160Procedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Ripemd160")),
-			connect.WithClientOptions(opts...),
-		),
-		secp256K1SecretKeyToPublicKey: connect.NewClient[v1.Secp256K1SecretKeyToPublicKeyRequest, v1.Secp256K1SecretKeyToPublicKeyResponse](
-			httpClient,
-			baseURL+CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1SecretKeyToPublicKey")),
-			connect.WithClientOptions(opts...),
-		),
-		secp256K1Sign: connect.NewClient[v1.Secp256K1SignRequest, v1.Secp256K1SignResponse](
-			httpClient,
-			baseURL+CryptoServiceSecp256K1SignProcedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Sign")),
-			connect.WithClientOptions(opts...),
-		),
-		secp256K1Verify: connect.NewClient[v1.Secp256K1VerifyRequest, v1.Secp256K1VerifyResponse](
-			httpClient,
-			baseURL+CryptoServiceSecp256K1VerifyProcedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Verify")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// NewCryptoServiceClient constructs a client for the cusf.crypto.v1.CryptoService service. Multiple
+// service clients may share a single connect.Client.
+func NewCryptoServiceClient(client *connect.Client) CryptoServiceClient {
+	return &cryptoServiceClient{client: client}
 }
 
-// cryptoServiceClient implements CryptoServiceClient.
-type cryptoServiceClient struct {
-	hmacSha512                    *connect.Client[v1.HmacSha512Request, v1.HmacSha512Response]
-	ripemd160                     *connect.Client[v1.Ripemd160Request, v1.Ripemd160Response]
-	secp256K1SecretKeyToPublicKey *connect.Client[v1.Secp256K1SecretKeyToPublicKeyRequest, v1.Secp256K1SecretKeyToPublicKeyResponse]
-	secp256K1Sign                 *connect.Client[v1.Secp256K1SignRequest, v1.Secp256K1SignResponse]
-	secp256K1Verify               *connect.Client[v1.Secp256K1VerifyRequest, v1.Secp256K1VerifyResponse]
+// CryptoServiceHandler is an implementation of the cusf.crypto.v1.CryptoService service.
+type CryptoServiceHandler interface {
+	HmacSha512(context.Context, *v1.HmacSha512Request) (*v1.HmacSha512Response, error)
+	Ripemd160(context.Context, *v1.Ripemd160Request) (*v1.Ripemd160Response, error)
+	Secp256K1SecretKeyToPublicKey(context.Context, *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error)
+	Secp256K1Sign(context.Context, *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error)
+	Secp256K1Verify(context.Context, *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error)
 }
 
-// HmacSha512 calls cusf.crypto.v1.CryptoService.HmacSha512.
-func (c *cryptoServiceClient) HmacSha512(ctx context.Context, req *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error) {
-	return c.hmacSha512.CallUnary(ctx, req)
+// RegisterCryptoServiceHandler registers svc as the cusf.crypto.v1.CryptoService implementation on
+// server.
+func RegisterCryptoServiceHandler(server *connect.Server, svc CryptoServiceHandler) {
+	adapter := cryptoServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: cryptoServiceHmacSha512Spec(), Handler: adapter.hmacSha512},
+		connect.Method{Spec: cryptoServiceRipemd160Spec(), Handler: adapter.ripemd160},
+		connect.Method{Spec: cryptoServiceSecp256K1SecretKeyToPublicKeySpec(), Handler: adapter.secp256K1SecretKeyToPublicKey},
+		connect.Method{Spec: cryptoServiceSecp256K1SignSpec(), Handler: adapter.secp256K1Sign},
+		connect.Method{Spec: cryptoServiceSecp256K1VerifySpec(), Handler: adapter.secp256K1Verify},
+	)
 }
 
-// Ripemd160 calls cusf.crypto.v1.CryptoService.Ripemd160.
-func (c *cryptoServiceClient) Ripemd160(ctx context.Context, req *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error) {
-	return c.ripemd160.CallUnary(ctx, req)
+// UnimplementedCryptoServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedCryptoServiceHandler struct{}
+
+func (UnimplementedCryptoServiceHandler) HmacSha512(context.Context, *v1.HmacSha512Request) (*v1.HmacSha512Response, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.HmacSha512 is not implemented")
 }
 
-// Secp256K1SecretKeyToPublicKey calls cusf.crypto.v1.CryptoService.Secp256k1SecretKeyToPublicKey.
-func (c *cryptoServiceClient) Secp256K1SecretKeyToPublicKey(ctx context.Context, req *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error) {
-	return c.secp256K1SecretKeyToPublicKey.CallUnary(ctx, req)
+func (UnimplementedCryptoServiceHandler) Ripemd160(context.Context, *v1.Ripemd160Request) (*v1.Ripemd160Response, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Ripemd160 is not implemented")
 }
 
-// Secp256K1Sign calls cusf.crypto.v1.CryptoService.Secp256k1Sign.
-func (c *cryptoServiceClient) Secp256K1Sign(ctx context.Context, req *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error) {
-	return c.secp256K1Sign.CallUnary(ctx, req)
+func (UnimplementedCryptoServiceHandler) Secp256K1SecretKeyToPublicKey(context.Context, *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Secp256k1SecretKeyToPublicKey is not implemented")
 }
 
-// Secp256K1Verify calls cusf.crypto.v1.CryptoService.Secp256k1Verify.
-func (c *cryptoServiceClient) Secp256K1Verify(ctx context.Context, req *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error) {
-	return c.secp256K1Verify.CallUnary(ctx, req)
+func (UnimplementedCryptoServiceHandler) Secp256K1Sign(context.Context, *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Secp256k1Sign is not implemented")
 }
 
-// CryptoServiceHandler is an implementation of the cusf.crypto.v1.CryptoService service.
-type CryptoServiceHandler interface {
-	HmacSha512(context.Context, *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error)
-	Ripemd160(context.Context, *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error)
-	Secp256K1SecretKeyToPublicKey(context.Context, *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error)
-	Secp256K1Sign(context.Context, *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error)
-	Secp256K1Verify(context.Context, *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error)
+func (UnimplementedCryptoServiceHandler) Secp256K1Verify(context.Context, *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Secp256k1Verify is not implemented")
 }
 
-// NewCryptoServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewCryptoServiceHandler(svc CryptoServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	cryptoServiceMethods := v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods()
-	cryptoServiceHmacSha512Handler := connect.NewUnaryHandler(
-		CryptoServiceHmacSha512Procedure,
-		svc.HmacSha512,
-		connect.WithSchema(cryptoServiceMethods.ByName("HmacSha512")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceRipemd160Handler := connect.NewUnaryHandler(
-		CryptoServiceRipemd160Procedure,
-		svc.Ripemd160,
-		connect.WithSchema(cryptoServiceMethods.ByName("Ripemd160")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceSecp256K1SecretKeyToPublicKeyHandler := connect.NewUnaryHandler(
-		CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure,
-		svc.Secp256K1SecretKeyToPublicKey,
-		connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1SecretKeyToPublicKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceSecp256K1SignHandler := connect.NewUnaryHandler(
-		CryptoServiceSecp256K1SignProcedure,
-		svc.Secp256K1Sign,
-		connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Sign")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceSecp256K1VerifyHandler := connect.NewUnaryHandler(
-		CryptoServiceSecp256K1VerifyProcedure,
-		svc.Secp256K1Verify,
-		connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Verify")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.crypto.v1.CryptoService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case CryptoServiceHmacSha512Procedure:
-			cryptoServiceHmacSha512Handler.ServeHTTP(w, r)
-		case CryptoServiceRipemd160Procedure:
-			cryptoServiceRipemd160Handler.ServeHTTP(w, r)
-		case CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure:
-			cryptoServiceSecp256K1SecretKeyToPublicKeyHandler.ServeHTTP(w, r)
-		case CryptoServiceSecp256K1SignProcedure:
-			cryptoServiceSecp256K1SignHandler.ServeHTTP(w, r)
-		case CryptoServiceSecp256K1VerifyProcedure:
-			cryptoServiceSecp256K1VerifyHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type cryptoServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedCryptoServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedCryptoServiceHandler struct{}
+func (c *cryptoServiceClient) HmacSha512(ctx context.Context, req *v1.HmacSha512Request) (*v1.HmacSha512Response, error) {
+	var res v1.HmacSha512Response
+	if err := c.client.CallUnary(ctx, cryptoServiceHmacSha512Spec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedCryptoServiceHandler) HmacSha512(context.Context, *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.HmacSha512 is not implemented"))
+func (c *cryptoServiceClient) Ripemd160(ctx context.Context, req *v1.Ripemd160Request) (*v1.Ripemd160Response, error) {
+	var res v1.Ripemd160Response
+	if err := c.client.CallUnary(ctx, cryptoServiceRipemd160Spec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Ripemd160(context.Context, *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Ripemd160 is not implemented"))
+func (c *cryptoServiceClient) Secp256K1SecretKeyToPublicKey(ctx context.Context, req *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error) {
+	var res v1.Secp256K1SecretKeyToPublicKeyResponse
+	if err := c.client.CallUnary(ctx, cryptoServiceSecp256K1SecretKeyToPublicKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Secp256K1SecretKeyToPublicKey(context.Context, *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Secp256k1SecretKeyToPublicKey is not implemented"))
+func (c *cryptoServiceClient) Secp256K1Sign(ctx context.Context, req *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error) {
+	var res v1.Secp256K1SignResponse
+	if err := c.client.CallUnary(ctx, cryptoServiceSecp256K1SignSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Secp256K1Sign(context.Context, *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Secp256k1Sign is not implemented"))
+func (c *cryptoServiceClient) Secp256K1Verify(ctx context.Context, req *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error) {
+	var res v1.Secp256K1VerifyResponse
+	if err := c.client.CallUnary(ctx, cryptoServiceSecp256K1VerifySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Secp256K1Verify(context.Context, *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Secp256k1Verify is not implemented"))
+type cryptoServiceHandler struct{ svc CryptoServiceHandler }
+
+func (h cryptoServiceHandler) hmacSha512(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.HmacSha512Request
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.HmacSha512(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) ripemd160(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Ripemd160Request
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Ripemd160(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) secp256K1SecretKeyToPublicKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Secp256K1SecretKeyToPublicKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Secp256K1SecretKeyToPublicKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) secp256K1Sign(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Secp256K1SignRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Secp256K1Sign(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) secp256K1Verify(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Secp256K1VerifyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Secp256K1Verify(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go b/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go
index a64980a646..0e04acdfd8 100644
--- a/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go
+++ b/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go
@@ -1,5 +1,3 @@
-// CUSF mainchain block producer service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/mainchain/v1/block_producer.proto
@@ -7,256 +5,277 @@
 package mainchainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BlockProducerServiceName is the fully-qualified name of the BlockProducerService service.
 	BlockProducerServiceName = "cusf.mainchain.v1.BlockProducerService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BlockProducerServiceCreateSidechainProposalProcedure is the fully-qualified name of the
+	// BlockProducerServiceCreateSidechainProposalProcedure is the procedure name of the
 	// BlockProducerService's CreateSidechainProposal RPC.
 	BlockProducerServiceCreateSidechainProposalProcedure = "/cusf.mainchain.v1.BlockProducerService/CreateSidechainProposal"
-	// BlockProducerServiceSubmitSidechainProposalProcedure is the fully-qualified name of the
+	// BlockProducerServiceSubmitSidechainProposalProcedure is the procedure name of the
 	// BlockProducerService's SubmitSidechainProposal RPC.
 	BlockProducerServiceSubmitSidechainProposalProcedure = "/cusf.mainchain.v1.BlockProducerService/SubmitSidechainProposal"
-	// BlockProducerServiceSetSidechainAckProcedure is the fully-qualified name of the
-	// BlockProducerService's SetSidechainAck RPC.
+	// BlockProducerServiceSetSidechainAckProcedure is the procedure name of the BlockProducerService's
+	// SetSidechainAck RPC.
 	BlockProducerServiceSetSidechainAckProcedure = "/cusf.mainchain.v1.BlockProducerService/SetSidechainAck"
-	// BlockProducerServiceSetAckAllProposalsProcedure is the fully-qualified name of the
+	// BlockProducerServiceSetAckAllProposalsProcedure is the procedure name of the
 	// BlockProducerService's SetAckAllProposals RPC.
 	BlockProducerServiceSetAckAllProposalsProcedure = "/cusf.mainchain.v1.BlockProducerService/SetAckAllProposals"
-	// BlockProducerServiceGetBlockProducerStateProcedure is the fully-qualified name of the
+	// BlockProducerServiceGetBlockProducerStateProcedure is the procedure name of the
 	// BlockProducerService's GetBlockProducerState RPC.
 	BlockProducerServiceGetBlockProducerStateProcedure = "/cusf.mainchain.v1.BlockProducerService/GetBlockProducerState"
 )
 
+var (
+	blockProducerServiceCreateSidechainProposalSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("CreateSidechainProposal"),
+			Procedure:  BlockProducerServiceCreateSidechainProposalProcedure,
+		}
+	})
+	blockProducerServiceSubmitSidechainProposalSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SubmitSidechainProposal"),
+			Procedure:  BlockProducerServiceSubmitSidechainProposalProcedure,
+		}
+	})
+	blockProducerServiceSetSidechainAckSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SetSidechainAck"),
+			Procedure:  BlockProducerServiceSetSidechainAckProcedure,
+		}
+	})
+	blockProducerServiceSetAckAllProposalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SetAckAllProposals"),
+			Procedure:  BlockProducerServiceSetAckAllProposalsProcedure,
+		}
+	})
+	blockProducerServiceGetBlockProducerStateSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("GetBlockProducerState"),
+			Procedure:        BlockProducerServiceGetBlockProducerStateProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+)
+
 // BlockProducerServiceClient is a client for the cusf.mainchain.v1.BlockProducerService service.
 type BlockProducerServiceClient interface {
-	// Create a new sidechain proposal (M1 in BIP300) and persist to the local
-	// database for further processing.
-	// Sidechain proposals must be included in the coinbase transaction of a
-	// newly mined block, so this proposal is not active until a new block has
-	// been generated.
-	// Returns a stream of (non-)confirmation events for the sidechain proposal.
-	CreateSidechainProposal(context.Context, *connect.Request[v1.CreateSidechainProposalRequest]) (*connect.ServerStreamForClient[v1.CreateSidechainProposalResponse], error)
-	// Unary variant of `CreateSidechainProposal`. Creates a new sidechain
-	// proposal (M1 in BIP300) and persists it to the local database for further
-	// processing, returning immediately once the proposal has been created.
-	SubmitSidechainProposal(context.Context, *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error)
-	// Toggle ACK or NACK policy for a specific sidechain proposal. Has no effect
-	// while `SetAckAllProposals` is on.
-	SetSidechainAck(context.Context, *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error)
-	// Toggle ACK of every active sidechain proposal.
-	SetAckAllProposals(context.Context, *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error)
-	// Block-producer / operator state that is not (yet) reflected on-chain:
-	// sidechain proposals authored here but not yet mined into a coinbase, plus
-	// the ACK policy. Complements ValidatorService.GetSidechainProposals, which
-	// only reports proposals already on the chain.
-	GetBlockProducerState(context.Context, *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error)
+	CreateSidechainProposal(context.Context, *v1.CreateSidechainProposalRequest) (BlockProducerServiceCreateSidechainProposalClientStream, error)
+	SubmitSidechainProposal(context.Context, *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error)
+	SetSidechainAck(context.Context, *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error)
+	SetAckAllProposals(context.Context, *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error)
+	GetBlockProducerState(context.Context, *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error)
 }
 
 // NewBlockProducerServiceClient constructs a client for the cusf.mainchain.v1.BlockProducerService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBlockProducerServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BlockProducerServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	blockProducerServiceMethods := v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods()
-	return &blockProducerServiceClient{
-		createSidechainProposal: connect.NewClient[v1.CreateSidechainProposalRequest, v1.CreateSidechainProposalResponse](
-			httpClient,
-			baseURL+BlockProducerServiceCreateSidechainProposalProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("CreateSidechainProposal")),
-			connect.WithClientOptions(opts...),
-		),
-		submitSidechainProposal: connect.NewClient[v1.SubmitSidechainProposalRequest, v1.SubmitSidechainProposalResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSubmitSidechainProposalProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SubmitSidechainProposal")),
-			connect.WithClientOptions(opts...),
-		),
-		setSidechainAck: connect.NewClient[v1.SetSidechainAckRequest, v1.SetSidechainAckResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSetSidechainAckProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SetSidechainAck")),
-			connect.WithClientOptions(opts...),
-		),
-		setAckAllProposals: connect.NewClient[v1.SetAckAllProposalsRequest, v1.SetAckAllProposalsResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSetAckAllProposalsProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SetAckAllProposals")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockProducerState: connect.NewClient[v1.GetBlockProducerStateRequest, v1.GetBlockProducerStateResponse](
-			httpClient,
-			baseURL+BlockProducerServiceGetBlockProducerStateProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("GetBlockProducerState")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// service. Multiple service clients may share a single connect.Client.
+func NewBlockProducerServiceClient(client *connect.Client) BlockProducerServiceClient {
+	return &blockProducerServiceClient{client: client}
 }
 
-// blockProducerServiceClient implements BlockProducerServiceClient.
-type blockProducerServiceClient struct {
-	createSidechainProposal *connect.Client[v1.CreateSidechainProposalRequest, v1.CreateSidechainProposalResponse]
-	submitSidechainProposal *connect.Client[v1.SubmitSidechainProposalRequest, v1.SubmitSidechainProposalResponse]
-	setSidechainAck         *connect.Client[v1.SetSidechainAckRequest, v1.SetSidechainAckResponse]
-	setAckAllProposals      *connect.Client[v1.SetAckAllProposalsRequest, v1.SetAckAllProposalsResponse]
-	getBlockProducerState   *connect.Client[v1.GetBlockProducerStateRequest, v1.GetBlockProducerStateResponse]
+// BlockProducerServiceCreateSidechainProposalClientStream is the client stream for the
+// BlockProducerService's CreateSidechainProposal RPC.
+type BlockProducerServiceCreateSidechainProposalClientStream struct {
+	stream connect.ClientStream
 }
 
-// CreateSidechainProposal calls cusf.mainchain.v1.BlockProducerService.CreateSidechainProposal.
-func (c *blockProducerServiceClient) CreateSidechainProposal(ctx context.Context, req *connect.Request[v1.CreateSidechainProposalRequest]) (*connect.ServerStreamForClient[v1.CreateSidechainProposalResponse], error) {
-	return c.createSidechainProposal.CallServerStream(ctx, req)
+// Receive returns the next response message from the server.
+func (s BlockProducerServiceCreateSidechainProposalClientStream) Receive() (*v1.CreateSidechainProposalResponse, error) {
+	var res v1.CreateSidechainProposalResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// SubmitSidechainProposal calls cusf.mainchain.v1.BlockProducerService.SubmitSidechainProposal.
-func (c *blockProducerServiceClient) SubmitSidechainProposal(ctx context.Context, req *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error) {
-	return c.submitSidechainProposal.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s BlockProducerServiceCreateSidechainProposalClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// SetSidechainAck calls cusf.mainchain.v1.BlockProducerService.SetSidechainAck.
-func (c *blockProducerServiceClient) SetSidechainAck(ctx context.Context, req *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error) {
-	return c.setSidechainAck.CallUnary(ctx, req)
+// BlockProducerServiceHandler is an implementation of the cusf.mainchain.v1.BlockProducerService
+// service.
+type BlockProducerServiceHandler interface {
+	CreateSidechainProposal(context.Context, *v1.CreateSidechainProposalRequest, BlockProducerServiceCreateSidechainProposalServerStream) error
+	SubmitSidechainProposal(context.Context, *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error)
+	SetSidechainAck(context.Context, *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error)
+	SetAckAllProposals(context.Context, *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error)
+	GetBlockProducerState(context.Context, *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error)
 }
 
-// SetAckAllProposals calls cusf.mainchain.v1.BlockProducerService.SetAckAllProposals.
-func (c *blockProducerServiceClient) SetAckAllProposals(ctx context.Context, req *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error) {
-	return c.setAckAllProposals.CallUnary(ctx, req)
+// RegisterBlockProducerServiceHandler registers svc as the cusf.mainchain.v1.BlockProducerService
+// implementation on server.
+func RegisterBlockProducerServiceHandler(server *connect.Server, svc BlockProducerServiceHandler) {
+	adapter := blockProducerServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: blockProducerServiceCreateSidechainProposalSpec(), Handler: adapter.createSidechainProposal},
+		connect.Method{Spec: blockProducerServiceSubmitSidechainProposalSpec(), Handler: adapter.submitSidechainProposal},
+		connect.Method{Spec: blockProducerServiceSetSidechainAckSpec(), Handler: adapter.setSidechainAck},
+		connect.Method{Spec: blockProducerServiceSetAckAllProposalsSpec(), Handler: adapter.setAckAllProposals},
+		connect.Method{Spec: blockProducerServiceGetBlockProducerStateSpec(), Handler: adapter.getBlockProducerState},
+	)
 }
 
-// GetBlockProducerState calls cusf.mainchain.v1.BlockProducerService.GetBlockProducerState.
-func (c *blockProducerServiceClient) GetBlockProducerState(ctx context.Context, req *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error) {
-	return c.getBlockProducerState.CallUnary(ctx, req)
+// BlockProducerServiceCreateSidechainProposalServerStream is the server stream for the
+// BlockProducerService's CreateSidechainProposal RPC.
+type BlockProducerServiceCreateSidechainProposalServerStream struct {
+	stream connect.ServerStream
 }
 
-// BlockProducerServiceHandler is an implementation of the cusf.mainchain.v1.BlockProducerService
-// service.
-type BlockProducerServiceHandler interface {
-	// Create a new sidechain proposal (M1 in BIP300) and persist to the local
-	// database for further processing.
-	// Sidechain proposals must be included in the coinbase transaction of a
-	// newly mined block, so this proposal is not active until a new block has
-	// been generated.
-	// Returns a stream of (non-)confirmation events for the sidechain proposal.
-	CreateSidechainProposal(context.Context, *connect.Request[v1.CreateSidechainProposalRequest], *connect.ServerStream[v1.CreateSidechainProposalResponse]) error
-	// Unary variant of `CreateSidechainProposal`. Creates a new sidechain
-	// proposal (M1 in BIP300) and persists it to the local database for further
-	// processing, returning immediately once the proposal has been created.
-	SubmitSidechainProposal(context.Context, *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error)
-	// Toggle ACK or NACK policy for a specific sidechain proposal. Has no effect
-	// while `SetAckAllProposals` is on.
-	SetSidechainAck(context.Context, *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error)
-	// Toggle ACK of every active sidechain proposal.
-	SetAckAllProposals(context.Context, *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error)
-	// Block-producer / operator state that is not (yet) reflected on-chain:
-	// sidechain proposals authored here but not yet mined into a coinbase, plus
-	// the ACK policy. Complements ValidatorService.GetSidechainProposals, which
-	// only reports proposals already on the chain.
-	GetBlockProducerState(context.Context, *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s BlockProducerServiceCreateSidechainProposalServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// NewBlockProducerServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBlockProducerServiceHandler(svc BlockProducerServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	blockProducerServiceMethods := v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods()
-	blockProducerServiceCreateSidechainProposalHandler := connect.NewServerStreamHandler(
-		BlockProducerServiceCreateSidechainProposalProcedure,
-		svc.CreateSidechainProposal,
-		connect.WithSchema(blockProducerServiceMethods.ByName("CreateSidechainProposal")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSubmitSidechainProposalHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSubmitSidechainProposalProcedure,
-		svc.SubmitSidechainProposal,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SubmitSidechainProposal")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSetSidechainAckHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSetSidechainAckProcedure,
-		svc.SetSidechainAck,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SetSidechainAck")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSetAckAllProposalsHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSetAckAllProposalsProcedure,
-		svc.SetAckAllProposals,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SetAckAllProposals")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceGetBlockProducerStateHandler := connect.NewUnaryHandler(
-		BlockProducerServiceGetBlockProducerStateProcedure,
-		svc.GetBlockProducerState,
-		connect.WithSchema(blockProducerServiceMethods.ByName("GetBlockProducerState")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.mainchain.v1.BlockProducerService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BlockProducerServiceCreateSidechainProposalProcedure:
-			blockProducerServiceCreateSidechainProposalHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSubmitSidechainProposalProcedure:
-			blockProducerServiceSubmitSidechainProposalHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSetSidechainAckProcedure:
-			blockProducerServiceSetSidechainAckHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSetAckAllProposalsProcedure:
-			blockProducerServiceSetAckAllProposalsHandler.ServeHTTP(w, r)
-		case BlockProducerServiceGetBlockProducerStateProcedure:
-			blockProducerServiceGetBlockProducerStateHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+// Send sends a response message to the client.
+func (s BlockProducerServiceCreateSidechainProposalServerStream) Send(res *v1.CreateSidechainProposalResponse) error {
+	return s.stream.Send(res)
 }
 
 // UnimplementedBlockProducerServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedBlockProducerServiceHandler struct{}
 
-func (UnimplementedBlockProducerServiceHandler) CreateSidechainProposal(context.Context, *connect.Request[v1.CreateSidechainProposalRequest], *connect.ServerStream[v1.CreateSidechainProposalResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.CreateSidechainProposal is not implemented"))
+func (UnimplementedBlockProducerServiceHandler) CreateSidechainProposal(context.Context, *v1.CreateSidechainProposalRequest, BlockProducerServiceCreateSidechainProposalServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.CreateSidechainProposal is not implemented")
+}
+
+func (UnimplementedBlockProducerServiceHandler) SubmitSidechainProposal(context.Context, *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SubmitSidechainProposal is not implemented")
 }
 
-func (UnimplementedBlockProducerServiceHandler) SubmitSidechainProposal(context.Context, *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SubmitSidechainProposal is not implemented"))
+func (UnimplementedBlockProducerServiceHandler) SetSidechainAck(context.Context, *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SetSidechainAck is not implemented")
 }
 
-func (UnimplementedBlockProducerServiceHandler) SetSidechainAck(context.Context, *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SetSidechainAck is not implemented"))
+func (UnimplementedBlockProducerServiceHandler) SetAckAllProposals(context.Context, *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SetAckAllProposals is not implemented")
 }
 
-func (UnimplementedBlockProducerServiceHandler) SetAckAllProposals(context.Context, *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SetAckAllProposals is not implemented"))
+func (UnimplementedBlockProducerServiceHandler) GetBlockProducerState(context.Context, *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.GetBlockProducerState is not implemented")
 }
 
-func (UnimplementedBlockProducerServiceHandler) GetBlockProducerState(context.Context, *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.GetBlockProducerState is not implemented"))
+type blockProducerServiceClient struct {
+	client *connect.Client
+}
+
+func (c *blockProducerServiceClient) CreateSidechainProposal(ctx context.Context, req *v1.CreateSidechainProposalRequest) (BlockProducerServiceCreateSidechainProposalClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, blockProducerServiceCreateSidechainProposalSpec(), req)
+	if err != nil {
+		return BlockProducerServiceCreateSidechainProposalClientStream{}, err
+	}
+	return BlockProducerServiceCreateSidechainProposalClientStream{stream: stream}, nil
+}
+
+func (c *blockProducerServiceClient) SubmitSidechainProposal(ctx context.Context, req *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error) {
+	var res v1.SubmitSidechainProposalResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSubmitSidechainProposalSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *blockProducerServiceClient) SetSidechainAck(ctx context.Context, req *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error) {
+	var res v1.SetSidechainAckResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSetSidechainAckSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *blockProducerServiceClient) SetAckAllProposals(ctx context.Context, req *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error) {
+	var res v1.SetAckAllProposalsResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSetAckAllProposalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *blockProducerServiceClient) GetBlockProducerState(ctx context.Context, req *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error) {
+	var res v1.GetBlockProducerStateResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceGetBlockProducerStateSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type blockProducerServiceHandler struct{ svc BlockProducerServiceHandler }
+
+func (h blockProducerServiceHandler) createSidechainProposal(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateSidechainProposalRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.CreateSidechainProposal(ctx, &req, BlockProducerServiceCreateSidechainProposalServerStream{stream: stream})
+}
+
+func (h blockProducerServiceHandler) submitSidechainProposal(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubmitSidechainProposalRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SubmitSidechainProposal(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) setSidechainAck(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSidechainAckRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSidechainAck(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) setAckAllProposals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetAckAllProposalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetAckAllProposals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) getBlockProducerState(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockProducerStateRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockProducerState(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go b/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go
index 8a61714443..7c339c3653 100644
--- a/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go
+++ b/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go
@@ -1,5 +1,3 @@
-// CUSF mainchain validator service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/mainchain/v1/validator.proto
@@ -7,500 +5,615 @@
 package mainchainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ValidatorServiceName is the fully-qualified name of the ValidatorService service.
 	ValidatorServiceName = "cusf.mainchain.v1.ValidatorService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ValidatorServiceGetBlockHeaderInfoProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetBlockHeaderInfoProcedure is the procedure name of the ValidatorService's
 	// GetBlockHeaderInfo RPC.
 	ValidatorServiceGetBlockHeaderInfoProcedure = "/cusf.mainchain.v1.ValidatorService/GetBlockHeaderInfo"
-	// ValidatorServiceGetBlockInfoProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetBlockInfoProcedure is the procedure name of the ValidatorService's
 	// GetBlockInfo RPC.
 	ValidatorServiceGetBlockInfoProcedure = "/cusf.mainchain.v1.ValidatorService/GetBlockInfo"
-	// ValidatorServiceGetBmmHStarCommitmentProcedure is the fully-qualified name of the
-	// ValidatorService's GetBmmHStarCommitment RPC.
+	// ValidatorServiceGetBmmHStarCommitmentProcedure is the procedure name of the ValidatorService's
+	// GetBmmHStarCommitment RPC.
 	ValidatorServiceGetBmmHStarCommitmentProcedure = "/cusf.mainchain.v1.ValidatorService/GetBmmHStarCommitment"
-	// ValidatorServiceGetChainInfoProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetChainInfoProcedure is the procedure name of the ValidatorService's
 	// GetChainInfo RPC.
 	ValidatorServiceGetChainInfoProcedure = "/cusf.mainchain.v1.ValidatorService/GetChainInfo"
-	// ValidatorServiceGetChainTipProcedure is the fully-qualified name of the ValidatorService's
-	// GetChainTip RPC.
+	// ValidatorServiceGetChainTipProcedure is the procedure name of the ValidatorService's GetChainTip
+	// RPC.
 	ValidatorServiceGetChainTipProcedure = "/cusf.mainchain.v1.ValidatorService/GetChainTip"
-	// ValidatorServiceGetCoinbasePSBTProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetCoinbasePSBTProcedure is the procedure name of the ValidatorService's
 	// GetCoinbasePSBT RPC.
 	ValidatorServiceGetCoinbasePSBTProcedure = "/cusf.mainchain.v1.ValidatorService/GetCoinbasePSBT"
-	// ValidatorServiceGetCtipProcedure is the fully-qualified name of the ValidatorService's GetCtip
-	// RPC.
+	// ValidatorServiceGetCtipProcedure is the procedure name of the ValidatorService's GetCtip RPC.
 	ValidatorServiceGetCtipProcedure = "/cusf.mainchain.v1.ValidatorService/GetCtip"
-	// ValidatorServiceGetSidechainProposalsProcedure is the fully-qualified name of the
-	// ValidatorService's GetSidechainProposals RPC.
+	// ValidatorServiceGetSidechainProposalsProcedure is the procedure name of the ValidatorService's
+	// GetSidechainProposals RPC.
 	ValidatorServiceGetSidechainProposalsProcedure = "/cusf.mainchain.v1.ValidatorService/GetSidechainProposals"
-	// ValidatorServiceGetSidechainsProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetSidechainsProcedure is the procedure name of the ValidatorService's
 	// GetSidechains RPC.
 	ValidatorServiceGetSidechainsProcedure = "/cusf.mainchain.v1.ValidatorService/GetSidechains"
-	// ValidatorServiceGetTwoWayPegDataProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetTwoWayPegDataProcedure is the procedure name of the ValidatorService's
 	// GetTwoWayPegData RPC.
 	ValidatorServiceGetTwoWayPegDataProcedure = "/cusf.mainchain.v1.ValidatorService/GetTwoWayPegData"
-	// ValidatorServiceSubscribeEventsProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceSubscribeEventsProcedure is the procedure name of the ValidatorService's
 	// SubscribeEvents RPC.
 	ValidatorServiceSubscribeEventsProcedure = "/cusf.mainchain.v1.ValidatorService/SubscribeEvents"
-	// ValidatorServiceSubscribeHeaderSyncProgressProcedure is the fully-qualified name of the
+	// ValidatorServiceSubscribeHeaderSyncProgressProcedure is the procedure name of the
 	// ValidatorService's SubscribeHeaderSyncProgress RPC.
 	ValidatorServiceSubscribeHeaderSyncProgressProcedure = "/cusf.mainchain.v1.ValidatorService/SubscribeHeaderSyncProgress"
-	// ValidatorServiceStopProcedure is the fully-qualified name of the ValidatorService's Stop RPC.
+	// ValidatorServiceStopProcedure is the procedure name of the ValidatorService's Stop RPC.
 	ValidatorServiceStopProcedure = "/cusf.mainchain.v1.ValidatorService/Stop"
 )
 
+var (
+	validatorServiceGetBlockHeaderInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetBlockHeaderInfo"),
+			Procedure:        ValidatorServiceGetBlockHeaderInfoProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetBlockInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetBlockInfo"),
+			Procedure:        ValidatorServiceGetBlockInfoProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetBmmHStarCommitmentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetBmmHStarCommitment"),
+			Procedure:        ValidatorServiceGetBmmHStarCommitmentProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetChainInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetChainInfo"),
+			Procedure:        ValidatorServiceGetChainInfoProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetChainTipSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetChainTip"),
+			Procedure:        ValidatorServiceGetChainTipProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetCoinbasePSBTSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetCoinbasePSBT"),
+			Procedure:        ValidatorServiceGetCoinbasePSBTProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetCtipSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetCtip"),
+			Procedure:        ValidatorServiceGetCtipProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetSidechainProposalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetSidechainProposals"),
+			Procedure:        ValidatorServiceGetSidechainProposalsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetSidechainsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetSidechains"),
+			Procedure:        ValidatorServiceGetSidechainsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetTwoWayPegDataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetTwoWayPegData"),
+			Procedure:        ValidatorServiceGetTwoWayPegDataProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceSubscribeEventsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeServer,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("SubscribeEvents"),
+			Procedure:        ValidatorServiceSubscribeEventsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceSubscribeHeaderSyncProgressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeServer,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("SubscribeHeaderSyncProgress"),
+			Procedure:        ValidatorServiceSubscribeHeaderSyncProgressProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("Stop"),
+			Procedure:        ValidatorServiceStopProcedure,
+			IdempotencyLevel: connect.IdempotencyIdempotent,
+		}
+	})
+)
+
 // ValidatorServiceClient is a client for the cusf.mainchain.v1.ValidatorService service.
 type ValidatorServiceClient interface {
-	// Fetches information about a specific mainchain block header,
-	// and optionally, it's ancestors
-	GetBlockHeaderInfo(context.Context, *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error)
-	// Fetches information about a specific mainchain block (and optionally,
-	// it's ancestors), regarding how it pertains to events happening on a
-	// specific sidechain.
-	GetBlockInfo(context.Context, *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error)
-	// Fetches BMM h* commitment for a specific mainchain block,
-	// and optionally, it's ancestors
-	GetBmmHStarCommitment(context.Context, *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error)
-	GetChainInfo(context.Context, *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error)
-	GetChainTip(context.Context, *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error)
-	GetCoinbasePSBT(context.Context, *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error)
-	GetCtip(context.Context, *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error)
-	GetSidechainProposals(context.Context, *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error)
-	GetSidechains(context.Context, *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error)
-	GetTwoWayPegData(context.Context, *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error)
-	SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.SubscribeEventsResponse], error)
-	// Stream header sync progress updates
-	SubscribeHeaderSyncProgress(context.Context, *connect.Request[v1.SubscribeHeaderSyncProgressRequest]) (*connect.ServerStreamForClient[v1.SubscribeHeaderSyncProgressResponse], error)
-	// Safely shutdown the validator. This is equivalent to sending a SIGINT
-	// to the validator process, and can be used to trigger a graceful shutdown
-	// in cases where you don't have access to the validator process.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
+	GetBlockHeaderInfo(context.Context, *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error)
+	GetBlockInfo(context.Context, *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error)
+	GetBmmHStarCommitment(context.Context, *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error)
+	GetChainInfo(context.Context, *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error)
+	GetChainTip(context.Context, *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error)
+	GetCoinbasePSBT(context.Context, *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error)
+	GetCtip(context.Context, *v1.GetCtipRequest) (*v1.GetCtipResponse, error)
+	GetSidechainProposals(context.Context, *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error)
+	GetSidechains(context.Context, *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error)
+	GetTwoWayPegData(context.Context, *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error)
+	SubscribeEvents(context.Context, *v1.SubscribeEventsRequest) (ValidatorServiceSubscribeEventsClientStream, error)
+	SubscribeHeaderSyncProgress(context.Context, *v1.SubscribeHeaderSyncProgressRequest) (ValidatorServiceSubscribeHeaderSyncProgressClientStream, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
 }
 
 // NewValidatorServiceClient constructs a client for the cusf.mainchain.v1.ValidatorService service.
-// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped
-// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewValidatorServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ValidatorServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	validatorServiceMethods := v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods()
-	return &validatorServiceClient{
-		getBlockHeaderInfo: connect.NewClient[v1.GetBlockHeaderInfoRequest, v1.GetBlockHeaderInfoResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetBlockHeaderInfoProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetBlockHeaderInfo")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockInfo: connect.NewClient[v1.GetBlockInfoRequest, v1.GetBlockInfoResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetBlockInfoProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetBlockInfo")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmHStarCommitment: connect.NewClient[v1.GetBmmHStarCommitmentRequest, v1.GetBmmHStarCommitmentResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetBmmHStarCommitmentProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetBmmHStarCommitment")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getChainInfo: connect.NewClient[v1.GetChainInfoRequest, v1.GetChainInfoResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetChainInfoProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetChainInfo")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getChainTip: connect.NewClient[v1.GetChainTipRequest, v1.GetChainTipResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetChainTipProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetChainTip")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getCoinbasePSBT: connect.NewClient[v1.GetCoinbasePSBTRequest, v1.GetCoinbasePSBTResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetCoinbasePSBTProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetCoinbasePSBT")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getCtip: connect.NewClient[v1.GetCtipRequest, v1.GetCtipResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetCtipProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetCtip")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainProposals: connect.NewClient[v1.GetSidechainProposalsRequest, v1.GetSidechainProposalsResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetSidechainProposalsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetSidechainProposals")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechains: connect.NewClient[v1.GetSidechainsRequest, v1.GetSidechainsResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetSidechainsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetSidechains")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getTwoWayPegData: connect.NewClient[v1.GetTwoWayPegDataRequest, v1.GetTwoWayPegDataResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetTwoWayPegDataProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetTwoWayPegData")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		subscribeEvents: connect.NewClient[v1.SubscribeEventsRequest, v1.SubscribeEventsResponse](
-			httpClient,
-			baseURL+ValidatorServiceSubscribeEventsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("SubscribeEvents")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		subscribeHeaderSyncProgress: connect.NewClient[v1.SubscribeHeaderSyncProgressRequest, v1.SubscribeHeaderSyncProgressResponse](
-			httpClient,
-			baseURL+ValidatorServiceSubscribeHeaderSyncProgressProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("SubscribeHeaderSyncProgress")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+ValidatorServiceStopProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("Stop")),
-			connect.WithIdempotency(connect.IdempotencyIdempotent),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// validatorServiceClient implements ValidatorServiceClient.
-type validatorServiceClient struct {
-	getBlockHeaderInfo          *connect.Client[v1.GetBlockHeaderInfoRequest, v1.GetBlockHeaderInfoResponse]
-	getBlockInfo                *connect.Client[v1.GetBlockInfoRequest, v1.GetBlockInfoResponse]
-	getBmmHStarCommitment       *connect.Client[v1.GetBmmHStarCommitmentRequest, v1.GetBmmHStarCommitmentResponse]
-	getChainInfo                *connect.Client[v1.GetChainInfoRequest, v1.GetChainInfoResponse]
-	getChainTip                 *connect.Client[v1.GetChainTipRequest, v1.GetChainTipResponse]
-	getCoinbasePSBT             *connect.Client[v1.GetCoinbasePSBTRequest, v1.GetCoinbasePSBTResponse]
-	getCtip                     *connect.Client[v1.GetCtipRequest, v1.GetCtipResponse]
-	getSidechainProposals       *connect.Client[v1.GetSidechainProposalsRequest, v1.GetSidechainProposalsResponse]
-	getSidechains               *connect.Client[v1.GetSidechainsRequest, v1.GetSidechainsResponse]
-	getTwoWayPegData            *connect.Client[v1.GetTwoWayPegDataRequest, v1.GetTwoWayPegDataResponse]
-	subscribeEvents             *connect.Client[v1.SubscribeEventsRequest, v1.SubscribeEventsResponse]
-	subscribeHeaderSyncProgress *connect.Client[v1.SubscribeHeaderSyncProgressRequest, v1.SubscribeHeaderSyncProgressResponse]
-	stop                        *connect.Client[v1.StopRequest, v1.StopResponse]
+// Multiple service clients may share a single connect.Client.
+func NewValidatorServiceClient(client *connect.Client) ValidatorServiceClient {
+	return &validatorServiceClient{client: client}
 }
 
-// GetBlockHeaderInfo calls cusf.mainchain.v1.ValidatorService.GetBlockHeaderInfo.
-func (c *validatorServiceClient) GetBlockHeaderInfo(ctx context.Context, req *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error) {
-	return c.getBlockHeaderInfo.CallUnary(ctx, req)
+// ValidatorServiceSubscribeEventsClientStream is the client stream for the ValidatorService's
+// SubscribeEvents RPC.
+type ValidatorServiceSubscribeEventsClientStream struct {
+	stream connect.ClientStream
 }
 
-// GetBlockInfo calls cusf.mainchain.v1.ValidatorService.GetBlockInfo.
-func (c *validatorServiceClient) GetBlockInfo(ctx context.Context, req *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error) {
-	return c.getBlockInfo.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s ValidatorServiceSubscribeEventsClientStream) Receive() (*v1.SubscribeEventsResponse, error) {
+	var res v1.SubscribeEventsResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// GetBmmHStarCommitment calls cusf.mainchain.v1.ValidatorService.GetBmmHStarCommitment.
-func (c *validatorServiceClient) GetBmmHStarCommitment(ctx context.Context, req *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error) {
-	return c.getBmmHStarCommitment.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s ValidatorServiceSubscribeEventsClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// GetChainInfo calls cusf.mainchain.v1.ValidatorService.GetChainInfo.
-func (c *validatorServiceClient) GetChainInfo(ctx context.Context, req *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error) {
-	return c.getChainInfo.CallUnary(ctx, req)
+// ValidatorServiceSubscribeHeaderSyncProgressClientStream is the client stream for the
+// ValidatorService's SubscribeHeaderSyncProgress RPC.
+type ValidatorServiceSubscribeHeaderSyncProgressClientStream struct {
+	stream connect.ClientStream
 }
 
-// GetChainTip calls cusf.mainchain.v1.ValidatorService.GetChainTip.
-func (c *validatorServiceClient) GetChainTip(ctx context.Context, req *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error) {
-	return c.getChainTip.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s ValidatorServiceSubscribeHeaderSyncProgressClientStream) Receive() (*v1.SubscribeHeaderSyncProgressResponse, error) {
+	var res v1.SubscribeHeaderSyncProgressResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// GetCoinbasePSBT calls cusf.mainchain.v1.ValidatorService.GetCoinbasePSBT.
-func (c *validatorServiceClient) GetCoinbasePSBT(ctx context.Context, req *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error) {
-	return c.getCoinbasePSBT.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s ValidatorServiceSubscribeHeaderSyncProgressClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// GetCtip calls cusf.mainchain.v1.ValidatorService.GetCtip.
-func (c *validatorServiceClient) GetCtip(ctx context.Context, req *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error) {
-	return c.getCtip.CallUnary(ctx, req)
+// ValidatorServiceHandler is an implementation of the cusf.mainchain.v1.ValidatorService service.
+type ValidatorServiceHandler interface {
+	GetBlockHeaderInfo(context.Context, *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error)
+	GetBlockInfo(context.Context, *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error)
+	GetBmmHStarCommitment(context.Context, *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error)
+	GetChainInfo(context.Context, *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error)
+	GetChainTip(context.Context, *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error)
+	GetCoinbasePSBT(context.Context, *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error)
+	GetCtip(context.Context, *v1.GetCtipRequest) (*v1.GetCtipResponse, error)
+	GetSidechainProposals(context.Context, *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error)
+	GetSidechains(context.Context, *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error)
+	GetTwoWayPegData(context.Context, *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error)
+	SubscribeEvents(context.Context, *v1.SubscribeEventsRequest, ValidatorServiceSubscribeEventsServerStream) error
+	SubscribeHeaderSyncProgress(context.Context, *v1.SubscribeHeaderSyncProgressRequest, ValidatorServiceSubscribeHeaderSyncProgressServerStream) error
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
 }
 
-// GetSidechainProposals calls cusf.mainchain.v1.ValidatorService.GetSidechainProposals.
-func (c *validatorServiceClient) GetSidechainProposals(ctx context.Context, req *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error) {
-	return c.getSidechainProposals.CallUnary(ctx, req)
+// RegisterValidatorServiceHandler registers svc as the cusf.mainchain.v1.ValidatorService
+// implementation on server.
+func RegisterValidatorServiceHandler(server *connect.Server, svc ValidatorServiceHandler) {
+	adapter := validatorServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: validatorServiceGetBlockHeaderInfoSpec(), Handler: adapter.getBlockHeaderInfo},
+		connect.Method{Spec: validatorServiceGetBlockInfoSpec(), Handler: adapter.getBlockInfo},
+		connect.Method{Spec: validatorServiceGetBmmHStarCommitmentSpec(), Handler: adapter.getBmmHStarCommitment},
+		connect.Method{Spec: validatorServiceGetChainInfoSpec(), Handler: adapter.getChainInfo},
+		connect.Method{Spec: validatorServiceGetChainTipSpec(), Handler: adapter.getChainTip},
+		connect.Method{Spec: validatorServiceGetCoinbasePSBTSpec(), Handler: adapter.getCoinbasePSBT},
+		connect.Method{Spec: validatorServiceGetCtipSpec(), Handler: adapter.getCtip},
+		connect.Method{Spec: validatorServiceGetSidechainProposalsSpec(), Handler: adapter.getSidechainProposals},
+		connect.Method{Spec: validatorServiceGetSidechainsSpec(), Handler: adapter.getSidechains},
+		connect.Method{Spec: validatorServiceGetTwoWayPegDataSpec(), Handler: adapter.getTwoWayPegData},
+		connect.Method{Spec: validatorServiceSubscribeEventsSpec(), Handler: adapter.subscribeEvents},
+		connect.Method{Spec: validatorServiceSubscribeHeaderSyncProgressSpec(), Handler: adapter.subscribeHeaderSyncProgress},
+		connect.Method{Spec: validatorServiceStopSpec(), Handler: adapter.stop},
+	)
 }
 
-// GetSidechains calls cusf.mainchain.v1.ValidatorService.GetSidechains.
-func (c *validatorServiceClient) GetSidechains(ctx context.Context, req *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error) {
-	return c.getSidechains.CallUnary(ctx, req)
+// ValidatorServiceSubscribeEventsServerStream is the server stream for the ValidatorService's
+// SubscribeEvents RPC.
+type ValidatorServiceSubscribeEventsServerStream struct {
+	stream connect.ServerStream
 }
 
-// GetTwoWayPegData calls cusf.mainchain.v1.ValidatorService.GetTwoWayPegData.
-func (c *validatorServiceClient) GetTwoWayPegData(ctx context.Context, req *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error) {
-	return c.getTwoWayPegData.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s ValidatorServiceSubscribeEventsServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// SubscribeEvents calls cusf.mainchain.v1.ValidatorService.SubscribeEvents.
-func (c *validatorServiceClient) SubscribeEvents(ctx context.Context, req *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.SubscribeEventsResponse], error) {
-	return c.subscribeEvents.CallServerStream(ctx, req)
+// Send sends a response message to the client.
+func (s ValidatorServiceSubscribeEventsServerStream) Send(res *v1.SubscribeEventsResponse) error {
+	return s.stream.Send(res)
 }
 
-// SubscribeHeaderSyncProgress calls cusf.mainchain.v1.ValidatorService.SubscribeHeaderSyncProgress.
-func (c *validatorServiceClient) SubscribeHeaderSyncProgress(ctx context.Context, req *connect.Request[v1.SubscribeHeaderSyncProgressRequest]) (*connect.ServerStreamForClient[v1.SubscribeHeaderSyncProgressResponse], error) {
-	return c.subscribeHeaderSyncProgress.CallServerStream(ctx, req)
+// ValidatorServiceSubscribeHeaderSyncProgressServerStream is the server stream for the
+// ValidatorService's SubscribeHeaderSyncProgress RPC.
+type ValidatorServiceSubscribeHeaderSyncProgressServerStream struct {
+	stream connect.ServerStream
 }
 
-// Stop calls cusf.mainchain.v1.ValidatorService.Stop.
-func (c *validatorServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s ValidatorServiceSubscribeHeaderSyncProgressServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// ValidatorServiceHandler is an implementation of the cusf.mainchain.v1.ValidatorService service.
-type ValidatorServiceHandler interface {
-	// Fetches information about a specific mainchain block header,
-	// and optionally, it's ancestors
-	GetBlockHeaderInfo(context.Context, *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error)
-	// Fetches information about a specific mainchain block (and optionally,
-	// it's ancestors), regarding how it pertains to events happening on a
-	// specific sidechain.
-	GetBlockInfo(context.Context, *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error)
-	// Fetches BMM h* commitment for a specific mainchain block,
-	// and optionally, it's ancestors
-	GetBmmHStarCommitment(context.Context, *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error)
-	GetChainInfo(context.Context, *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error)
-	GetChainTip(context.Context, *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error)
-	GetCoinbasePSBT(context.Context, *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error)
-	GetCtip(context.Context, *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error)
-	GetSidechainProposals(context.Context, *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error)
-	GetSidechains(context.Context, *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error)
-	GetTwoWayPegData(context.Context, *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error)
-	SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.SubscribeEventsResponse]) error
-	// Stream header sync progress updates
-	SubscribeHeaderSyncProgress(context.Context, *connect.Request[v1.SubscribeHeaderSyncProgressRequest], *connect.ServerStream[v1.SubscribeHeaderSyncProgressResponse]) error
-	// Safely shutdown the validator. This is equivalent to sending a SIGINT
-	// to the validator process, and can be used to trigger a graceful shutdown
-	// in cases where you don't have access to the validator process.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-}
-
-// NewValidatorServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewValidatorServiceHandler(svc ValidatorServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	validatorServiceMethods := v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods()
-	validatorServiceGetBlockHeaderInfoHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetBlockHeaderInfoProcedure,
-		svc.GetBlockHeaderInfo,
-		connect.WithSchema(validatorServiceMethods.ByName("GetBlockHeaderInfo")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetBlockInfoHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetBlockInfoProcedure,
-		svc.GetBlockInfo,
-		connect.WithSchema(validatorServiceMethods.ByName("GetBlockInfo")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetBmmHStarCommitmentHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetBmmHStarCommitmentProcedure,
-		svc.GetBmmHStarCommitment,
-		connect.WithSchema(validatorServiceMethods.ByName("GetBmmHStarCommitment")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetChainInfoHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetChainInfoProcedure,
-		svc.GetChainInfo,
-		connect.WithSchema(validatorServiceMethods.ByName("GetChainInfo")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetChainTipHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetChainTipProcedure,
-		svc.GetChainTip,
-		connect.WithSchema(validatorServiceMethods.ByName("GetChainTip")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetCoinbasePSBTHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetCoinbasePSBTProcedure,
-		svc.GetCoinbasePSBT,
-		connect.WithSchema(validatorServiceMethods.ByName("GetCoinbasePSBT")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetCtipHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetCtipProcedure,
-		svc.GetCtip,
-		connect.WithSchema(validatorServiceMethods.ByName("GetCtip")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetSidechainProposalsHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetSidechainProposalsProcedure,
-		svc.GetSidechainProposals,
-		connect.WithSchema(validatorServiceMethods.ByName("GetSidechainProposals")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetSidechainsHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetSidechainsProcedure,
-		svc.GetSidechains,
-		connect.WithSchema(validatorServiceMethods.ByName("GetSidechains")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetTwoWayPegDataHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetTwoWayPegDataProcedure,
-		svc.GetTwoWayPegData,
-		connect.WithSchema(validatorServiceMethods.ByName("GetTwoWayPegData")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceSubscribeEventsHandler := connect.NewServerStreamHandler(
-		ValidatorServiceSubscribeEventsProcedure,
-		svc.SubscribeEvents,
-		connect.WithSchema(validatorServiceMethods.ByName("SubscribeEvents")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceSubscribeHeaderSyncProgressHandler := connect.NewServerStreamHandler(
-		ValidatorServiceSubscribeHeaderSyncProgressProcedure,
-		svc.SubscribeHeaderSyncProgress,
-		connect.WithSchema(validatorServiceMethods.ByName("SubscribeHeaderSyncProgress")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceStopHandler := connect.NewUnaryHandler(
-		ValidatorServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(validatorServiceMethods.ByName("Stop")),
-		connect.WithIdempotency(connect.IdempotencyIdempotent),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.mainchain.v1.ValidatorService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ValidatorServiceGetBlockHeaderInfoProcedure:
-			validatorServiceGetBlockHeaderInfoHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetBlockInfoProcedure:
-			validatorServiceGetBlockInfoHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetBmmHStarCommitmentProcedure:
-			validatorServiceGetBmmHStarCommitmentHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetChainInfoProcedure:
-			validatorServiceGetChainInfoHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetChainTipProcedure:
-			validatorServiceGetChainTipHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetCoinbasePSBTProcedure:
-			validatorServiceGetCoinbasePSBTHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetCtipProcedure:
-			validatorServiceGetCtipHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetSidechainProposalsProcedure:
-			validatorServiceGetSidechainProposalsHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetSidechainsProcedure:
-			validatorServiceGetSidechainsHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetTwoWayPegDataProcedure:
-			validatorServiceGetTwoWayPegDataHandler.ServeHTTP(w, r)
-		case ValidatorServiceSubscribeEventsProcedure:
-			validatorServiceSubscribeEventsHandler.ServeHTTP(w, r)
-		case ValidatorServiceSubscribeHeaderSyncProgressProcedure:
-			validatorServiceSubscribeHeaderSyncProgressHandler.ServeHTTP(w, r)
-		case ValidatorServiceStopProcedure:
-			validatorServiceStopHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+// Send sends a response message to the client.
+func (s ValidatorServiceSubscribeHeaderSyncProgressServerStream) Send(res *v1.SubscribeHeaderSyncProgressResponse) error {
+	return s.stream.Send(res)
 }
 
 // UnimplementedValidatorServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedValidatorServiceHandler struct{}
 
-func (UnimplementedValidatorServiceHandler) GetBlockHeaderInfo(context.Context, *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetBlockHeaderInfo is not implemented"))
+func (UnimplementedValidatorServiceHandler) GetBlockHeaderInfo(context.Context, *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetBlockHeaderInfo is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetBlockInfo(context.Context, *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetBlockInfo is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetBmmHStarCommitment(context.Context, *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetBmmHStarCommitment is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetChainInfo(context.Context, *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetChainInfo is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetChainTip(context.Context, *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetChainTip is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetCoinbasePSBT(context.Context, *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetCoinbasePSBT is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetCtip(context.Context, *v1.GetCtipRequest) (*v1.GetCtipResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetCtip is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetSidechainProposals(context.Context, *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetSidechainProposals is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetSidechains(context.Context, *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetSidechains is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetTwoWayPegData(context.Context, *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetTwoWayPegData is not implemented")
 }
 
-func (UnimplementedValidatorServiceHandler) GetBlockInfo(context.Context, *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetBlockInfo is not implemented"))
+func (UnimplementedValidatorServiceHandler) SubscribeEvents(context.Context, *v1.SubscribeEventsRequest, ValidatorServiceSubscribeEventsServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.SubscribeEvents is not implemented")
 }
 
-func (UnimplementedValidatorServiceHandler) GetBmmHStarCommitment(context.Context, *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetBmmHStarCommitment is not implemented"))
+func (UnimplementedValidatorServiceHandler) SubscribeHeaderSyncProgress(context.Context, *v1.SubscribeHeaderSyncProgressRequest, ValidatorServiceSubscribeHeaderSyncProgressServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.SubscribeHeaderSyncProgress is not implemented")
 }
 
-func (UnimplementedValidatorServiceHandler) GetChainInfo(context.Context, *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetChainInfo is not implemented"))
+func (UnimplementedValidatorServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.Stop is not implemented")
 }
 
-func (UnimplementedValidatorServiceHandler) GetChainTip(context.Context, *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetChainTip is not implemented"))
+type validatorServiceClient struct {
+	client *connect.Client
+}
+
+func (c *validatorServiceClient) GetBlockHeaderInfo(ctx context.Context, req *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error) {
+	var res v1.GetBlockHeaderInfoResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetBlockHeaderInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetBlockInfo(ctx context.Context, req *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error) {
+	var res v1.GetBlockInfoResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetBlockInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetBmmHStarCommitment(ctx context.Context, req *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error) {
+	var res v1.GetBmmHStarCommitmentResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetBmmHStarCommitmentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetChainInfo(ctx context.Context, req *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error) {
+	var res v1.GetChainInfoResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetChainInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetChainTip(ctx context.Context, req *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error) {
+	var res v1.GetChainTipResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetChainTipSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetCoinbasePSBT(ctx context.Context, req *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error) {
+	var res v1.GetCoinbasePSBTResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetCoinbasePSBTSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetCoinbasePSBT(context.Context, *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetCoinbasePSBT is not implemented"))
+func (c *validatorServiceClient) GetCtip(ctx context.Context, req *v1.GetCtipRequest) (*v1.GetCtipResponse, error) {
+	var res v1.GetCtipResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetCtipSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetCtip(context.Context, *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetCtip is not implemented"))
+func (c *validatorServiceClient) GetSidechainProposals(ctx context.Context, req *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error) {
+	var res v1.GetSidechainProposalsResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetSidechainProposalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetSidechainProposals(context.Context, *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetSidechainProposals is not implemented"))
+func (c *validatorServiceClient) GetSidechains(ctx context.Context, req *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error) {
+	var res v1.GetSidechainsResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetSidechainsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetSidechains(context.Context, *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetSidechains is not implemented"))
+func (c *validatorServiceClient) GetTwoWayPegData(ctx context.Context, req *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error) {
+	var res v1.GetTwoWayPegDataResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetTwoWayPegDataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetTwoWayPegData(context.Context, *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetTwoWayPegData is not implemented"))
+func (c *validatorServiceClient) SubscribeEvents(ctx context.Context, req *v1.SubscribeEventsRequest) (ValidatorServiceSubscribeEventsClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, validatorServiceSubscribeEventsSpec(), req)
+	if err != nil {
+		return ValidatorServiceSubscribeEventsClientStream{}, err
+	}
+	return ValidatorServiceSubscribeEventsClientStream{stream: stream}, nil
 }
 
-func (UnimplementedValidatorServiceHandler) SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.SubscribeEventsResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.SubscribeEvents is not implemented"))
+func (c *validatorServiceClient) SubscribeHeaderSyncProgress(ctx context.Context, req *v1.SubscribeHeaderSyncProgressRequest) (ValidatorServiceSubscribeHeaderSyncProgressClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, validatorServiceSubscribeHeaderSyncProgressSpec(), req)
+	if err != nil {
+		return ValidatorServiceSubscribeHeaderSyncProgressClientStream{}, err
+	}
+	return ValidatorServiceSubscribeHeaderSyncProgressClientStream{stream: stream}, nil
 }
 
-func (UnimplementedValidatorServiceHandler) SubscribeHeaderSyncProgress(context.Context, *connect.Request[v1.SubscribeHeaderSyncProgressRequest], *connect.ServerStream[v1.SubscribeHeaderSyncProgressResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.SubscribeHeaderSyncProgress is not implemented"))
+func (c *validatorServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, validatorServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedValidatorServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.Stop is not implemented"))
+type validatorServiceHandler struct{ svc ValidatorServiceHandler }
+
+func (h validatorServiceHandler) getBlockHeaderInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockHeaderInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockHeaderInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getBlockInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getBmmHStarCommitment(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmHStarCommitmentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmHStarCommitment(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getChainInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetChainInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetChainInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getChainTip(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetChainTipRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetChainTip(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getCoinbasePSBT(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetCoinbasePSBTRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCoinbasePSBT(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getCtip(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetCtipRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCtip(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getSidechainProposals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainProposalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainProposals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getSidechains(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechains(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getTwoWayPegData(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTwoWayPegDataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTwoWayPegData(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) subscribeEvents(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubscribeEventsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.SubscribeEvents(ctx, &req, ValidatorServiceSubscribeEventsServerStream{stream: stream})
+}
+
+func (h validatorServiceHandler) subscribeHeaderSyncProgress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubscribeHeaderSyncProgressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.SubscribeHeaderSyncProgress(ctx, &req, ValidatorServiceSubscribeHeaderSyncProgressServerStream{stream: stream})
+}
+
+func (h validatorServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/wallet.connect.go b/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/wallet.connect.go
index fa04055752..9e228428f6 100644
--- a/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/wallet.connect.go
+++ b/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect/wallet.connect.go
@@ -1,5 +1,3 @@
-// CUSF mainchain wallet service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/mainchain/v1/wallet.proto
@@ -7,470 +5,574 @@
 package mainchainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// WalletServiceName is the fully-qualified name of the WalletService service.
 	WalletServiceName = "cusf.mainchain.v1.WalletService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// WalletServiceBroadcastWithdrawalBundleProcedure is the fully-qualified name of the
-	// WalletService's BroadcastWithdrawalBundle RPC.
+	// WalletServiceBroadcastWithdrawalBundleProcedure is the procedure name of the WalletService's
+	// BroadcastWithdrawalBundle RPC.
 	WalletServiceBroadcastWithdrawalBundleProcedure = "/cusf.mainchain.v1.WalletService/BroadcastWithdrawalBundle"
-	// WalletServiceCreateBmmCriticalDataTransactionProcedure is the fully-qualified name of the
+	// WalletServiceCreateBmmCriticalDataTransactionProcedure is the procedure name of the
 	// WalletService's CreateBmmCriticalDataTransaction RPC.
 	WalletServiceCreateBmmCriticalDataTransactionProcedure = "/cusf.mainchain.v1.WalletService/CreateBmmCriticalDataTransaction"
-	// WalletServiceCreateDepositTransactionProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceCreateDepositTransactionProcedure is the procedure name of the WalletService's
 	// CreateDepositTransaction RPC.
 	WalletServiceCreateDepositTransactionProcedure = "/cusf.mainchain.v1.WalletService/CreateDepositTransaction"
-	// WalletServiceCreateNewAddressProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceCreateNewAddressProcedure is the procedure name of the WalletService's
 	// CreateNewAddress RPC.
 	WalletServiceCreateNewAddressProcedure = "/cusf.mainchain.v1.WalletService/CreateNewAddress"
-	// WalletServiceCreateWalletProcedure is the fully-qualified name of the WalletService's
-	// CreateWallet RPC.
+	// WalletServiceCreateWalletProcedure is the procedure name of the WalletService's CreateWallet RPC.
 	WalletServiceCreateWalletProcedure = "/cusf.mainchain.v1.WalletService/CreateWallet"
-	// WalletServiceGetBalanceProcedure is the fully-qualified name of the WalletService's GetBalance
-	// RPC.
+	// WalletServiceGetBalanceProcedure is the procedure name of the WalletService's GetBalance RPC.
 	WalletServiceGetBalanceProcedure = "/cusf.mainchain.v1.WalletService/GetBalance"
-	// WalletServiceListSidechainDepositTransactionsProcedure is the fully-qualified name of the
+	// WalletServiceListSidechainDepositTransactionsProcedure is the procedure name of the
 	// WalletService's ListSidechainDepositTransactions RPC.
 	WalletServiceListSidechainDepositTransactionsProcedure = "/cusf.mainchain.v1.WalletService/ListSidechainDepositTransactions"
-	// WalletServiceListTransactionsProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceListTransactionsProcedure is the procedure name of the WalletService's
 	// ListTransactions RPC.
 	WalletServiceListTransactionsProcedure = "/cusf.mainchain.v1.WalletService/ListTransactions"
-	// WalletServiceListUnspentOutputsProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceListUnspentOutputsProcedure is the procedure name of the WalletService's
 	// ListUnspentOutputs RPC.
 	WalletServiceListUnspentOutputsProcedure = "/cusf.mainchain.v1.WalletService/ListUnspentOutputs"
-	// WalletServiceGetInfoProcedure is the fully-qualified name of the WalletService's GetInfo RPC.
+	// WalletServiceGetInfoProcedure is the procedure name of the WalletService's GetInfo RPC.
 	WalletServiceGetInfoProcedure = "/cusf.mainchain.v1.WalletService/GetInfo"
-	// WalletServiceSendTransactionProcedure is the fully-qualified name of the WalletService's
+	// WalletServiceSendTransactionProcedure is the procedure name of the WalletService's
 	// SendTransaction RPC.
 	WalletServiceSendTransactionProcedure = "/cusf.mainchain.v1.WalletService/SendTransaction"
-	// WalletServiceUnlockWalletProcedure is the fully-qualified name of the WalletService's
-	// UnlockWallet RPC.
+	// WalletServiceUnlockWalletProcedure is the procedure name of the WalletService's UnlockWallet RPC.
 	WalletServiceUnlockWalletProcedure = "/cusf.mainchain.v1.WalletService/UnlockWallet"
-	// WalletServiceGenerateBlocksProcedure is the fully-qualified name of the WalletService's
-	// GenerateBlocks RPC.
+	// WalletServiceGenerateBlocksProcedure is the procedure name of the WalletService's GenerateBlocks
+	// RPC.
 	WalletServiceGenerateBlocksProcedure = "/cusf.mainchain.v1.WalletService/GenerateBlocks"
 )
 
+var (
+	walletServiceBroadcastWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("BroadcastWithdrawalBundle"),
+			Procedure:        WalletServiceBroadcastWithdrawalBundleProcedure,
+			IdempotencyLevel: connect.IdempotencyIdempotent,
+		}
+	})
+	walletServiceCreateBmmCriticalDataTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CreateBmmCriticalDataTransaction"),
+			Procedure:  WalletServiceCreateBmmCriticalDataTransactionProcedure,
+		}
+	})
+	walletServiceCreateDepositTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CreateDepositTransaction"),
+			Procedure:  WalletServiceCreateDepositTransactionProcedure,
+		}
+	})
+	walletServiceCreateNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CreateNewAddress"),
+			Procedure:  WalletServiceCreateNewAddressProcedure,
+		}
+	})
+	walletServiceCreateWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("CreateWallet"),
+			Procedure:  WalletServiceCreateWalletProcedure,
+		}
+	})
+	walletServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetBalance"),
+			Procedure:        WalletServiceGetBalanceProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	walletServiceListSidechainDepositTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListSidechainDepositTransactions"),
+			Procedure:        WalletServiceListSidechainDepositTransactionsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	walletServiceListTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListTransactions"),
+			Procedure:        WalletServiceListTransactionsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	walletServiceListUnspentOutputsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("ListUnspentOutputs"),
+			Procedure:        WalletServiceListUnspentOutputsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	walletServiceGetInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GetInfo"),
+			Procedure:        WalletServiceGetInfoProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	walletServiceSendTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("SendTransaction"),
+			Procedure:  WalletServiceSendTransactionProcedure,
+		}
+	})
+	walletServiceUnlockWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("UnlockWallet"),
+			Procedure:        WalletServiceUnlockWalletProcedure,
+			IdempotencyLevel: connect.IdempotencyIdempotent,
+		}
+	})
+	walletServiceGenerateBlocksSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods().ByName("GenerateBlocks"),
+			Procedure:  WalletServiceGenerateBlocksProcedure,
+		}
+	})
+)
+
 // WalletServiceClient is a client for the cusf.mainchain.v1.WalletService service.
 type WalletServiceClient interface {
-	BroadcastWithdrawalBundle(context.Context, *connect.Request[v1.BroadcastWithdrawalBundleRequest]) (*connect.Response[v1.BroadcastWithdrawalBundleResponse], error)
-	CreateBmmCriticalDataTransaction(context.Context, *connect.Request[v1.CreateBmmCriticalDataTransactionRequest]) (*connect.Response[v1.CreateBmmCriticalDataTransactionResponse], error)
-	CreateDepositTransaction(context.Context, *connect.Request[v1.CreateDepositTransactionRequest]) (*connect.Response[v1.CreateDepositTransactionResponse], error)
-	CreateNewAddress(context.Context, *connect.Request[v1.CreateNewAddressRequest]) (*connect.Response[v1.CreateNewAddressResponse], error)
-	CreateWallet(context.Context, *connect.Request[v1.CreateWalletRequest]) (*connect.Response[v1.CreateWalletResponse], error)
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	ListSidechainDepositTransactions(context.Context, *connect.Request[v1.ListSidechainDepositTransactionsRequest]) (*connect.Response[v1.ListSidechainDepositTransactionsResponse], error)
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	ListUnspentOutputs(context.Context, *connect.Request[v1.ListUnspentOutputsRequest]) (*connect.Response[v1.ListUnspentOutputsResponse], error)
-	GetInfo(context.Context, *connect.Request[v1.GetInfoRequest]) (*connect.Response[v1.GetInfoResponse], error)
-	SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error)
-	UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error)
-	// Available on regtest and signet only.
-	GenerateBlocks(context.Context, *connect.Request[v1.GenerateBlocksRequest]) (*connect.ServerStreamForClient[v1.GenerateBlocksResponse], error)
-}
-
-// NewWalletServiceClient constructs a client for the cusf.mainchain.v1.WalletService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewWalletServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) WalletServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	walletServiceMethods := v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods()
-	return &walletServiceClient{
-		broadcastWithdrawalBundle: connect.NewClient[v1.BroadcastWithdrawalBundleRequest, v1.BroadcastWithdrawalBundleResponse](
-			httpClient,
-			baseURL+WalletServiceBroadcastWithdrawalBundleProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("BroadcastWithdrawalBundle")),
-			connect.WithIdempotency(connect.IdempotencyIdempotent),
-			connect.WithClientOptions(opts...),
-		),
-		createBmmCriticalDataTransaction: connect.NewClient[v1.CreateBmmCriticalDataTransactionRequest, v1.CreateBmmCriticalDataTransactionResponse](
-			httpClient,
-			baseURL+WalletServiceCreateBmmCriticalDataTransactionProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CreateBmmCriticalDataTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		createDepositTransaction: connect.NewClient[v1.CreateDepositTransactionRequest, v1.CreateDepositTransactionResponse](
-			httpClient,
-			baseURL+WalletServiceCreateDepositTransactionProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CreateDepositTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		createNewAddress: connect.NewClient[v1.CreateNewAddressRequest, v1.CreateNewAddressResponse](
-			httpClient,
-			baseURL+WalletServiceCreateNewAddressProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CreateNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		createWallet: connect.NewClient[v1.CreateWalletRequest, v1.CreateWalletResponse](
-			httpClient,
-			baseURL+WalletServiceCreateWalletProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("CreateWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+WalletServiceGetBalanceProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetBalance")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		listSidechainDepositTransactions: connect.NewClient[v1.ListSidechainDepositTransactionsRequest, v1.ListSidechainDepositTransactionsResponse](
-			httpClient,
-			baseURL+WalletServiceListSidechainDepositTransactionsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListSidechainDepositTransactions")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		listTransactions: connect.NewClient[v1.ListTransactionsRequest, v1.ListTransactionsResponse](
-			httpClient,
-			baseURL+WalletServiceListTransactionsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListTransactions")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		listUnspentOutputs: connect.NewClient[v1.ListUnspentOutputsRequest, v1.ListUnspentOutputsResponse](
-			httpClient,
-			baseURL+WalletServiceListUnspentOutputsProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("ListUnspentOutputs")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getInfo: connect.NewClient[v1.GetInfoRequest, v1.GetInfoResponse](
-			httpClient,
-			baseURL+WalletServiceGetInfoProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GetInfo")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		sendTransaction: connect.NewClient[v1.SendTransactionRequest, v1.SendTransactionResponse](
-			httpClient,
-			baseURL+WalletServiceSendTransactionProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("SendTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		unlockWallet: connect.NewClient[v1.UnlockWalletRequest, v1.UnlockWalletResponse](
-			httpClient,
-			baseURL+WalletServiceUnlockWalletProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("UnlockWallet")),
-			connect.WithIdempotency(connect.IdempotencyIdempotent),
-			connect.WithClientOptions(opts...),
-		),
-		generateBlocks: connect.NewClient[v1.GenerateBlocksRequest, v1.GenerateBlocksResponse](
-			httpClient,
-			baseURL+WalletServiceGenerateBlocksProcedure,
-			connect.WithSchema(walletServiceMethods.ByName("GenerateBlocks")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// walletServiceClient implements WalletServiceClient.
-type walletServiceClient struct {
-	broadcastWithdrawalBundle        *connect.Client[v1.BroadcastWithdrawalBundleRequest, v1.BroadcastWithdrawalBundleResponse]
-	createBmmCriticalDataTransaction *connect.Client[v1.CreateBmmCriticalDataTransactionRequest, v1.CreateBmmCriticalDataTransactionResponse]
-	createDepositTransaction         *connect.Client[v1.CreateDepositTransactionRequest, v1.CreateDepositTransactionResponse]
-	createNewAddress                 *connect.Client[v1.CreateNewAddressRequest, v1.CreateNewAddressResponse]
-	createWallet                     *connect.Client[v1.CreateWalletRequest, v1.CreateWalletResponse]
-	getBalance                       *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	listSidechainDepositTransactions *connect.Client[v1.ListSidechainDepositTransactionsRequest, v1.ListSidechainDepositTransactionsResponse]
-	listTransactions                 *connect.Client[v1.ListTransactionsRequest, v1.ListTransactionsResponse]
-	listUnspentOutputs               *connect.Client[v1.ListUnspentOutputsRequest, v1.ListUnspentOutputsResponse]
-	getInfo                          *connect.Client[v1.GetInfoRequest, v1.GetInfoResponse]
-	sendTransaction                  *connect.Client[v1.SendTransactionRequest, v1.SendTransactionResponse]
-	unlockWallet                     *connect.Client[v1.UnlockWalletRequest, v1.UnlockWalletResponse]
-	generateBlocks                   *connect.Client[v1.GenerateBlocksRequest, v1.GenerateBlocksResponse]
+	BroadcastWithdrawalBundle(context.Context, *v1.BroadcastWithdrawalBundleRequest) (*v1.BroadcastWithdrawalBundleResponse, error)
+	CreateBmmCriticalDataTransaction(context.Context, *v1.CreateBmmCriticalDataTransactionRequest) (*v1.CreateBmmCriticalDataTransactionResponse, error)
+	CreateDepositTransaction(context.Context, *v1.CreateDepositTransactionRequest) (*v1.CreateDepositTransactionResponse, error)
+	CreateNewAddress(context.Context, *v1.CreateNewAddressRequest) (*v1.CreateNewAddressResponse, error)
+	CreateWallet(context.Context, *v1.CreateWalletRequest) (*v1.CreateWalletResponse, error)
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	ListSidechainDepositTransactions(context.Context, *v1.ListSidechainDepositTransactionsRequest) (*v1.ListSidechainDepositTransactionsResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	ListUnspentOutputs(context.Context, *v1.ListUnspentOutputsRequest) (*v1.ListUnspentOutputsResponse, error)
+	GetInfo(context.Context, *v1.GetInfoRequest) (*v1.GetInfoResponse, error)
+	SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error)
+	UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error)
+	GenerateBlocks(context.Context, *v1.GenerateBlocksRequest) (WalletServiceGenerateBlocksClientStream, error)
+}
+
+// NewWalletServiceClient constructs a client for the cusf.mainchain.v1.WalletService service.
+// Multiple service clients may share a single connect.Client.
+func NewWalletServiceClient(client *connect.Client) WalletServiceClient {
+	return &walletServiceClient{client: client}
 }
 
-// BroadcastWithdrawalBundle calls cusf.mainchain.v1.WalletService.BroadcastWithdrawalBundle.
-func (c *walletServiceClient) BroadcastWithdrawalBundle(ctx context.Context, req *connect.Request[v1.BroadcastWithdrawalBundleRequest]) (*connect.Response[v1.BroadcastWithdrawalBundleResponse], error) {
-	return c.broadcastWithdrawalBundle.CallUnary(ctx, req)
+// WalletServiceGenerateBlocksClientStream is the client stream for the WalletService's
+// GenerateBlocks RPC.
+type WalletServiceGenerateBlocksClientStream struct {
+	stream connect.ClientStream
 }
 
-// CreateBmmCriticalDataTransaction calls
-// cusf.mainchain.v1.WalletService.CreateBmmCriticalDataTransaction.
-func (c *walletServiceClient) CreateBmmCriticalDataTransaction(ctx context.Context, req *connect.Request[v1.CreateBmmCriticalDataTransactionRequest]) (*connect.Response[v1.CreateBmmCriticalDataTransactionResponse], error) {
-	return c.createBmmCriticalDataTransaction.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s WalletServiceGenerateBlocksClientStream) Receive() (*v1.GenerateBlocksResponse, error) {
+	var res v1.GenerateBlocksResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// CreateDepositTransaction calls cusf.mainchain.v1.WalletService.CreateDepositTransaction.
-func (c *walletServiceClient) CreateDepositTransaction(ctx context.Context, req *connect.Request[v1.CreateDepositTransactionRequest]) (*connect.Response[v1.CreateDepositTransactionResponse], error) {
-	return c.createDepositTransaction.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s WalletServiceGenerateBlocksClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// CreateNewAddress calls cusf.mainchain.v1.WalletService.CreateNewAddress.
-func (c *walletServiceClient) CreateNewAddress(ctx context.Context, req *connect.Request[v1.CreateNewAddressRequest]) (*connect.Response[v1.CreateNewAddressResponse], error) {
-	return c.createNewAddress.CallUnary(ctx, req)
+// WalletServiceHandler is an implementation of the cusf.mainchain.v1.WalletService service.
+type WalletServiceHandler interface {
+	BroadcastWithdrawalBundle(context.Context, *v1.BroadcastWithdrawalBundleRequest) (*v1.BroadcastWithdrawalBundleResponse, error)
+	CreateBmmCriticalDataTransaction(context.Context, *v1.CreateBmmCriticalDataTransactionRequest) (*v1.CreateBmmCriticalDataTransactionResponse, error)
+	CreateDepositTransaction(context.Context, *v1.CreateDepositTransactionRequest) (*v1.CreateDepositTransactionResponse, error)
+	CreateNewAddress(context.Context, *v1.CreateNewAddressRequest) (*v1.CreateNewAddressResponse, error)
+	CreateWallet(context.Context, *v1.CreateWalletRequest) (*v1.CreateWalletResponse, error)
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	ListSidechainDepositTransactions(context.Context, *v1.ListSidechainDepositTransactionsRequest) (*v1.ListSidechainDepositTransactionsResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	ListUnspentOutputs(context.Context, *v1.ListUnspentOutputsRequest) (*v1.ListUnspentOutputsResponse, error)
+	GetInfo(context.Context, *v1.GetInfoRequest) (*v1.GetInfoResponse, error)
+	SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error)
+	UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error)
+	GenerateBlocks(context.Context, *v1.GenerateBlocksRequest, WalletServiceGenerateBlocksServerStream) error
 }
 
-// CreateWallet calls cusf.mainchain.v1.WalletService.CreateWallet.
-func (c *walletServiceClient) CreateWallet(ctx context.Context, req *connect.Request[v1.CreateWalletRequest]) (*connect.Response[v1.CreateWalletResponse], error) {
-	return c.createWallet.CallUnary(ctx, req)
+// RegisterWalletServiceHandler registers svc as the cusf.mainchain.v1.WalletService implementation
+// on server.
+func RegisterWalletServiceHandler(server *connect.Server, svc WalletServiceHandler) {
+	adapter := walletServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: walletServiceBroadcastWithdrawalBundleSpec(), Handler: adapter.broadcastWithdrawalBundle},
+		connect.Method{Spec: walletServiceCreateBmmCriticalDataTransactionSpec(), Handler: adapter.createBmmCriticalDataTransaction},
+		connect.Method{Spec: walletServiceCreateDepositTransactionSpec(), Handler: adapter.createDepositTransaction},
+		connect.Method{Spec: walletServiceCreateNewAddressSpec(), Handler: adapter.createNewAddress},
+		connect.Method{Spec: walletServiceCreateWalletSpec(), Handler: adapter.createWallet},
+		connect.Method{Spec: walletServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: walletServiceListSidechainDepositTransactionsSpec(), Handler: adapter.listSidechainDepositTransactions},
+		connect.Method{Spec: walletServiceListTransactionsSpec(), Handler: adapter.listTransactions},
+		connect.Method{Spec: walletServiceListUnspentOutputsSpec(), Handler: adapter.listUnspentOutputs},
+		connect.Method{Spec: walletServiceGetInfoSpec(), Handler: adapter.getInfo},
+		connect.Method{Spec: walletServiceSendTransactionSpec(), Handler: adapter.sendTransaction},
+		connect.Method{Spec: walletServiceUnlockWalletSpec(), Handler: adapter.unlockWallet},
+		connect.Method{Spec: walletServiceGenerateBlocksSpec(), Handler: adapter.generateBlocks},
+	)
 }
 
-// GetBalance calls cusf.mainchain.v1.WalletService.GetBalance.
-func (c *walletServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// WalletServiceGenerateBlocksServerStream is the server stream for the WalletService's
+// GenerateBlocks RPC.
+type WalletServiceGenerateBlocksServerStream struct {
+	stream connect.ServerStream
 }
 
-// ListSidechainDepositTransactions calls
-// cusf.mainchain.v1.WalletService.ListSidechainDepositTransactions.
-func (c *walletServiceClient) ListSidechainDepositTransactions(ctx context.Context, req *connect.Request[v1.ListSidechainDepositTransactionsRequest]) (*connect.Response[v1.ListSidechainDepositTransactionsResponse], error) {
-	return c.listSidechainDepositTransactions.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s WalletServiceGenerateBlocksServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// ListTransactions calls cusf.mainchain.v1.WalletService.ListTransactions.
-func (c *walletServiceClient) ListTransactions(ctx context.Context, req *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return c.listTransactions.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s WalletServiceGenerateBlocksServerStream) Send(res *v1.GenerateBlocksResponse) error {
+	return s.stream.Send(res)
 }
 
-// ListUnspentOutputs calls cusf.mainchain.v1.WalletService.ListUnspentOutputs.
-func (c *walletServiceClient) ListUnspentOutputs(ctx context.Context, req *connect.Request[v1.ListUnspentOutputsRequest]) (*connect.Response[v1.ListUnspentOutputsResponse], error) {
-	return c.listUnspentOutputs.CallUnary(ctx, req)
+// UnimplementedWalletServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedWalletServiceHandler struct{}
+
+func (UnimplementedWalletServiceHandler) BroadcastWithdrawalBundle(context.Context, *v1.BroadcastWithdrawalBundleRequest) (*v1.BroadcastWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.BroadcastWithdrawalBundle is not implemented")
 }
 
-// GetInfo calls cusf.mainchain.v1.WalletService.GetInfo.
-func (c *walletServiceClient) GetInfo(ctx context.Context, req *connect.Request[v1.GetInfoRequest]) (*connect.Response[v1.GetInfoResponse], error) {
-	return c.getInfo.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) CreateBmmCriticalDataTransaction(context.Context, *v1.CreateBmmCriticalDataTransactionRequest) (*v1.CreateBmmCriticalDataTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.CreateBmmCriticalDataTransaction is not implemented")
 }
 
-// SendTransaction calls cusf.mainchain.v1.WalletService.SendTransaction.
-func (c *walletServiceClient) SendTransaction(ctx context.Context, req *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error) {
-	return c.sendTransaction.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) CreateDepositTransaction(context.Context, *v1.CreateDepositTransactionRequest) (*v1.CreateDepositTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.CreateDepositTransaction is not implemented")
 }
 
-// UnlockWallet calls cusf.mainchain.v1.WalletService.UnlockWallet.
-func (c *walletServiceClient) UnlockWallet(ctx context.Context, req *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error) {
-	return c.unlockWallet.CallUnary(ctx, req)
+func (UnimplementedWalletServiceHandler) CreateNewAddress(context.Context, *v1.CreateNewAddressRequest) (*v1.CreateNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.CreateNewAddress is not implemented")
 }
 
-// GenerateBlocks calls cusf.mainchain.v1.WalletService.GenerateBlocks.
-func (c *walletServiceClient) GenerateBlocks(ctx context.Context, req *connect.Request[v1.GenerateBlocksRequest]) (*connect.ServerStreamForClient[v1.GenerateBlocksResponse], error) {
-	return c.generateBlocks.CallServerStream(ctx, req)
+func (UnimplementedWalletServiceHandler) CreateWallet(context.Context, *v1.CreateWalletRequest) (*v1.CreateWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.CreateWallet is not implemented")
 }
 
-// WalletServiceHandler is an implementation of the cusf.mainchain.v1.WalletService service.
-type WalletServiceHandler interface {
-	BroadcastWithdrawalBundle(context.Context, *connect.Request[v1.BroadcastWithdrawalBundleRequest]) (*connect.Response[v1.BroadcastWithdrawalBundleResponse], error)
-	CreateBmmCriticalDataTransaction(context.Context, *connect.Request[v1.CreateBmmCriticalDataTransactionRequest]) (*connect.Response[v1.CreateBmmCriticalDataTransactionResponse], error)
-	CreateDepositTransaction(context.Context, *connect.Request[v1.CreateDepositTransactionRequest]) (*connect.Response[v1.CreateDepositTransactionResponse], error)
-	CreateNewAddress(context.Context, *connect.Request[v1.CreateNewAddressRequest]) (*connect.Response[v1.CreateNewAddressResponse], error)
-	CreateWallet(context.Context, *connect.Request[v1.CreateWalletRequest]) (*connect.Response[v1.CreateWalletResponse], error)
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	ListSidechainDepositTransactions(context.Context, *connect.Request[v1.ListSidechainDepositTransactionsRequest]) (*connect.Response[v1.ListSidechainDepositTransactionsResponse], error)
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	ListUnspentOutputs(context.Context, *connect.Request[v1.ListUnspentOutputsRequest]) (*connect.Response[v1.ListUnspentOutputsResponse], error)
-	GetInfo(context.Context, *connect.Request[v1.GetInfoRequest]) (*connect.Response[v1.GetInfoResponse], error)
-	SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error)
-	UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error)
-	// Available on regtest and signet only.
-	GenerateBlocks(context.Context, *connect.Request[v1.GenerateBlocksRequest], *connect.ServerStream[v1.GenerateBlocksResponse]) error
-}
-
-// NewWalletServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewWalletServiceHandler(svc WalletServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	walletServiceMethods := v1.File_cusf_mainchain_v1_wallet_proto.Services().ByName("WalletService").Methods()
-	walletServiceBroadcastWithdrawalBundleHandler := connect.NewUnaryHandler(
-		WalletServiceBroadcastWithdrawalBundleProcedure,
-		svc.BroadcastWithdrawalBundle,
-		connect.WithSchema(walletServiceMethods.ByName("BroadcastWithdrawalBundle")),
-		connect.WithIdempotency(connect.IdempotencyIdempotent),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCreateBmmCriticalDataTransactionHandler := connect.NewUnaryHandler(
-		WalletServiceCreateBmmCriticalDataTransactionProcedure,
-		svc.CreateBmmCriticalDataTransaction,
-		connect.WithSchema(walletServiceMethods.ByName("CreateBmmCriticalDataTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCreateDepositTransactionHandler := connect.NewUnaryHandler(
-		WalletServiceCreateDepositTransactionProcedure,
-		svc.CreateDepositTransaction,
-		connect.WithSchema(walletServiceMethods.ByName("CreateDepositTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCreateNewAddressHandler := connect.NewUnaryHandler(
-		WalletServiceCreateNewAddressProcedure,
-		svc.CreateNewAddress,
-		connect.WithSchema(walletServiceMethods.ByName("CreateNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceCreateWalletHandler := connect.NewUnaryHandler(
-		WalletServiceCreateWalletProcedure,
-		svc.CreateWallet,
-		connect.WithSchema(walletServiceMethods.ByName("CreateWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetBalanceHandler := connect.NewUnaryHandler(
-		WalletServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(walletServiceMethods.ByName("GetBalance")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListSidechainDepositTransactionsHandler := connect.NewUnaryHandler(
-		WalletServiceListSidechainDepositTransactionsProcedure,
-		svc.ListSidechainDepositTransactions,
-		connect.WithSchema(walletServiceMethods.ByName("ListSidechainDepositTransactions")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListTransactionsHandler := connect.NewUnaryHandler(
-		WalletServiceListTransactionsProcedure,
-		svc.ListTransactions,
-		connect.WithSchema(walletServiceMethods.ByName("ListTransactions")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceListUnspentOutputsHandler := connect.NewUnaryHandler(
-		WalletServiceListUnspentOutputsProcedure,
-		svc.ListUnspentOutputs,
-		connect.WithSchema(walletServiceMethods.ByName("ListUnspentOutputs")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGetInfoHandler := connect.NewUnaryHandler(
-		WalletServiceGetInfoProcedure,
-		svc.GetInfo,
-		connect.WithSchema(walletServiceMethods.ByName("GetInfo")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceSendTransactionHandler := connect.NewUnaryHandler(
-		WalletServiceSendTransactionProcedure,
-		svc.SendTransaction,
-		connect.WithSchema(walletServiceMethods.ByName("SendTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceUnlockWalletHandler := connect.NewUnaryHandler(
-		WalletServiceUnlockWalletProcedure,
-		svc.UnlockWallet,
-		connect.WithSchema(walletServiceMethods.ByName("UnlockWallet")),
-		connect.WithIdempotency(connect.IdempotencyIdempotent),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletServiceGenerateBlocksHandler := connect.NewServerStreamHandler(
-		WalletServiceGenerateBlocksProcedure,
-		svc.GenerateBlocks,
-		connect.WithSchema(walletServiceMethods.ByName("GenerateBlocks")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.mainchain.v1.WalletService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case WalletServiceBroadcastWithdrawalBundleProcedure:
-			walletServiceBroadcastWithdrawalBundleHandler.ServeHTTP(w, r)
-		case WalletServiceCreateBmmCriticalDataTransactionProcedure:
-			walletServiceCreateBmmCriticalDataTransactionHandler.ServeHTTP(w, r)
-		case WalletServiceCreateDepositTransactionProcedure:
-			walletServiceCreateDepositTransactionHandler.ServeHTTP(w, r)
-		case WalletServiceCreateNewAddressProcedure:
-			walletServiceCreateNewAddressHandler.ServeHTTP(w, r)
-		case WalletServiceCreateWalletProcedure:
-			walletServiceCreateWalletHandler.ServeHTTP(w, r)
-		case WalletServiceGetBalanceProcedure:
-			walletServiceGetBalanceHandler.ServeHTTP(w, r)
-		case WalletServiceListSidechainDepositTransactionsProcedure:
-			walletServiceListSidechainDepositTransactionsHandler.ServeHTTP(w, r)
-		case WalletServiceListTransactionsProcedure:
-			walletServiceListTransactionsHandler.ServeHTTP(w, r)
-		case WalletServiceListUnspentOutputsProcedure:
-			walletServiceListUnspentOutputsHandler.ServeHTTP(w, r)
-		case WalletServiceGetInfoProcedure:
-			walletServiceGetInfoHandler.ServeHTTP(w, r)
-		case WalletServiceSendTransactionProcedure:
-			walletServiceSendTransactionHandler.ServeHTTP(w, r)
-		case WalletServiceUnlockWalletProcedure:
-			walletServiceUnlockWalletHandler.ServeHTTP(w, r)
-		case WalletServiceGenerateBlocksProcedure:
-			walletServiceGenerateBlocksHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedWalletServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.GetBalance is not implemented")
 }
 
-// UnimplementedWalletServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedWalletServiceHandler struct{}
+func (UnimplementedWalletServiceHandler) ListSidechainDepositTransactions(context.Context, *v1.ListSidechainDepositTransactionsRequest) (*v1.ListSidechainDepositTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.ListSidechainDepositTransactions is not implemented")
+}
+
+func (UnimplementedWalletServiceHandler) ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.ListTransactions is not implemented")
+}
+
+func (UnimplementedWalletServiceHandler) ListUnspentOutputs(context.Context, *v1.ListUnspentOutputsRequest) (*v1.ListUnspentOutputsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.ListUnspentOutputs is not implemented")
+}
+
+func (UnimplementedWalletServiceHandler) GetInfo(context.Context, *v1.GetInfoRequest) (*v1.GetInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.GetInfo is not implemented")
+}
+
+func (UnimplementedWalletServiceHandler) SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.SendTransaction is not implemented")
+}
 
-func (UnimplementedWalletServiceHandler) BroadcastWithdrawalBundle(context.Context, *connect.Request[v1.BroadcastWithdrawalBundleRequest]) (*connect.Response[v1.BroadcastWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.BroadcastWithdrawalBundle is not implemented"))
+func (UnimplementedWalletServiceHandler) UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.UnlockWallet is not implemented")
 }
 
-func (UnimplementedWalletServiceHandler) CreateBmmCriticalDataTransaction(context.Context, *connect.Request[v1.CreateBmmCriticalDataTransactionRequest]) (*connect.Response[v1.CreateBmmCriticalDataTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.CreateBmmCriticalDataTransaction is not implemented"))
+func (UnimplementedWalletServiceHandler) GenerateBlocks(context.Context, *v1.GenerateBlocksRequest, WalletServiceGenerateBlocksServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.WalletService.GenerateBlocks is not implemented")
 }
 
-func (UnimplementedWalletServiceHandler) CreateDepositTransaction(context.Context, *connect.Request[v1.CreateDepositTransactionRequest]) (*connect.Response[v1.CreateDepositTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.CreateDepositTransaction is not implemented"))
+type walletServiceClient struct {
+	client *connect.Client
+}
+
+func (c *walletServiceClient) BroadcastWithdrawalBundle(ctx context.Context, req *v1.BroadcastWithdrawalBundleRequest) (*v1.BroadcastWithdrawalBundleResponse, error) {
+	var res v1.BroadcastWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, walletServiceBroadcastWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CreateBmmCriticalDataTransaction(ctx context.Context, req *v1.CreateBmmCriticalDataTransactionRequest) (*v1.CreateBmmCriticalDataTransactionResponse, error) {
+	var res v1.CreateBmmCriticalDataTransactionResponse
+	if err := c.client.CallUnary(ctx, walletServiceCreateBmmCriticalDataTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CreateDepositTransaction(ctx context.Context, req *v1.CreateDepositTransactionRequest) (*v1.CreateDepositTransactionResponse, error) {
+	var res v1.CreateDepositTransactionResponse
+	if err := c.client.CallUnary(ctx, walletServiceCreateDepositTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CreateNewAddress(ctx context.Context, req *v1.CreateNewAddressRequest) (*v1.CreateNewAddressResponse, error) {
+	var res v1.CreateNewAddressResponse
+	if err := c.client.CallUnary(ctx, walletServiceCreateNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) CreateWallet(ctx context.Context, req *v1.CreateWalletRequest) (*v1.CreateWalletResponse, error) {
+	var res v1.CreateWalletResponse
+	if err := c.client.CallUnary(ctx, walletServiceCreateWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) ListSidechainDepositTransactions(ctx context.Context, req *v1.ListSidechainDepositTransactionsRequest) (*v1.ListSidechainDepositTransactionsResponse, error) {
+	var res v1.ListSidechainDepositTransactionsResponse
+	if err := c.client.CallUnary(ctx, walletServiceListSidechainDepositTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) ListTransactions(ctx context.Context, req *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	var res v1.ListTransactionsResponse
+	if err := c.client.CallUnary(ctx, walletServiceListTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) ListUnspentOutputs(ctx context.Context, req *v1.ListUnspentOutputsRequest) (*v1.ListUnspentOutputsResponse, error) {
+	var res v1.ListUnspentOutputsResponse
+	if err := c.client.CallUnary(ctx, walletServiceListUnspentOutputsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GetInfo(ctx context.Context, req *v1.GetInfoRequest) (*v1.GetInfoResponse, error) {
+	var res v1.GetInfoResponse
+	if err := c.client.CallUnary(ctx, walletServiceGetInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) SendTransaction(ctx context.Context, req *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error) {
+	var res v1.SendTransactionResponse
+	if err := c.client.CallUnary(ctx, walletServiceSendTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) UnlockWallet(ctx context.Context, req *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error) {
+	var res v1.UnlockWalletResponse
+	if err := c.client.CallUnary(ctx, walletServiceUnlockWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletServiceClient) GenerateBlocks(ctx context.Context, req *v1.GenerateBlocksRequest) (WalletServiceGenerateBlocksClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, walletServiceGenerateBlocksSpec(), req)
+	if err != nil {
+		return WalletServiceGenerateBlocksClientStream{}, err
+	}
+	return WalletServiceGenerateBlocksClientStream{stream: stream}, nil
+}
+
+type walletServiceHandler struct{ svc WalletServiceHandler }
+
+func (h walletServiceHandler) broadcastWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BroadcastWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BroadcastWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) CreateNewAddress(context.Context, *connect.Request[v1.CreateNewAddressRequest]) (*connect.Response[v1.CreateNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.CreateNewAddress is not implemented"))
+func (h walletServiceHandler) createBmmCriticalDataTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateBmmCriticalDataTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateBmmCriticalDataTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletServiceHandler) createDepositTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDepositTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletServiceHandler) createNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) CreateWallet(context.Context, *connect.Request[v1.CreateWalletRequest]) (*connect.Response[v1.CreateWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.CreateWallet is not implemented"))
+func (h walletServiceHandler) createWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.GetBalance is not implemented"))
+func (h walletServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListSidechainDepositTransactions(context.Context, *connect.Request[v1.ListSidechainDepositTransactionsRequest]) (*connect.Response[v1.ListSidechainDepositTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.ListSidechainDepositTransactions is not implemented"))
+func (h walletServiceHandler) listSidechainDepositTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSidechainDepositTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSidechainDepositTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.ListTransactions is not implemented"))
+func (h walletServiceHandler) listTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) ListUnspentOutputs(context.Context, *connect.Request[v1.ListUnspentOutputsRequest]) (*connect.Response[v1.ListUnspentOutputsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.ListUnspentOutputs is not implemented"))
+func (h walletServiceHandler) listUnspentOutputs(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUnspentOutputsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUnspentOutputs(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GetInfo(context.Context, *connect.Request[v1.GetInfoRequest]) (*connect.Response[v1.GetInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.GetInfo is not implemented"))
+func (h walletServiceHandler) getInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.SendTransaction is not implemented"))
+func (h walletServiceHandler) sendTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SendTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SendTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.UnlockWallet is not implemented"))
+func (h walletServiceHandler) unlockWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UnlockWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UnlockWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletServiceHandler) GenerateBlocks(context.Context, *connect.Request[v1.GenerateBlocksRequest], *connect.ServerStream[v1.GenerateBlocksResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.WalletService.GenerateBlocks is not implemented"))
+func (h walletServiceHandler) generateBlocks(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateBlocksRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.GenerateBlocks(ctx, &req, WalletServiceGenerateBlocksServerStream{stream: stream})
 }
diff --git a/dc-hub/server/gen/explorer/v1/explorerv1connect/explorer.connect.go b/dc-hub/server/gen/explorer/v1/explorerv1connect/explorer.connect.go
index f2ba30efc7..78843c4007 100644
--- a/dc-hub/server/gen/explorer/v1/explorerv1connect/explorer.connect.go
+++ b/dc-hub/server/gen/explorer/v1/explorerv1connect/explorer.connect.go
@@ -5,136 +5,131 @@
 package explorerv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/explorer/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ExplorerServiceName is the fully-qualified name of the ExplorerService service.
 	ExplorerServiceName = "explorer.v1.ExplorerService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ExplorerServiceGetChainTipsProcedure is the fully-qualified name of the ExplorerService's
-	// GetChainTips RPC.
+	// ExplorerServiceGetChainTipsProcedure is the procedure name of the ExplorerService's GetChainTips
+	// RPC.
 	ExplorerServiceGetChainTipsProcedure = "/explorer.v1.ExplorerService/GetChainTips"
-	// ExplorerServiceListSidechainsProcedure is the fully-qualified name of the ExplorerService's
+	// ExplorerServiceListSidechainsProcedure is the procedure name of the ExplorerService's
 	// ListSidechains RPC.
 	ExplorerServiceListSidechainsProcedure = "/explorer.v1.ExplorerService/ListSidechains"
 )
 
+var (
+	explorerServiceGetChainTipsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("GetChainTips"),
+			Procedure:  ExplorerServiceGetChainTipsProcedure,
+		}
+	})
+	explorerServiceListSidechainsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("ListSidechains"),
+			Procedure:  ExplorerServiceListSidechainsProcedure,
+		}
+	})
+)
+
 // ExplorerServiceClient is a client for the explorer.v1.ExplorerService service.
 type ExplorerServiceClient interface {
-	GetChainTips(context.Context, *connect.Request[v1.GetChainTipsRequest]) (*connect.Response[v1.GetChainTipsResponse], error)
-	// Lists active and proposed side chains.
-	ListSidechains(context.Context, *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error)
+	GetChainTips(context.Context, *v1.GetChainTipsRequest) (*v1.GetChainTipsResponse, error)
+	ListSidechains(context.Context, *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error)
 }
 
-// NewExplorerServiceClient constructs a client for the explorer.v1.ExplorerService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewExplorerServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ExplorerServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	explorerServiceMethods := v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods()
-	return &explorerServiceClient{
-		getChainTips: connect.NewClient[v1.GetChainTipsRequest, v1.GetChainTipsResponse](
-			httpClient,
-			baseURL+ExplorerServiceGetChainTipsProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("GetChainTips")),
-			connect.WithClientOptions(opts...),
-		),
-		listSidechains: connect.NewClient[v1.ListSidechainsRequest, v1.ListSidechainsResponse](
-			httpClient,
-			baseURL+ExplorerServiceListSidechainsProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("ListSidechains")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// NewExplorerServiceClient constructs a client for the explorer.v1.ExplorerService service.
+// Multiple service clients may share a single connect.Client.
+func NewExplorerServiceClient(client *connect.Client) ExplorerServiceClient {
+	return &explorerServiceClient{client: client}
 }
 
-// explorerServiceClient implements ExplorerServiceClient.
-type explorerServiceClient struct {
-	getChainTips   *connect.Client[v1.GetChainTipsRequest, v1.GetChainTipsResponse]
-	listSidechains *connect.Client[v1.ListSidechainsRequest, v1.ListSidechainsResponse]
+// ExplorerServiceHandler is an implementation of the explorer.v1.ExplorerService service.
+type ExplorerServiceHandler interface {
+	GetChainTips(context.Context, *v1.GetChainTipsRequest) (*v1.GetChainTipsResponse, error)
+	ListSidechains(context.Context, *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error)
 }
 
-// GetChainTips calls explorer.v1.ExplorerService.GetChainTips.
-func (c *explorerServiceClient) GetChainTips(ctx context.Context, req *connect.Request[v1.GetChainTipsRequest]) (*connect.Response[v1.GetChainTipsResponse], error) {
-	return c.getChainTips.CallUnary(ctx, req)
+// RegisterExplorerServiceHandler registers svc as the explorer.v1.ExplorerService implementation on
+// server.
+func RegisterExplorerServiceHandler(server *connect.Server, svc ExplorerServiceHandler) {
+	adapter := explorerServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: explorerServiceGetChainTipsSpec(), Handler: adapter.getChainTips},
+		connect.Method{Spec: explorerServiceListSidechainsSpec(), Handler: adapter.listSidechains},
+	)
 }
 
-// ListSidechains calls explorer.v1.ExplorerService.ListSidechains.
-func (c *explorerServiceClient) ListSidechains(ctx context.Context, req *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error) {
-	return c.listSidechains.CallUnary(ctx, req)
+// UnimplementedExplorerServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedExplorerServiceHandler struct{}
+
+func (UnimplementedExplorerServiceHandler) GetChainTips(context.Context, *v1.GetChainTipsRequest) (*v1.GetChainTipsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.GetChainTips is not implemented")
 }
 
-// ExplorerServiceHandler is an implementation of the explorer.v1.ExplorerService service.
-type ExplorerServiceHandler interface {
-	GetChainTips(context.Context, *connect.Request[v1.GetChainTipsRequest]) (*connect.Response[v1.GetChainTipsResponse], error)
-	// Lists active and proposed side chains.
-	ListSidechains(context.Context, *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error)
+func (UnimplementedExplorerServiceHandler) ListSidechains(context.Context, *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.ListSidechains is not implemented")
 }
 
-// NewExplorerServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewExplorerServiceHandler(svc ExplorerServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	explorerServiceMethods := v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods()
-	explorerServiceGetChainTipsHandler := connect.NewUnaryHandler(
-		ExplorerServiceGetChainTipsProcedure,
-		svc.GetChainTips,
-		connect.WithSchema(explorerServiceMethods.ByName("GetChainTips")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceListSidechainsHandler := connect.NewUnaryHandler(
-		ExplorerServiceListSidechainsProcedure,
-		svc.ListSidechains,
-		connect.WithSchema(explorerServiceMethods.ByName("ListSidechains")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/explorer.v1.ExplorerService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ExplorerServiceGetChainTipsProcedure:
-			explorerServiceGetChainTipsHandler.ServeHTTP(w, r)
-		case ExplorerServiceListSidechainsProcedure:
-			explorerServiceListSidechainsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type explorerServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedExplorerServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedExplorerServiceHandler struct{}
+func (c *explorerServiceClient) GetChainTips(ctx context.Context, req *v1.GetChainTipsRequest) (*v1.GetChainTipsResponse, error) {
+	var res v1.GetChainTipsResponse
+	if err := c.client.CallUnary(ctx, explorerServiceGetChainTipsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedExplorerServiceHandler) GetChainTips(context.Context, *connect.Request[v1.GetChainTipsRequest]) (*connect.Response[v1.GetChainTipsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.GetChainTips is not implemented"))
+func (c *explorerServiceClient) ListSidechains(ctx context.Context, req *v1.ListSidechainsRequest) (*v1.ListSidechainsResponse, error) {
+	var res v1.ListSidechainsResponse
+	if err := c.client.CallUnary(ctx, explorerServiceListSidechainsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) ListSidechains(context.Context, *connect.Request[v1.ListSidechainsRequest]) (*connect.Response[v1.ListSidechainsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.ListSidechains is not implemented"))
+type explorerServiceHandler struct{ svc ExplorerServiceHandler }
+
+func (h explorerServiceHandler) getChainTips(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetChainTipsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetChainTips(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) listSidechains(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSidechainsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSidechains(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/dc-hub/server/gen/hub/v1/hubv1connect/faucet.connect.go b/dc-hub/server/gen/hub/v1/hubv1connect/faucet.connect.go
index 5ddae51ee7..1832f90054 100644
--- a/dc-hub/server/gen/hub/v1/hubv1connect/faucet.connect.go
+++ b/dc-hub/server/gen/hub/v1/hubv1connect/faucet.connect.go
@@ -5,162 +5,165 @@
 package hubv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/hub/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// FaucetServiceName is the fully-qualified name of the FaucetService service.
 	FaucetServiceName = "hub.v1.FaucetService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// FaucetServiceDispenseCoinsProcedure is the fully-qualified name of the FaucetService's
-	// DispenseCoins RPC.
-	FaucetServiceDispenseCoinsProcedure = "/hub.v1.FaucetService/DispenseCoins"
-	// FaucetServiceListClaimsProcedure is the fully-qualified name of the FaucetService's ListClaims
+	// FaucetServiceDispenseCoinsProcedure is the procedure name of the FaucetService's DispenseCoins
 	// RPC.
+	FaucetServiceDispenseCoinsProcedure = "/hub.v1.FaucetService/DispenseCoins"
+	// FaucetServiceListClaimsProcedure is the procedure name of the FaucetService's ListClaims RPC.
 	FaucetServiceListClaimsProcedure = "/hub.v1.FaucetService/ListClaims"
-	// FaucetServiceGetStatusProcedure is the fully-qualified name of the FaucetService's GetStatus RPC.
+	// FaucetServiceGetStatusProcedure is the procedure name of the FaucetService's GetStatus RPC.
 	FaucetServiceGetStatusProcedure = "/hub.v1.FaucetService/GetStatus"
 )
 
+var (
+	faucetServiceDispenseCoinsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_hub_v1_faucet_proto.Services().ByName("FaucetService").Methods().ByName("DispenseCoins"),
+			Procedure:  FaucetServiceDispenseCoinsProcedure,
+		}
+	})
+	faucetServiceListClaimsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_hub_v1_faucet_proto.Services().ByName("FaucetService").Methods().ByName("ListClaims"),
+			Procedure:  FaucetServiceListClaimsProcedure,
+		}
+	})
+	faucetServiceGetStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_hub_v1_faucet_proto.Services().ByName("FaucetService").Methods().ByName("GetStatus"),
+			Procedure:  FaucetServiceGetStatusProcedure,
+		}
+	})
+)
+
 // FaucetServiceClient is a client for the hub.v1.FaucetService service.
 type FaucetServiceClient interface {
-	DispenseCoins(context.Context, *connect.Request[v1.DispenseCoinsRequest]) (*connect.Response[v1.DispenseCoinsResponse], error)
-	ListClaims(context.Context, *connect.Request[v1.ListClaimsRequest]) (*connect.Response[v1.ListClaimsResponse], error)
-	GetStatus(context.Context, *connect.Request[v1.GetStatusRequest]) (*connect.Response[v1.GetStatusResponse], error)
+	DispenseCoins(context.Context, *v1.DispenseCoinsRequest) (*v1.DispenseCoinsResponse, error)
+	ListClaims(context.Context, *v1.ListClaimsRequest) (*v1.ListClaimsResponse, error)
+	GetStatus(context.Context, *v1.GetStatusRequest) (*v1.GetStatusResponse, error)
 }
 
-// NewFaucetServiceClient constructs a client for the hub.v1.FaucetService service. By default, it
-// uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewFaucetServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) FaucetServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	faucetServiceMethods := v1.File_hub_v1_faucet_proto.Services().ByName("FaucetService").Methods()
-	return &faucetServiceClient{
-		dispenseCoins: connect.NewClient[v1.DispenseCoinsRequest, v1.DispenseCoinsResponse](
-			httpClient,
-			baseURL+FaucetServiceDispenseCoinsProcedure,
-			connect.WithSchema(faucetServiceMethods.ByName("DispenseCoins")),
-			connect.WithClientOptions(opts...),
-		),
-		listClaims: connect.NewClient[v1.ListClaimsRequest, v1.ListClaimsResponse](
-			httpClient,
-			baseURL+FaucetServiceListClaimsProcedure,
-			connect.WithSchema(faucetServiceMethods.ByName("ListClaims")),
-			connect.WithClientOptions(opts...),
-		),
-		getStatus: connect.NewClient[v1.GetStatusRequest, v1.GetStatusResponse](
-			httpClient,
-			baseURL+FaucetServiceGetStatusProcedure,
-			connect.WithSchema(faucetServiceMethods.ByName("GetStatus")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// NewFaucetServiceClient constructs a client for the hub.v1.FaucetService service. Multiple service
+// clients may share a single connect.Client.
+func NewFaucetServiceClient(client *connect.Client) FaucetServiceClient {
+	return &faucetServiceClient{client: client}
 }
 
-// faucetServiceClient implements FaucetServiceClient.
-type faucetServiceClient struct {
-	dispenseCoins *connect.Client[v1.DispenseCoinsRequest, v1.DispenseCoinsResponse]
-	listClaims    *connect.Client[v1.ListClaimsRequest, v1.ListClaimsResponse]
-	getStatus     *connect.Client[v1.GetStatusRequest, v1.GetStatusResponse]
+// FaucetServiceHandler is an implementation of the hub.v1.FaucetService service.
+type FaucetServiceHandler interface {
+	DispenseCoins(context.Context, *v1.DispenseCoinsRequest) (*v1.DispenseCoinsResponse, error)
+	ListClaims(context.Context, *v1.ListClaimsRequest) (*v1.ListClaimsResponse, error)
+	GetStatus(context.Context, *v1.GetStatusRequest) (*v1.GetStatusResponse, error)
 }
 
-// DispenseCoins calls hub.v1.FaucetService.DispenseCoins.
-func (c *faucetServiceClient) DispenseCoins(ctx context.Context, req *connect.Request[v1.DispenseCoinsRequest]) (*connect.Response[v1.DispenseCoinsResponse], error) {
-	return c.dispenseCoins.CallUnary(ctx, req)
+// RegisterFaucetServiceHandler registers svc as the hub.v1.FaucetService implementation on server.
+func RegisterFaucetServiceHandler(server *connect.Server, svc FaucetServiceHandler) {
+	adapter := faucetServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: faucetServiceDispenseCoinsSpec(), Handler: adapter.dispenseCoins},
+		connect.Method{Spec: faucetServiceListClaimsSpec(), Handler: adapter.listClaims},
+		connect.Method{Spec: faucetServiceGetStatusSpec(), Handler: adapter.getStatus},
+	)
 }
 
-// ListClaims calls hub.v1.FaucetService.ListClaims.
-func (c *faucetServiceClient) ListClaims(ctx context.Context, req *connect.Request[v1.ListClaimsRequest]) (*connect.Response[v1.ListClaimsResponse], error) {
-	return c.listClaims.CallUnary(ctx, req)
+// UnimplementedFaucetServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedFaucetServiceHandler struct{}
+
+func (UnimplementedFaucetServiceHandler) DispenseCoins(context.Context, *v1.DispenseCoinsRequest) (*v1.DispenseCoinsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "hub.v1.FaucetService.DispenseCoins is not implemented")
 }
 
-// GetStatus calls hub.v1.FaucetService.GetStatus.
-func (c *faucetServiceClient) GetStatus(ctx context.Context, req *connect.Request[v1.GetStatusRequest]) (*connect.Response[v1.GetStatusResponse], error) {
-	return c.getStatus.CallUnary(ctx, req)
+func (UnimplementedFaucetServiceHandler) ListClaims(context.Context, *v1.ListClaimsRequest) (*v1.ListClaimsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "hub.v1.FaucetService.ListClaims is not implemented")
 }
 
-// FaucetServiceHandler is an implementation of the hub.v1.FaucetService service.
-type FaucetServiceHandler interface {
-	DispenseCoins(context.Context, *connect.Request[v1.DispenseCoinsRequest]) (*connect.Response[v1.DispenseCoinsResponse], error)
-	ListClaims(context.Context, *connect.Request[v1.ListClaimsRequest]) (*connect.Response[v1.ListClaimsResponse], error)
-	GetStatus(context.Context, *connect.Request[v1.GetStatusRequest]) (*connect.Response[v1.GetStatusResponse], error)
+func (UnimplementedFaucetServiceHandler) GetStatus(context.Context, *v1.GetStatusRequest) (*v1.GetStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "hub.v1.FaucetService.GetStatus is not implemented")
 }
 
-// NewFaucetServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewFaucetServiceHandler(svc FaucetServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	faucetServiceMethods := v1.File_hub_v1_faucet_proto.Services().ByName("FaucetService").Methods()
-	faucetServiceDispenseCoinsHandler := connect.NewUnaryHandler(
-		FaucetServiceDispenseCoinsProcedure,
-		svc.DispenseCoins,
-		connect.WithSchema(faucetServiceMethods.ByName("DispenseCoins")),
-		connect.WithHandlerOptions(opts...),
-	)
-	faucetServiceListClaimsHandler := connect.NewUnaryHandler(
-		FaucetServiceListClaimsProcedure,
-		svc.ListClaims,
-		connect.WithSchema(faucetServiceMethods.ByName("ListClaims")),
-		connect.WithHandlerOptions(opts...),
-	)
-	faucetServiceGetStatusHandler := connect.NewUnaryHandler(
-		FaucetServiceGetStatusProcedure,
-		svc.GetStatus,
-		connect.WithSchema(faucetServiceMethods.ByName("GetStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/hub.v1.FaucetService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case FaucetServiceDispenseCoinsProcedure:
-			faucetServiceDispenseCoinsHandler.ServeHTTP(w, r)
-		case FaucetServiceListClaimsProcedure:
-			faucetServiceListClaimsHandler.ServeHTTP(w, r)
-		case FaucetServiceGetStatusProcedure:
-			faucetServiceGetStatusHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type faucetServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedFaucetServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedFaucetServiceHandler struct{}
+func (c *faucetServiceClient) DispenseCoins(ctx context.Context, req *v1.DispenseCoinsRequest) (*v1.DispenseCoinsResponse, error) {
+	var res v1.DispenseCoinsResponse
+	if err := c.client.CallUnary(ctx, faucetServiceDispenseCoinsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedFaucetServiceHandler) DispenseCoins(context.Context, *connect.Request[v1.DispenseCoinsRequest]) (*connect.Response[v1.DispenseCoinsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("hub.v1.FaucetService.DispenseCoins is not implemented"))
+func (c *faucetServiceClient) ListClaims(ctx context.Context, req *v1.ListClaimsRequest) (*v1.ListClaimsResponse, error) {
+	var res v1.ListClaimsResponse
+	if err := c.client.CallUnary(ctx, faucetServiceListClaimsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedFaucetServiceHandler) ListClaims(context.Context, *connect.Request[v1.ListClaimsRequest]) (*connect.Response[v1.ListClaimsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("hub.v1.FaucetService.ListClaims is not implemented"))
+func (c *faucetServiceClient) GetStatus(ctx context.Context, req *v1.GetStatusRequest) (*v1.GetStatusResponse, error) {
+	var res v1.GetStatusResponse
+	if err := c.client.CallUnary(ctx, faucetServiceGetStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedFaucetServiceHandler) GetStatus(context.Context, *connect.Request[v1.GetStatusRequest]) (*connect.Response[v1.GetStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("hub.v1.FaucetService.GetStatus is not implemented"))
+type faucetServiceHandler struct{ svc FaucetServiceHandler }
+
+func (h faucetServiceHandler) dispenseCoins(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DispenseCoinsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DispenseCoins(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h faucetServiceHandler) listClaims(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListClaimsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListClaims(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h faucetServiceHandler) getStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/dc-hub/server/go.mod b/dc-hub/server/go.mod
index bef1cf1a1a..a891898dbb 100644
--- a/dc-hub/server/go.mod
+++ b/dc-hub/server/go.mod
@@ -5,6 +5,7 @@ go 1.27.0
 require (
 	buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.6-20250425153114-8976f5be98c1.1
 	connectrpc.com/connect v1.18.1
+	connectrpc.com/connect/v2 v2.0.1
 	connectrpc.com/grpcreflect v1.3.0
 	github.com/barebitcoin/btc-buf v0.0.0-20250502095110-38e347c4c3dd
 	github.com/btcsuite/btcd/btcutil v1.1.6
@@ -14,8 +15,9 @@ require (
 	github.com/rs/zerolog v1.33.0
 	github.com/samber/lo v1.50.0
 	github.com/sourcegraph/conc v0.3.0
+	github.com/stretchr/testify v1.10.0
 	golang.org/x/net v0.40.0
-	google.golang.org/protobuf v1.36.6
+	google.golang.org/protobuf v1.36.11
 )
 
 require (
@@ -29,6 +31,7 @@ require (
 	github.com/btcsuite/btclog v1.0.0 // indirect
 	github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd // indirect
 	github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/decred/dcrd/crypto/blake256 v1.1.0 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect
 	github.com/google/cel-go v0.25.0 // indirect
@@ -36,6 +39,7 @@ require (
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/oklog/ulid/v2 v2.1.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/stoewer/go-strcase v1.3.0 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.9.0 // indirect
@@ -45,4 +49,5 @@ require (
 	golang.org/x/text v0.25.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20240826202546-f6391c0de4c7 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20240826202546-f6391c0de4c7 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/dc-hub/server/go.sum b/dc-hub/server/go.sum
index bdf30ce3a7..00dd4e095f 100644
--- a/dc-hub/server/go.sum
+++ b/dc-hub/server/go.sum
@@ -4,6 +4,8 @@ cel.dev/expr v0.23.1 h1:K4KOtPCJQjVggkARsjG9RWXP6O4R73aHeJMa/dmCQQg=
 cel.dev/expr v0.23.1/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw=
 connectrpc.com/connect v1.18.1 h1:PAg7CjSAGvscaf6YZKUefjoih5Z/qYkyaTrBW8xvYPw=
 connectrpc.com/connect v1.18.1/go.mod h1:0292hj1rnx8oFrStN7cB4jjVBeqs+Yx5yDIC2prWDO8=
+connectrpc.com/connect/v2 v2.0.1 h1:WTAycxe87UqxSM5oxS30d1dalZ+C5xz8Ec8O6zVYkHQ=
+connectrpc.com/connect/v2 v2.0.1/go.mod h1:N32OLrstcPUzkykFynnefFro3+xzSdOrZlK2jHmS/xo=
 connectrpc.com/grpchealth v1.3.0 h1:FA3OIwAvuMokQIXQrY5LbIy8IenftksTP/lG4PbYN+E=
 connectrpc.com/grpchealth v1.3.0/go.mod h1:3vpqmX25/ir0gVgW6RdnCPPZRcR6HvqtXX5RNPmDXHM=
 connectrpc.com/grpcreflect v1.3.0 h1:Y4V+ACf8/vOb1XOc251Qun7jMB75gCUNw6llvB9csXc=
@@ -78,8 +80,8 @@ github.com/google/cel-go v0.25.0/go.mod h1:hjEb6r5SuOSlhCHmFoLzu8HGCERvIsDAbxDAy
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
@@ -92,6 +94,8 @@ github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bB
 github.com/jessevdk/go-flags v1.6.1/go.mod h1:Mk8T1hIAWpOiJiHa9rJASDK2UGWji0EuPGBnNLMooyc=
 github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
 github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
@@ -99,6 +103,8 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/oklog/ulid/v2 v2.1.0 h1:+9lhoxAP56we25tyYETBBY1YLA2SaoLvUFgrP2miPJU=
 github.com/oklog/ulid/v2 v2.1.0/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNsTT1QQ=
@@ -188,9 +194,11 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/dc-hub/server/server/server.go b/dc-hub/server/server/server.go
index f3ed6a84b3..426ad39290 100644
--- a/dc-hub/server/server/server.go
+++ b/dc-hub/server/server/server.go
@@ -7,12 +7,12 @@ import (
 	"io"
 	"net"
 	"net/http"
-	"slices"
 	"strings"
 	"sync/atomic"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"connectrpc.com/grpcreflect"
 	api_explorer "github.com/LayerTwo-Labs/sidesail/dc-hub/server/api/explorer"
 	api_faucet "github.com/LayerTwo-Labs/sidesail/dc-hub/server/api/faucet"
@@ -34,27 +34,25 @@ func New(
 	rpcClients *api_explorer.RpcClients,
 	enforcerConnector connector.Connector[validatordrpc.ValidatorServiceClient],
 ) *Server {
-	interceptors := []connect.Interceptor{
-		validation.Interceptor(),
-	}
-
 	mux := http.NewServeMux()
-	srv := &Server{mux: mux, interceptors: interceptors}
+	srv := &Server{
+		mux: mux,
+		services: []string{
+			faucetrpc.FaucetServiceName,
+			explorerrpc.ExplorerServiceName,
+			validatordrpc.ValidatorServiceName,
+		},
+	}
 
 	validatorSvc := connector.New("enforcer", enforcerConnector)
-
-	Register(
-		srv, faucetrpc.NewFaucetServiceHandler,
-		faucetrpc.FaucetServiceHandler(api_faucet.New(bitcoind)),
-	)
-	Register(
-		srv, explorerrpc.NewExplorerServiceHandler,
-		explorerrpc.ExplorerServiceHandler(api_explorer.New(bitcoind, rpcClients, validatorSvc)),
-	)
-	Register(
-		srv, validatordrpc.NewValidatorServiceHandler,
-		validatordrpc.ValidatorServiceHandler(api_validator.New(validatorSvc)),
-	)
+	rpcServer := connect.NewServer(validation.Interceptor())
+	faucetrpc.RegisterFaucetServiceHandler(rpcServer, api_faucet.New(bitcoind))
+	explorerrpc.RegisterExplorerServiceHandler(rpcServer, api_explorer.New(bitcoind, rpcClients, validatorSvc))
+	validatordrpc.RegisterValidatorServiceHandler(rpcServer, api_validator.New(validatorSvc))
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
+	reflector := grpcreflect.NewStaticReflector(srv.services...)
+	mux.Handle(grpcreflect.NewHandlerV1(reflector))
+	mux.Handle(grpcreflect.NewHandlerV1Alpha(reflector))
 
 	return srv
 }
@@ -66,8 +64,6 @@ type Server struct {
 
 	mux    *http.ServeMux
 	server *http.Server
-
-	interceptors []connect.Interceptor
 }
 
 func (s *Server) Handler(ctx context.Context) http.Handler {
@@ -128,15 +124,8 @@ func (s *Server) Serve(ctx context.Context, address string) error {
 	})
 
 	joinedServices := strings.Join(services, ", ")
-	{
-		log.Debug().
-			Msgf("serve connect: enabling reflection: %s", joinedServices)
-
-		reflector := grpcreflect.NewStaticReflector(s.services...)
-
-		s.mux.Handle(grpcreflect.NewHandlerV1(reflector))
-		s.mux.Handle(grpcreflect.NewHandlerV1Alpha(reflector))
-	}
+	log.Debug().
+		Msgf("serve connect: enabling reflection: %s", joinedServices)
 
 	lis, err := net.Listen("tcp", address)
 	if err != nil {
@@ -213,21 +202,3 @@ func (s *Server) Shutdown(ctx context.Context) {
 
 	atomic.AddInt64(&stopped, 1)
 }
-
-// Register can be user to register a new sub-service to the server.
-// This is _NOT_ a part of the Server API, because it is generic.
-func Register[T any](
-	s *Server,
-	handler func(svc T, opts ...connect.HandlerOption) (string, http.Handler),
-	svc T, opts ...connect.HandlerOption,
-) {
-	service, h := handler(svc,
-		slices.Concat(
-			[]connect.HandlerOption{connect.WithInterceptors(s.interceptors...)},
-			opts,
-		)...,
-	)
-
-	s.services = append(s.services, service)
-	s.mux.Handle(service, h)
-}
diff --git a/dc-hub/server/server/server_test.go b/dc-hub/server/server/server_test.go
new file mode 100644
index 0000000000..f8cdc7f658
--- /dev/null
+++ b/dc-hub/server/server/server_test.go
@@ -0,0 +1,281 @@
+package server
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/grpcreflect"
+	btcpb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
+	btcrpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	api_explorer "github.com/LayerTwo-Labs/sidesail/dc-hub/server/api/explorer"
+	"github.com/LayerTwo-Labs/sidesail/dc-hub/server/dial"
+	mainchainv1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1"
+	"github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/cusf/mainchain/v1/mainchainv1connect"
+	explorerv1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/explorer/v1"
+	"github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/explorer/v1/explorerv1connect"
+	hubv1 "github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/hub/v1"
+	"github.com/LayerTwo-Labs/sidesail/dc-hub/server/gen/hub/v1/hubv1connect"
+)
+
+func TestV1Clients(t *testing.T) {
+	detail, err := connectv1.NewErrorDetail(wrapperspb.String("retry"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	coreMux := http.NewServeMux()
+	coreMux.Handle(btcrpc.BitcoinServiceSendToAddressProcedure, connectv1.NewUnaryHandler(
+		btcrpc.BitcoinServiceSendToAddressProcedure,
+		func(_ context.Context, req *connectv1.Request[btcpb.SendToAddressRequest]) (*connectv1.Response[btcpb.SendToAddressResponse], error) {
+			if req.Msg.Address != "destination" || req.Msg.Amount != 1 {
+				t.Error("The Bitcoin request changed.")
+			}
+			return connectv1.NewResponse(&btcpb.SendToAddressResponse{Txid: "test-txid"}), nil
+		},
+	))
+	coreMux.Handle(btcrpc.BitcoinServiceGetBlockchainInfoProcedure, connectv1.NewUnaryHandler(
+		btcrpc.BitcoinServiceGetBlockchainInfoProcedure,
+		func(context.Context, *connectv1.Request[btcpb.GetBlockchainInfoRequest]) (*connectv1.Response[btcpb.GetBlockchainInfoResponse], error) {
+			err := connectv1.NewError(connectv1.CodeUnavailable, errors.New("mainchain unavailable"))
+			err.AddDetail(detail)
+			err.Meta().Set("X-Core", "unavailable")
+			return nil, err
+		},
+	))
+	core := httptest.NewServer(coreMux)
+	t.Cleanup(core.Close)
+
+	cancelled := make(chan struct{}, 1)
+	enforcerMux := http.NewServeMux()
+	enforcerMux.Handle(mainchainv1connect.ValidatorServiceGetSidechainsProcedure, connectv1.NewUnaryHandler(
+		mainchainv1connect.ValidatorServiceGetSidechainsProcedure,
+		func(context.Context, *connectv1.Request[mainchainv1.GetSidechainsRequest]) (*connectv1.Response[mainchainv1.GetSidechainsResponse], error) {
+			return connectv1.NewResponse(&mainchainv1.GetSidechainsResponse{}), nil
+		},
+	))
+	enforcerMux.Handle(mainchainv1connect.ValidatorServiceGetChainInfoProcedure, connectv1.NewUnaryHandler(
+		mainchainv1connect.ValidatorServiceGetChainInfoProcedure,
+		func(_ context.Context, req *connectv1.Request[mainchainv1.GetChainInfoRequest]) (*connectv1.Response[mainchainv1.GetChainInfoResponse], error) {
+			if req.Header().Get("X-Token") != "token" {
+				return nil, connectv1.NewError(connectv1.CodeUnauthenticated, errors.New("token absent"))
+			}
+			res := connectv1.NewResponse(&mainchainv1.GetChainInfoResponse{})
+			res.Header().Add("X-Reply", "first")
+			res.Header().Add("X-Reply", "second")
+			res.Trailer().Set("X-Trailer", "complete")
+			return res, nil
+		},
+	))
+	enforcerMux.Handle(mainchainv1connect.ValidatorServiceGetBlockInfoProcedure, connectv1.NewUnaryHandler(
+		mainchainv1connect.ValidatorServiceGetBlockInfoProcedure,
+		func(context.Context, *connectv1.Request[mainchainv1.GetBlockInfoRequest]) (*connectv1.Response[mainchainv1.GetBlockInfoResponse], error) {
+			err := connectv1.NewError(connectv1.CodeNotFound, errors.New("block absent"))
+			err.AddDetail(detail)
+			err.Meta().Set("X-Error", "block")
+			return nil, err
+		},
+	))
+	enforcerMux.Handle(mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressProcedure, connectv1.NewServerStreamHandler(
+		mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressProcedure,
+		func(ctx context.Context, req *connectv1.Request[mainchainv1.SubscribeHeaderSyncProgressRequest], stream *connectv1.ServerStream[mainchainv1.SubscribeHeaderSyncProgressResponse]) error {
+			if req.Header().Get("X-Token") != "token" {
+				return connectv1.NewError(connectv1.CodeUnauthenticated, errors.New("token absent"))
+			}
+			for height := range uint32(2) {
+				if err := stream.Send(&mainchainv1.SubscribeHeaderSyncProgressResponse{CurrentHeight: wrapperspb.UInt32(height)}); err != nil {
+					return err
+				}
+			}
+			switch req.Header().Get("X-Mode") {
+			case "error":
+				err := connectv1.NewError(connectv1.CodeUnavailable, errors.New("sync stopped"))
+				err.AddDetail(detail)
+				return err
+			case "wait":
+				<-ctx.Done()
+				cancelled <- struct{}{}
+				return ctx.Err()
+			default:
+				return nil
+			}
+		},
+	))
+	enforcer := httptest.NewUnstartedServer(enforcerMux)
+	enforcer.Config.Protocols = new(http.Protocols)
+	enforcer.Config.Protocols.SetHTTP1(true)
+	enforcer.Config.Protocols.SetUnencryptedHTTP2(true)
+	enforcer.Start()
+	t.Cleanup(enforcer.Close)
+
+	api := New(t.Context(), btcrpc.NewBitcoinServiceClient(core.Client(), core.URL), &api_explorer.RpcClients{},
+		func(ctx context.Context) (mainchainv1connect.ValidatorServiceClient, error) {
+			return dial.EnforcerValidator(ctx, enforcer.URL)
+		},
+	)
+	server := httptest.NewUnstartedServer(api.Handler(t.Context()))
+	server.EnableHTTP2 = true
+	server.StartTLS()
+	t.Cleanup(server.Close)
+
+	for _, protocol := range []struct {
+		name    string
+		options []connectv1.ClientOption
+	}{
+		{name: "Connect"},
+		{name: "JSON", options: []connectv1.ClientOption{connectv1.WithProtoJSON()}},
+		{name: "gRPC", options: []connectv1.ClientOption{connectv1.WithGRPC()}},
+		{name: "gRPCWeb", options: []connectv1.ClientOption{connectv1.WithGRPCWeb()}},
+	} {
+		t.Run(protocol.name, func(t *testing.T) {
+			faucet := connectv1.NewClient[hubv1.DispenseCoinsRequest, hubv1.DispenseCoinsResponse](
+				server.Client(), server.URL+hubv1connect.FaucetServiceDispenseCoinsProcedure, protocol.options...,
+			)
+			_, err := faucet.CallUnary(t.Context(), connectv1.NewRequest(&hubv1.DispenseCoinsRequest{Amount: 1}))
+			if connectv1.CodeOf(err) != connectv1.CodeInvalidArgument {
+				t.Fatalf("The empty destination returned %v.", err)
+			}
+			response, err := faucet.CallUnary(t.Context(), connectv1.NewRequest(&hubv1.DispenseCoinsRequest{Destination: "destination", Amount: 1}))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if response.Msg.Txid != "test-txid" {
+				t.Fatalf("The transaction ID is %q.", response.Msg.Txid)
+			}
+
+			chain := connectv1.NewClient[mainchainv1.GetChainInfoRequest, mainchainv1.GetChainInfoResponse](
+				server.Client(), server.URL+mainchainv1connect.ValidatorServiceGetChainInfoProcedure, protocol.options...,
+			)
+			request := connectv1.NewRequest(&mainchainv1.GetChainInfoRequest{})
+			request.Header().Set("X-Token", "token")
+			chainResponse, err := chain.CallUnary(t.Context(), request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(chainResponse.Header().Values("X-Reply")) != 2 || chainResponse.Trailer().Get("X-Trailer") != "complete" {
+				t.Fatal("The proxy changed the response metadata.")
+			}
+
+			block := connectv1.NewClient[mainchainv1.GetBlockInfoRequest, mainchainv1.GetBlockInfoResponse](
+				server.Client(), server.URL+mainchainv1connect.ValidatorServiceGetBlockInfoProcedure, protocol.options...,
+			)
+			_, err = block.CallUnary(t.Context(), connectv1.NewRequest(&mainchainv1.GetBlockInfoRequest{}))
+			blockError := checkRPCError(t, err, connectv1.CodeNotFound, "block absent")
+			checkErrorDetail(t, blockError)
+			if blockError.Meta().Get("X-Error") != "block" {
+				t.Fatal("The proxy changed the error metadata.")
+			}
+
+			explorer := connectv1.NewClient[explorerv1.GetChainTipsRequest, explorerv1.GetChainTipsResponse](
+				server.Client(), server.URL+explorerv1connect.ExplorerServiceGetChainTipsProcedure, protocol.options...,
+			)
+			_, err = explorer.CallUnary(t.Context(), connectv1.NewRequest(&explorerv1.GetChainTipsRequest{}))
+			coreError := checkRPCError(t, err, connectv1.CodeUnavailable, "mainchain unavailable")
+			checkErrorDetail(t, coreError)
+			if coreError.Meta().Get("X-Core") != "unavailable" {
+				t.Fatal("The proxy changed the Bitcoin error metadata.")
+			}
+
+			sync := connectv1.NewClient[mainchainv1.SubscribeHeaderSyncProgressRequest, mainchainv1.SubscribeHeaderSyncProgressResponse](
+				server.Client(), server.URL+mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressProcedure, protocol.options...,
+			)
+			for _, mode := range []string{"complete", "error"} {
+				request := connectv1.NewRequest(&mainchainv1.SubscribeHeaderSyncProgressRequest{})
+				request.Header().Set("X-Token", "token")
+				request.Header().Set("X-Mode", mode)
+				stream, err := sync.CallServerStream(t.Context(), request)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var count uint32
+				for stream.Receive() {
+					if stream.Msg().GetCurrentHeight().GetValue() != count {
+						t.Fatal("The proxy changed the stream order.")
+					}
+					count++
+				}
+				if count != 2 {
+					t.Fatalf("The stream returned %d messages.", count)
+				}
+				if mode == "error" {
+					checkErrorDetail(t, checkRPCError(t, stream.Err(), connectv1.CodeUnavailable, "sync stopped"))
+				} else if err := stream.Err(); err != nil {
+					t.Fatal(err)
+				}
+				if err := stream.Close(); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+	client := connectv1.NewClient[mainchainv1.SubscribeHeaderSyncProgressRequest, mainchainv1.SubscribeHeaderSyncProgressResponse](
+		server.Client(), server.URL+mainchainv1connect.ValidatorServiceSubscribeHeaderSyncProgressProcedure,
+	)
+	request := connectv1.NewRequest(&mainchainv1.SubscribeHeaderSyncProgressRequest{})
+	request.Header().Set("X-Token", "token")
+	request.Header().Set("X-Mode", "wait")
+	stream, err := client.CallServerStream(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !stream.Receive() {
+		t.Fatal(stream.Err())
+	}
+	cancel()
+	if err := stream.Close(); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case <-cancelled:
+	case <-time.After(5 * time.Second):
+		t.Fatal("The upstream stream did not stop.")
+	}
+
+	reflection := grpcreflect.NewClient(server.Client(), server.URL)
+	reflectionStream := reflection.NewStream(t.Context())
+	services, err := reflectionStream.ListServices()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(services) != 3 {
+		t.Fatalf("Reflection returned %d services.", len(services))
+	}
+	if _, err := reflectionStream.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func checkRPCError(t *testing.T, err error, code connectv1.Code, message string) *connectv1.Error {
+	t.Helper()
+	var rpcError *connectv1.Error
+	if !errors.As(err, &rpcError) {
+		t.Fatalf("The RPC did not return a Connect error: %v.", err)
+	}
+	if rpcError.Code() != code || rpcError.Message() != message {
+		t.Fatalf("The RPC returned %v.", rpcError)
+	}
+	return rpcError
+}
+
+func checkErrorDetail(t *testing.T, err *connectv1.Error) {
+	t.Helper()
+	if len(err.Details()) != 1 {
+		t.Fatalf("The RPC returned %d error details.", len(err.Details()))
+	}
+	value, detailError := err.Details()[0].Value()
+	if detailError != nil {
+		t.Fatal(detailError)
+	}
+	if !proto.Equal(value, wrapperspb.String("retry")) {
+		t.Fatalf("The RPC returned the error detail %v.", value)
+	}
+}
diff --git a/ecash-broadcaster/buf.go.gen.yaml b/ecash-broadcaster/buf.go.gen.yaml
index a5c5a5c127..f51520dbeb 100644
--- a/ecash-broadcaster/buf.go.gen.yaml
+++ b/ecash-broadcaster/buf.go.gen.yaml
@@ -8,13 +8,13 @@ managed:
 
 plugins:
   # Base message/enum types for Go.
-  - remote: buf.build/protocolbuffers/go
+  - remote: buf.build/protocolbuffers/go:v1.36.11
     out: gen
     opt:
       - paths=source_relative
 
   # Client + server stubs for connectrpc.com/connect.
-  - remote: buf.build/connectrpc/go
+  - remote: buf.build/connectrpc/go:v2.0.1
     out: gen
     opt:
       - paths=source_relative
diff --git a/ecash-broadcaster/gen/ecash/v1/ecashv1connect/ecash.connect.go b/ecash-broadcaster/gen/ecash/v1/ecashv1connect/ecash.connect.go
index 813cfc47eb..ef4644f1d7 100644
--- a/ecash-broadcaster/gen/ecash/v1/ecashv1connect/ecash.connect.go
+++ b/ecash-broadcaster/gen/ecash/v1/ecashv1connect/ecash.connect.go
@@ -5,105 +5,94 @@
 package ecashv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/ecash-broadcaster/gen/ecash/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ECashBroadcastServiceName is the fully-qualified name of the ECashBroadcastService service.
 	ECashBroadcastServiceName = "ecash.v1.ECashBroadcastService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ECashBroadcastServiceBroadcastECashTxProcedure is the fully-qualified name of the
+	// ECashBroadcastServiceBroadcastECashTxProcedure is the procedure name of the
 	// ECashBroadcastService's BroadcastECashTx RPC.
 	ECashBroadcastServiceBroadcastECashTxProcedure = "/ecash.v1.ECashBroadcastService/BroadcastECashTx"
 )
 
+var (
+	eCashBroadcastServiceBroadcastECashTxSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_ecash_v1_ecash_proto.Services().ByName("ECashBroadcastService").Methods().ByName("BroadcastECashTx"),
+			Procedure:  ECashBroadcastServiceBroadcastECashTxProcedure,
+		}
+	})
+)
+
 // ECashBroadcastServiceClient is a client for the ecash.v1.ECashBroadcastService service.
 type ECashBroadcastServiceClient interface {
-	BroadcastECashTx(context.Context, *connect.Request[v1.BroadcastECashTxRequest]) (*connect.Response[v1.BroadcastECashTxResponse], error)
+	BroadcastECashTx(context.Context, *v1.BroadcastECashTxRequest) (*v1.BroadcastECashTxResponse, error)
 }
 
 // NewECashBroadcastServiceClient constructs a client for the ecash.v1.ECashBroadcastService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewECashBroadcastServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ECashBroadcastServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	eCashBroadcastServiceMethods := v1.File_ecash_v1_ecash_proto.Services().ByName("ECashBroadcastService").Methods()
-	return &eCashBroadcastServiceClient{
-		broadcastECashTx: connect.NewClient[v1.BroadcastECashTxRequest, v1.BroadcastECashTxResponse](
-			httpClient,
-			baseURL+ECashBroadcastServiceBroadcastECashTxProcedure,
-			connect.WithSchema(eCashBroadcastServiceMethods.ByName("BroadcastECashTx")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// eCashBroadcastServiceClient implements ECashBroadcastServiceClient.
-type eCashBroadcastServiceClient struct {
-	broadcastECashTx *connect.Client[v1.BroadcastECashTxRequest, v1.BroadcastECashTxResponse]
-}
-
-// BroadcastECashTx calls ecash.v1.ECashBroadcastService.BroadcastECashTx.
-func (c *eCashBroadcastServiceClient) BroadcastECashTx(ctx context.Context, req *connect.Request[v1.BroadcastECashTxRequest]) (*connect.Response[v1.BroadcastECashTxResponse], error) {
-	return c.broadcastECashTx.CallUnary(ctx, req)
+// service. Multiple service clients may share a single connect.Client.
+func NewECashBroadcastServiceClient(client *connect.Client) ECashBroadcastServiceClient {
+	return &eCashBroadcastServiceClient{client: client}
 }
 
 // ECashBroadcastServiceHandler is an implementation of the ecash.v1.ECashBroadcastService service.
 type ECashBroadcastServiceHandler interface {
-	BroadcastECashTx(context.Context, *connect.Request[v1.BroadcastECashTxRequest]) (*connect.Response[v1.BroadcastECashTxResponse], error)
+	BroadcastECashTx(context.Context, *v1.BroadcastECashTxRequest) (*v1.BroadcastECashTxResponse, error)
 }
 
-// NewECashBroadcastServiceHandler builds an HTTP handler from the service implementation. It
-// returns the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewECashBroadcastServiceHandler(svc ECashBroadcastServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	eCashBroadcastServiceMethods := v1.File_ecash_v1_ecash_proto.Services().ByName("ECashBroadcastService").Methods()
-	eCashBroadcastServiceBroadcastECashTxHandler := connect.NewUnaryHandler(
-		ECashBroadcastServiceBroadcastECashTxProcedure,
-		svc.BroadcastECashTx,
-		connect.WithSchema(eCashBroadcastServiceMethods.ByName("BroadcastECashTx")),
-		connect.WithHandlerOptions(opts...),
+// RegisterECashBroadcastServiceHandler registers svc as the ecash.v1.ECashBroadcastService
+// implementation on server.
+func RegisterECashBroadcastServiceHandler(server *connect.Server, svc ECashBroadcastServiceHandler) {
+	adapter := eCashBroadcastServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: eCashBroadcastServiceBroadcastECashTxSpec(), Handler: adapter.broadcastECashTx},
 	)
-	return "/ecash.v1.ECashBroadcastService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ECashBroadcastServiceBroadcastECashTxProcedure:
-			eCashBroadcastServiceBroadcastECashTxHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
 }
 
 // UnimplementedECashBroadcastServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedECashBroadcastServiceHandler struct{}
 
-func (UnimplementedECashBroadcastServiceHandler) BroadcastECashTx(context.Context, *connect.Request[v1.BroadcastECashTxRequest]) (*connect.Response[v1.BroadcastECashTxResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("ecash.v1.ECashBroadcastService.BroadcastECashTx is not implemented"))
+func (UnimplementedECashBroadcastServiceHandler) BroadcastECashTx(context.Context, *v1.BroadcastECashTxRequest) (*v1.BroadcastECashTxResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "ecash.v1.ECashBroadcastService.BroadcastECashTx is not implemented")
+}
+
+type eCashBroadcastServiceClient struct {
+	client *connect.Client
+}
+
+func (c *eCashBroadcastServiceClient) BroadcastECashTx(ctx context.Context, req *v1.BroadcastECashTxRequest) (*v1.BroadcastECashTxResponse, error) {
+	var res v1.BroadcastECashTxResponse
+	if err := c.client.CallUnary(ctx, eCashBroadcastServiceBroadcastECashTxSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type eCashBroadcastServiceHandler struct{ svc ECashBroadcastServiceHandler }
+
+func (h eCashBroadcastServiceHandler) broadcastECashTx(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BroadcastECashTxRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BroadcastECashTx(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/ecash-broadcaster/go.mod b/ecash-broadcaster/go.mod
index 29101e16ee..71eb6eb317 100644
--- a/ecash-broadcaster/go.mod
+++ b/ecash-broadcaster/go.mod
@@ -4,8 +4,8 @@ go 1.27.0
 
 require (
 	connectrpc.com/connect v1.18.1
-	golang.org/x/net v0.40.0
-	google.golang.org/protobuf v1.36.6
+	connectrpc.com/connect/v2 v2.0.1
+	google.golang.org/protobuf v1.36.11
 )
 
-require golang.org/x/text v0.25.0 // indirect
+require golang.org/x/net v0.40.0 // indirect
diff --git a/ecash-broadcaster/go.sum b/ecash-broadcaster/go.sum
index 42c8ab6fa6..f7d3bf3805 100644
--- a/ecash-broadcaster/go.sum
+++ b/ecash-broadcaster/go.sum
@@ -1,10 +1,12 @@
 connectrpc.com/connect v1.18.1 h1:PAg7CjSAGvscaf6YZKUefjoih5Z/qYkyaTrBW8xvYPw=
 connectrpc.com/connect v1.18.1/go.mod h1:0292hj1rnx8oFrStN7cB4jjVBeqs+Yx5yDIC2prWDO8=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+connectrpc.com/connect/v2 v2.0.1 h1:WTAycxe87UqxSM5oxS30d1dalZ+C5xz8Ec8O6zVYkHQ=
+connectrpc.com/connect/v2 v2.0.1/go.mod h1:N32OLrstcPUzkykFynnefFro3+xzSdOrZlK2jHmS/xo=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
 golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
 golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
diff --git a/ecash-broadcaster/handler.go b/ecash-broadcaster/handler.go
index ef2749a443..711dd57eb0 100644
--- a/ecash-broadcaster/handler.go
+++ b/ecash-broadcaster/handler.go
@@ -2,9 +2,8 @@ package main
 
 import (
 	"context"
-	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	ecashv1 "github.com/LayerTwo-Labs/sidesail/ecash-broadcaster/gen/ecash/v1"
 )
@@ -16,16 +15,16 @@ type handler struct {
 
 func (h *handler) BroadcastECashTx(
 	ctx context.Context,
-	req *connect.Request[ecashv1.BroadcastECashTxRequest],
-) (*connect.Response[ecashv1.BroadcastECashTxResponse], error) {
-	if req.Msg.SignedHex == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("signed_hex is required"))
+	req *ecashv1.BroadcastECashTxRequest,
+) (*ecashv1.BroadcastECashTxResponse, error) {
+	if req.SignedHex == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "signed_hex is required")
 	}
 
-	txid, err := h.bitcoind.sendRawTransaction(ctx, req.Msg.SignedHex)
+	txid, err := h.bitcoind.sendRawTransaction(ctx, req.SignedHex)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("broadcast: %w", err))
+		return nil, connect.Errorf(connect.CodeInternal, "broadcast: %s", err).WithCause(err)
 	}
 
-	return connect.NewResponse(&ecashv1.BroadcastECashTxResponse{Txid: txid}), nil
+	return &ecashv1.BroadcastECashTxResponse{Txid: txid}, nil
 }
diff --git a/ecash-broadcaster/handler_test.go b/ecash-broadcaster/handler_test.go
new file mode 100644
index 0000000000..211f8f802f
--- /dev/null
+++ b/ecash-broadcaster/handler_test.go
@@ -0,0 +1,104 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	connectv1 "connectrpc.com/connect"
+
+	ecashv1 "github.com/LayerTwo-Labs/sidesail/ecash-broadcaster/gen/ecash/v1"
+	"github.com/LayerTwo-Labs/sidesail/ecash-broadcaster/gen/ecash/v1/ecashv1connect"
+)
+
+func TestBroadcastV1Client(t *testing.T) {
+	node := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		user, password, ok := r.BasicAuth()
+		if !ok || user != "user" || password != "password" {
+			t.Error("The node did not receive the RPC credentials.")
+			w.WriteHeader(http.StatusUnauthorized)
+			return
+		}
+		var request struct {
+			Method string   `json:"method"`
+			Params []string `json:"params"`
+		}
+		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+			t.Error(err)
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		if request.Method != "sendrawtransaction" || len(request.Params) != 1 {
+			t.Error("The node did not receive one transaction.")
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		var result any = map[string]string{"result": "test-txid"}
+		if request.Params[0] == "bad" {
+			result = map[string]any{"error": map[string]any{"code": -26, "message": "bad transaction"}}
+		}
+		if err := json.NewEncoder(w).Encode(result); err != nil {
+			t.Error(err)
+		}
+	}))
+	t.Cleanup(node.Close)
+
+	server := httptest.NewUnstartedServer(newMux(&handler{bitcoind: &bitcoindClient{
+		url: node.URL, user: "user", pass: "password", http: node.Client(),
+	}}))
+	server.EnableHTTP2 = true
+	server.StartTLS()
+	t.Cleanup(server.Close)
+
+	protocols := []struct {
+		name    string
+		options []connectv1.ClientOption
+	}{
+		{name: "Connect"},
+		{name: "JSON", options: []connectv1.ClientOption{connectv1.WithProtoJSON()}},
+		{name: "gRPC", options: []connectv1.ClientOption{connectv1.WithGRPC()}},
+		{name: "gRPCWeb", options: []connectv1.ClientOption{connectv1.WithGRPCWeb()}},
+	}
+	for _, protocol := range protocols {
+		t.Run(protocol.name, func(t *testing.T) {
+			client := connectv1.NewClient[ecashv1.BroadcastECashTxRequest, ecashv1.BroadcastECashTxResponse](
+				server.Client(), server.URL+ecashv1connect.ECashBroadcastServiceBroadcastECashTxProcedure,
+				protocol.options...,
+			)
+			for _, test := range []struct {
+				name    string
+				hex     string
+				code    connectv1.Code
+				message string
+			}{
+				{name: "valid", hex: "00"},
+				{name: "large", hex: strings.Repeat("00", 2*1024*1024+1)},
+				{name: "empty", code: connectv1.CodeInvalidArgument, message: "signed_hex is required"},
+				{name: "node error", hex: "bad", code: connectv1.CodeInternal, message: "broadcast: bitcoind error -26: bad transaction"},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					response, err := client.CallUnary(t.Context(), connectv1.NewRequest(&ecashv1.BroadcastECashTxRequest{SignedHex: test.hex}))
+					if test.code == 0 {
+						if err != nil {
+							t.Fatal(err)
+						}
+						if response.Msg.Txid != "test-txid" {
+							t.Fatalf("The transaction ID is %q.", response.Msg.Txid)
+						}
+						return
+					}
+					var rpcError *connectv1.Error
+					if !errors.As(err, &rpcError) {
+						t.Fatalf("The RPC did not return a Connect error: %v.", err)
+					}
+					if rpcError.Code() != test.code || rpcError.Message() != test.message {
+						t.Fatalf("The RPC returned %v.", rpcError)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/ecash-broadcaster/main.go b/ecash-broadcaster/main.go
index 3e3d5e0c1a..7eae2e5b74 100644
--- a/ecash-broadcaster/main.go
+++ b/ecash-broadcaster/main.go
@@ -11,6 +11,8 @@ import (
 	"syscall"
 	"time"
 
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/LayerTwo-Labs/sidesail/ecash-broadcaster/gen/ecash/v1/ecashv1connect"
 )
 
@@ -24,15 +26,12 @@ func main() {
 
 	h := &handler{bitcoind: newBitcoindClient(*host, *port, *user, *pass)}
 
-	mux := http.NewServeMux()
-	mux.Handle(ecashv1connect.NewECashBroadcastServiceHandler(h))
-
 	protocols := new(http.Protocols)
 	protocols.SetHTTP1(true)
 	protocols.SetUnencryptedHTTP2(true)
 	srv := &http.Server{
 		Addr:      *listen,
-		Handler:   mux,
+		Handler:   newMux(h),
 		Protocols: protocols,
 	}
 
@@ -54,3 +53,11 @@ func main() {
 		log.Printf("shutdown: %v", err)
 	}
 }
+
+func newMux(handler *handler) *http.ServeMux {
+	mux := http.NewServeMux()
+	server := connect.NewServer()
+	ecashv1connect.RegisterECashBroadcastServiceHandler(server, handler)
+	connecthttp.Mount(mux, server, connecthttp.WithReadMaxBytes(0))
+	return mux
+}
diff --git a/photon/pubspec.yaml b/photon/pubspec.yaml
index 2bb6bcbd54..787dfddcbd 100644
--- a/photon/pubspec.yaml
+++ b/photon/pubspec.yaml
@@ -2,7 +2,7 @@ name: photon
 description: UI for Drivechain (BIP300/301) based sidechains
 publish_to: "none" # Remove this line if you wish to publish to pub.dev
 
-version: 1.0.240
+version: 1.0.241
 
 environment:
   sdk: 3.13.5
diff --git a/sidechain-orchestrator/api/adopt_owner_test.go b/sidechain-orchestrator/api/adopt_owner_test.go
index 6e520163b9..3d1c934a2a 100644
--- a/sidechain-orchestrator/api/adopt_owner_test.go
+++ b/sidechain-orchestrator/api/adopt_owner_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/lease"
@@ -51,9 +51,9 @@ func TestAdoptOwnerRejectsLateLease(t *testing.T) {
 			}
 			orch := &orchestrator.Orchestrator{}
 			orch.SetLease(clients)
-			response, err := NewHandler(orch).AdoptOwner(ctx, connect.NewRequest(&pb.AdoptOwnerRequest{
+			response, err := NewHandler(orch).AdoptOwner(ctx, &pb.AdoptOwnerRequest{
 				OwnerPid: int32(os.Getpid()),
-			}))
+			})
 			require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 			require.Nil(t, response)
 		})
@@ -63,9 +63,9 @@ func TestAdoptOwnerRejectsLateLease(t *testing.T) {
 func TestAdoptOwnerAcceptsLiveLease(t *testing.T) {
 	orch := &orchestrator.Orchestrator{}
 	orch.SetLease(lease.New(os.Getpid(), time.Minute, func() {}))
-	response, err := NewHandler(orch).AdoptOwner(context.Background(), connect.NewRequest(&pb.AdoptOwnerRequest{
+	response, err := NewHandler(orch).AdoptOwner(context.Background(), &pb.AdoptOwnerRequest{
 		OwnerPid: int32(os.Getpid()),
-	}))
+	})
 	require.NoError(t, err)
-	require.False(t, response.Msg.CanceledExit)
+	require.False(t, response.CanceledExit)
 }
diff --git a/sidechain-orchestrator/api/bid_source.go b/sidechain-orchestrator/api/bid_source.go
index 978e5d3d3b..4a6ba2e5e9 100644
--- a/sidechain-orchestrator/api/bid_source.go
+++ b/sidechain-orchestrator/api/bid_source.go
@@ -6,7 +6,7 @@ import (
 	"maps"
 	"slices"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	bmmpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1"
@@ -150,8 +150,8 @@ func (s bidSource) Replacement(ctx context.Context, walletID, txid string) (Repl
 	var walk func(txid string, depth int) error
 	walk = func(txid string, depth int) error {
 		if depth > maxBidChain {
-			return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-				"bid %s sits over more than %d unconfirmed bids", txid, maxBidChain))
+			return connect.Errorf(connect.CodeFailedPrecondition,
+				"bid %s sits over more than %d unconfirmed bids", txid, maxBidChain)
 		}
 		if !chainSeen[txid] {
 			chainSeen[txid] = true
@@ -188,8 +188,8 @@ func (s bidSource) Replacement(ctx context.Context, walletID, txid string) (Repl
 		return Replacement{}, err
 	}
 	if len(inputs) == 0 {
-		return Replacement{}, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("bid %s has no inputs to reuse", txid))
+		return Replacement{}, connect.Errorf(connect.CodeFailedPrecondition,
+			"bid %s has no inputs to reuse", txid)
 	}
 
 	evicted, err := s.own.evicted(ctx, walletID, roots, chain)
diff --git a/sidechain-orchestrator/api/bid_source_core.go b/sidechain-orchestrator/api/bid_source_core.go
index 066d0254a6..cac5e49c4e 100644
--- a/sidechain-orchestrator/api/bid_source_core.go
+++ b/sidechain-orchestrator/api/bid_source_core.go
@@ -7,7 +7,7 @@ import (
 	"fmt"
 	"math"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
@@ -20,7 +20,7 @@ type coreBids struct{ h *BMMHandler }
 func (c coreBids) spends(ctx context.Context, _, txid string) ([]*wpb.UnspentOutput, error) {
 	raw, err := c.h.coreCall(ctx, "getrawtransaction", fmt.Sprintf("[%q,true]", txid))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("read bid %s: %w", txid, err))
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("read bid %s: %w", txid, err).Error())
 	}
 	var tx struct {
 		Vin []struct {
@@ -29,10 +29,10 @@ func (c coreBids) spends(ctx context.Context, _, txid string) ([]*wpb.UnspentOut
 		} `json:"vin"`
 	}
 	if err := json.Unmarshal(raw, &tx); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode bid %s: %w", txid, err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode bid %s: %w", txid, err).Error())
 	}
 	if len(tx.Vin) == 0 {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bid %s has no inputs to reuse", txid))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bid %s has no inputs to reuse", txid)
 	}
 	return lo.Map(tx.Vin, func(in struct {
 		Txid string `json:"txid"`
@@ -107,7 +107,7 @@ func (c coreBids) mempoolFees(ctx context.Context, txid string) (mempoolFeeSats,
 	}
 	if err := json.Unmarshal(raw, &entry); err != nil {
 		return mempoolFeeSats{}, false, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("decode mempool entry %s: %w", txid, err))
+			fmt.Errorf("decode mempool entry %s: %w", txid, err).Error())
 	}
 	return mempoolFeeSats{
 		Base:     int64(math.Round(entry.Fees.Base * 1e8)),
@@ -154,11 +154,11 @@ func (c coreBids) mempoolDescendants(ctx context.Context, txid string) []string
 func (c coreBids) PendingTxids(ctx context.Context, _ []string) (map[string]bool, error) {
 	raw, err := c.h.coreCall(ctx, "getrawmempool", "[false]")
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get raw mempool: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get raw mempool: %w", err).Error())
 	}
 	var txids []string
 	if err := json.Unmarshal(raw, &txids); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode mempool: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode mempool: %w", err).Error())
 	}
 	held := make(map[string]bool, len(txids))
 	for _, txid := range txids {
@@ -184,13 +184,13 @@ func (c coreBids) request(ctx context.Context, _, txid string) (*orchestrator.Bm
 func (c coreBids) vsize(ctx context.Context, _, txid string) (int64, error) {
 	raw, err := c.h.coreCall(ctx, "getrawtransaction", fmt.Sprintf("[%q,true]", txid))
 	if err != nil {
-		return 0, connect.NewError(connect.CodeNotFound, fmt.Errorf("read bid %s: %w", txid, err))
+		return 0, connect.NewError(connect.CodeNotFound, fmt.Errorf("read bid %s: %w", txid, err).Error())
 	}
 	var tx struct {
 		Vsize int64 `json:"vsize"`
 	}
 	if err := json.Unmarshal(raw, &tx); err != nil {
-		return 0, connect.NewError(connect.CodeInternal, fmt.Errorf("decode bid %s: %w", txid, err))
+		return 0, connect.NewError(connect.CodeInternal, fmt.Errorf("decode bid %s: %w", txid, err).Error())
 	}
 	return tx.Vsize, nil
 }
@@ -198,7 +198,7 @@ func (c coreBids) vsize(ctx context.Context, _, txid string) (int64, error) {
 func (c coreBids) outputValues(ctx context.Context, _, txid string) ([]int64, error) {
 	values, err := outputValuesSats(ctx, c.h.coreCall, txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	return values, nil
 }
diff --git a/sidechain-orchestrator/api/bid_source_wallet.go b/sidechain-orchestrator/api/bid_source_wallet.go
index f03ec6adbf..611054799f 100644
--- a/sidechain-orchestrator/api/bid_source_wallet.go
+++ b/sidechain-orchestrator/api/bid_source_wallet.go
@@ -7,7 +7,7 @@ import (
 	"slices"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
@@ -23,16 +23,16 @@ func (w walletBids) details(
 	ctx context.Context, walletID, txid string,
 ) (*wpb.GetTransactionDetailsResponse, error) {
 	if w.h.wallet == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("no wallet is wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "no wallet is wired")
 	}
-	resp, err := w.h.wallet.GetTransactionDetails(ctx, connect.NewRequest(&wpb.GetTransactionDetailsRequest{
+	resp, err := w.h.wallet.GetTransactionDetails(ctx, &wpb.GetTransactionDetailsRequest{
 		WalletId: walletID,
 		Txid:     txid,
-	}))
+	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("read bid %s: %w", txid, err))
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("read bid %s: %w", txid, err).Error())
 	}
-	return resp.Msg, nil
+	return resp, nil
 }
 
 func (w walletBids) spends(ctx context.Context, walletID, txid string) ([]*wpb.UnspentOutput, error) {
@@ -41,8 +41,8 @@ func (w walletBids) spends(ctx context.Context, walletID, txid string) ([]*wpb.U
 		return nil, err
 	}
 	if len(details.Inputs) == 0 {
-		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("bid %s has no inputs to reuse", txid))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
+			"bid %s has no inputs to reuse", txid)
 	}
 	return lo.Map(details.Inputs, func(in *wpb.TransactionInput, _ int) *wpb.UnspentOutput {
 		return &wpb.UnspentOutput{Txid: in.PrevTxid, Vout: in.PrevVout}
@@ -152,14 +152,14 @@ func walletGone(err error, walletID string) bool {
 // wallet in walletIDs. The first id names the current funding wallet.
 func (w walletBids) PendingTxids(ctx context.Context, walletIDs []string) (map[string]bool, error) {
 	if w.h.wallet == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("no wallet is wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "no wallet is wired")
 	}
 	held := make(map[string]bool)
 	for i, walletID := range lo.Uniq(walletIDs) {
-		resp, err := w.h.wallet.ListTransactions(ctx, connect.NewRequest(&wpb.ListTransactionsRequest{
+		resp, err := w.h.wallet.ListTransactions(ctx, &wpb.ListTransactionsRequest{
 			WalletId: walletID,
 			Count:    pendingListCount,
-		}))
+		})
 		if err != nil {
 			// A stored round names its funding wallet forever, so the tail of
 			// this list can name a wallet the user deleted since. Only that
@@ -168,9 +168,9 @@ func (w walletBids) PendingTxids(ctx context.Context, walletIDs []string) (map[s
 			if i > 0 && walletGone(err, walletID) {
 				continue
 			}
-			return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("list the wallet transactions: %w", err))
+			return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("list the wallet transactions: %w", err).Error())
 		}
-		for _, tx := range resp.Msg.Transactions {
+		for _, tx := range resp.Transactions {
 			if tx.Confirmations == 0 {
 				held[tx.Txid] = true
 			}
@@ -182,11 +182,11 @@ func (w walletBids) PendingTxids(ctx context.Context, walletIDs []string) (map[s
 // mined reads the chain source, because the wallet cache lags a new block.
 func (w walletBids) mined(ctx context.Context, txid string) (bool, error) {
 	if w.h.wallet == nil {
-		return false, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("no wallet is wired"))
+		return false, connect.Errorf(connect.CodeFailedPrecondition, "no wallet is wired")
 	}
 	status, err := w.h.wallet.TxStatus(ctx, txid)
 	if err != nil {
-		return false, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the chain status of %s: %w", txid, err))
+		return false, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the chain status of %s: %w", txid, err).Error())
 	}
 	return status.Confirmed, nil
 }
diff --git a/sidechain-orchestrator/api/bip47_send.go b/sidechain-orchestrator/api/bip47_send.go
index 5505e82c48..39ee3a90aa 100644
--- a/sidechain-orchestrator/api/bip47_send.go
+++ b/sidechain-orchestrator/api/bip47_send.go
@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"math"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/samber/lo"
@@ -44,9 +44,9 @@ func bip47SubstituteError(err error) error {
 	case errors.Is(err, bip47send.ErrMultiDestination),
 		errors.Is(err, bip47send.ErrSelfSend),
 		errors.Is(err, bip47send.ErrUnsupportedVersion):
-		return connect.NewError(connect.CodeInvalidArgument, err)
+		return connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	return connect.NewError(connect.CodeInternal, err)
+	return connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 }
 
 // sizingIndex stands in for the next BIP47 index. Every index gives a payment
@@ -69,15 +69,15 @@ func (h *WalletHandler) sizeBip47Destinations(
 		return destinations, false, nil
 	}
 	if h.bip47State == nil {
-		return nil, false, connect.NewError(connect.CodeFailedPrecondition, errors.New("bip47 state store not configured"))
+		return nil, false, connect.NewError(connect.CodeFailedPrecondition, "bip47 state store not configured")
 	}
 	seedHex := h.walletSeedHex(walletID)
 	if seedHex == "" {
-		return nil, false, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("wallet %s has no master seed", walletID))
+		return nil, false, connect.Errorf(connect.CodeFailedPrecondition, "wallet %s has no master seed", walletID)
 	}
 	netParams := h.engine.Network()
 	if netParams == nil {
-		return nil, false, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("BIP47 send not supported on this network"))
+		return nil, false, connect.Errorf(connect.CodeFailedPrecondition, "BIP47 send not supported on this network")
 	}
 	result, err := bip47send.SubstituteBip47Destination(seedHex, walletID, destinations, netParams, sizingIndex{})
 	if err != nil {
@@ -85,7 +85,7 @@ func (h *WalletHandler) sizeBip47Destinations(
 	}
 	state, err := h.bip47State.GetState(walletID, result.RecipientCode)
 	if err != nil {
-		return nil, false, connect.NewError(connect.CodeInternal, fmt.Errorf("read bip47 state: %w", err))
+		return nil, false, connect.NewError(connect.CodeInternal, fmt.Errorf("read bip47 state: %w", err).Error())
 	}
 	return result.Destinations, state == nil || state.NotificationTxID == nil, nil
 }
@@ -114,27 +114,27 @@ func (h *WalletHandler) expandBip47Destinations(
 	}
 
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet backend not configured"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "wallet backend not configured")
 	}
 	// BIP47 send works for any backend that can sign the notification tx and
 	// hold the seed for ECDH blinding — Core and electrum both qualify. The
 	// enforcer (no spendable wallet) does not implement Bip47Backend.
 	if _, ok := h.engine.Bip47BackendFor(walletID); !ok {
-		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("BIP47 send is not supported for wallet %s: its backend cannot build the notification transaction", walletID))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
+			"BIP47 send is not supported for wallet %s: its backend cannot build the notification transaction", walletID)
 	}
 	if h.bip47State == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("bip47 state store not configured"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "bip47 state store not configured")
 	}
 
 	seedHex := h.walletSeedHex(walletID)
 	if seedHex == "" {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("wallet %s has no master seed", walletID))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "wallet %s has no master seed", walletID)
 	}
 
 	netParams := h.engine.Network()
 	if netParams == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("BIP47 send not supported on this network"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "BIP47 send not supported on this network")
 	}
 
 	result, err := bip47send.SubstituteBip47Destination(seedHex, walletID, destinations, netParams, h.bip47State)
@@ -154,7 +154,7 @@ func (h *WalletHandler) expandBip47Destinations(
 	state, err := h.bip47State.GetState(walletID, result.RecipientCode)
 	if err != nil {
 		h.releaseBip47Index(walletID, expansion)
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("read bip47 state: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("read bip47 state: %w", err).Error())
 	}
 	if state != nil && state.NotificationTxID != nil {
 		return expansion, nil
@@ -184,7 +184,7 @@ func (h *WalletHandler) resolveSendFeeRate(ctx context.Context, walletID string,
 	}
 	rate, err := rater.FeeRateForTarget(ctx, wallet.SendFeeTarget)
 	if err != nil {
-		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("no fee estimate for the payment: %w", err))
+		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("no fee estimate for the payment: %w", err).Error())
 	}
 	req.FeeRateSatPerVB = int64(math.Ceil(rate))
 	return nil
@@ -227,13 +227,13 @@ func (h *WalletHandler) bip47NotificationCoin(
 		if rater, ok := h.engine.FeeRaterFor(walletID); ok {
 			rate, err = rater.FeeRateForTarget(ctx, wallet.SendFeeTarget)
 			if err != nil {
-				return wallet.UTXO{}, 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("no fee estimate for the bip47 notification: %w", err))
+				return wallet.UTXO{}, 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("no fee estimate for the bip47 notification: %w", err).Error())
 			}
 		}
 	}
 	if rate > wallet.MaxFeeRateSatPerVB {
-		return wallet.UTXO{}, 0, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("the fee rate of %.0f sat/vB for the bip47 notification is above the limit of %d sat/vB", rate, wallet.MaxFeeRateSatPerVB))
+		return wallet.UTXO{}, 0, connect.Errorf(connect.CodeFailedPrecondition,
+			"the fee rate of %.0f sat/vB for the bip47 notification is above the limit of %d sat/vB", rate, wallet.MaxFeeRateSatPerVB)
 	}
 	feeSats := bip47send.EstimateNotificationFee(int64(math.Ceil(rate)))
 	minRequired := bip47NotificationDustSats + feeSats + bip47NotificationDustSats
@@ -259,11 +259,11 @@ func (h *WalletHandler) bip47NotificationCoin(
 		return *picked, feeSats, nil
 	}
 	if pinned != nil {
-		return wallet.UTXO{}, 0, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("notification coin %s:%d is not a spendable UTXO of at least %d sats", pinned.TxID, pinned.Vout, minRequired))
+		return wallet.UTXO{}, 0, connect.Errorf(connect.CodeFailedPrecondition,
+			"notification coin %s:%d is not a spendable UTXO of at least %d sats", pinned.TxID, pinned.Vout, minRequired)
 	}
-	return wallet.UTXO{}, 0, connect.NewError(connect.CodeFailedPrecondition,
-		fmt.Errorf("no spendable UTXO ≥ %d sats available for BIP47 notification tx", minRequired))
+	return wallet.UTXO{}, 0, connect.Errorf(connect.CodeFailedPrecondition,
+		"no spendable UTXO ≥ %d sats available for BIP47 notification tx", minRequired)
 }
 
 // unfrozenSpendableCoins lists the wallet coins a send can spend. The
@@ -272,13 +272,13 @@ func (h *WalletHandler) bip47NotificationCoin(
 func (h *WalletHandler) unfrozenSpendableCoins(ctx context.Context, walletID string) ([]wallet.UTXO, error) {
 	utxos, err := h.engine.Backend().ListUnspent(ctx, walletID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("list unspent: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("list unspent: %w", err).Error())
 	}
 	frozen, err := h.svc.FrozenCoins(ctx, walletID, lo.Map(utxos, func(u wallet.UTXO, _ int) wallet.Outpoint {
 		return wallet.Outpoint{TxID: u.TxID, Vout: u.Vout, Confirmed: u.Confirmations > 0}
 	}))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	return lo.Filter(utxos, func(u wallet.UTXO, _ int) bool {
 		return u.Spendable && !frozen[(wallet.Outpoint{TxID: u.TxID, Vout: u.Vout}).Key()]
@@ -310,30 +310,30 @@ func (h *WalletHandler) buildBip47NotificationTx(
 
 	hdPath, err := h.engine.Backend().AddressHDPath(ctx, walletID, picked.Address)
 	if err != nil {
-		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("address hd path: %w", err))
+		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("address hd path: %w", err).Error())
 	}
 	if hdPath == "" {
-		return "", "", connect.NewError(connect.CodeInternal,
-			fmt.Errorf("no HD key path for address %s; cannot derive privkey for BIP47 blinding", picked.Address))
+		return "", "", connect.Errorf(connect.CodeInternal,
+			"no HD key path for address %s; cannot derive privkey for BIP47 blinding", picked.Address)
 	}
 
 	desigPriv, err := bip47send.DerivePrivKeyFromHDPath(seedHex, hdPath)
 	if err != nil {
-		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("derive designated input privkey: %w", err))
+		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("derive designated input privkey: %w", err).Error())
 	}
 
 	notifAddr, err := bip47.DeriveNotificationAddress(recipient, netParams)
 	if err != nil {
-		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("recipient notification address: %w", err))
+		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("recipient notification address: %w", err).Error())
 	}
 
 	changeAddrStr, err := h.engine.Backend().NextChangeAddress(ctx, walletID)
 	if err != nil {
-		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("get change address: %w", err))
+		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("get change address: %w", err).Error())
 	}
 	changeAddr, err := btcutil.DecodeAddress(changeAddrStr, netParams)
 	if err != nil {
-		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("decode change address: %w", err))
+		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("decode change address: %w", err).Error())
 	}
 
 	desig := bip47send.DesignatedInput{
@@ -356,7 +356,7 @@ func (h *WalletHandler) buildBip47NotificationTx(
 		netParams,
 	)
 	if err != nil {
-		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("build notification tx: %w", err))
+		return "", "", connect.NewError(connect.CodeInternal, fmt.Errorf("build notification tx: %w", err).Error())
 	}
 	return rawHex, picked.Address, nil
 }
@@ -370,11 +370,11 @@ func (h *WalletHandler) broadcastBip47Notification(ctx context.Context, walletID
 	if wallet.ReplayProtect(h.svc.Network(), allowReplay) {
 		lockTime, err := config.ECashReplayLockTime()
 		if err != nil {
-			return "", connect.NewError(connect.CodeUnavailable, err)
+			return "", connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 		}
 		protectedHex, err := replay.ApplyLockTimeHex(rawHex, lockTime)
 		if err != nil {
-			return "", connect.NewError(connect.CodeInternal, err)
+			return "", connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 		rawHex = protectedHex
 	}
diff --git a/sidechain-orchestrator/api/bip47_send_fee_test.go b/sidechain-orchestrator/api/bip47_send_fee_test.go
index 2e37cead48..3e76987ce5 100644
--- a/sidechain-orchestrator/api/bip47_send_fee_test.go
+++ b/sidechain-orchestrator/api/bip47_send_fee_test.go
@@ -9,7 +9,7 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -218,7 +218,7 @@ func TestSendTransactionBip47WithoutAFeeEstimateBroadcastsNothing(t *testing.T)
 		Destinations: map[string]int64{code: 50_000},
 	}
 
-	_, err = h.SendTransaction(ctx, connect.NewRequest(send))
+	_, err = h.SendTransaction(ctx, send)
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "fee estimate")
 	assert.Empty(t, chain.broadcast, "no notification may go out before the payment is priced")
@@ -233,7 +233,7 @@ func TestSendTransactionBip47WithoutAFeeEstimateBroadcastsNothing(t *testing.T)
 	// came from the missing estimate alone.
 	chain.feeErr = nil
 	chain.feeRate = 5
-	_, err = h.SendTransaction(ctx, connect.NewRequest(send))
+	_, err = h.SendTransaction(ctx, send)
 	require.NoError(t, err)
 	assert.Len(t, chain.broadcast, 2, "the notification and the payment both go out")
 
@@ -246,7 +246,7 @@ func TestSendTransactionBip47WithoutAFeeEstimateBroadcastsNothing(t *testing.T)
 	nextIndex := state.NextSendIndex
 
 	chain.feeErr = errors.New("estimatefee: connection refused")
-	_, err = h.SendTransaction(ctx, connect.NewRequest(send))
+	_, err = h.SendTransaction(ctx, send)
 	require.Error(t, err)
 	assert.Len(t, chain.broadcast, 2, "a payment the wallet cannot price sends nothing")
 
@@ -281,10 +281,10 @@ func TestSendTransactionBip47NotificationPaysTheSendRate(t *testing.T) {
 	recipient, err := bip47.PaymentCodeFromSeed(strings.Repeat("ab", 32), net)
 	require.NoError(t, err)
 
-	_, err = h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err = h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:     w.ID,
 		Destinations: map[string]int64{recipient.Base58(): 50_000},
-	}))
+	})
 	require.NoError(t, err)
 	require.Len(t, chain.broadcast, 2)
 
@@ -324,10 +324,10 @@ func TestSendTransactionBip47AboveTheFeeCapBroadcastsNothing(t *testing.T) {
 	recipient, err := bip47.PaymentCodeFromSeed(strings.Repeat("ab", 32), net)
 	require.NoError(t, err)
 
-	_, err = h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err = h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:     w.ID,
 		Destinations: map[string]int64{recipient.Base58(): 50_000},
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	assert.Contains(t, err.Error(), "above the limit")
@@ -366,13 +366,13 @@ func TestPreviewSendBip47PricesTheNotification(t *testing.T) {
 	const rate = 5
 
 	preview := func() *pb.PreviewSendResponse {
-		resp, err := h.PreviewSend(context.Background(), connect.NewRequest(&pb.PreviewSendRequest{
+		resp, err := h.PreviewSend(context.Background(), &pb.PreviewSendRequest{
 			WalletId:           w.ID,
 			Destinations:       map[string]int64{code: 50_000},
 			FeeRateSatPerVbyte: rate,
-		}))
+		})
 		require.NoError(t, err)
-		return resp.Msg
+		return resp
 	}
 
 	first := preview()
@@ -389,13 +389,13 @@ func TestPreviewSendBip47PricesTheNotification(t *testing.T) {
 	require.NoError(t, err)
 	assert.Nil(t, state, "a preview reserves no index")
 
-	_, err = h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err = h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:           w.ID,
 		Destinations:       map[string]int64{code: 50_000},
 		FeeRateSatPerVbyte: rate,
 		RequiredInputs:     first.Inputs,
 		NotificationInput:  first.NotificationInput,
-	}))
+	})
 	require.NoError(t, err)
 	require.Len(t, chain.broadcast, 2, "the notification and the payment both go out")
 
@@ -455,14 +455,14 @@ func TestPreviewSendBip47ReservesNoIndex(t *testing.T) {
 	require.NoError(t, err)
 	code := recipient.Base58()
 
-	resp, err := h.PreviewSend(context.Background(), connect.NewRequest(&pb.PreviewSendRequest{
+	resp, err := h.PreviewSend(context.Background(), &pb.PreviewSendRequest{
 		WalletId:           w.ID,
 		Destinations:       map[string]int64{code: 50_000},
 		FeeRateSatPerVbyte: 5,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Positive(t, resp.Msg.FeeSats)
-	assert.NotNil(t, resp.Msg.NotificationInput)
+	assert.Positive(t, resp.FeeSats)
+	assert.NotNil(t, resp.NotificationInput)
 	assert.Empty(t, chain.broadcast)
 
 	state, err := store.GetState(w.ID, code)
@@ -470,13 +470,13 @@ func TestPreviewSendBip47ReservesNoIndex(t *testing.T) {
 	assert.Nil(t, state, "a preview reserves no index")
 
 	require.NoError(t, store.MarkNotified(w.ID, code, strings.Repeat("cd", 32)))
-	resp, err = h.PreviewSend(context.Background(), connect.NewRequest(&pb.PreviewSendRequest{
+	resp, err = h.PreviewSend(context.Background(), &pb.PreviewSendRequest{
 		WalletId:           w.ID,
 		Destinations:       map[string]int64{code: 50_000},
 		FeeRateSatPerVbyte: 5,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Len(t, resp.Msg.Inputs, 1, "a notified recipient takes the payment alone, so its coins can be pinned")
+	assert.Len(t, resp.Inputs, 1, "a notified recipient takes the payment alone, so its coins can be pinned")
 	state, err = store.GetState(w.ID, code)
 	require.NoError(t, err)
 	assert.Zero(t, state.NextSendIndex, "a preview reserves no index")
@@ -511,24 +511,24 @@ func TestPreviewSendBip47OneCoinGivesAnEstimate(t *testing.T) {
 	code := recipient.Base58()
 	const rate = 5
 
-	resp, err := h.PreviewSend(context.Background(), connect.NewRequest(&pb.PreviewSendRequest{
+	resp, err := h.PreviewSend(context.Background(), &pb.PreviewSendRequest{
 		WalletId:           w.ID,
 		Destinations:       map[string]int64{code: 50_000},
 		FeeRateSatPerVbyte: rate,
-	}))
+	})
 	require.NoError(t, err)
-	assert.True(t, resp.Msg.FeeIsEstimate)
-	assert.Positive(t, resp.Msg.FeeSats)
-	assert.Equal(t, bip47send.EstimateNotificationFee(rate), resp.Msg.NotificationFeeSats)
-	assert.Empty(t, resp.Msg.Inputs, "the payment coin does not exist before the notification")
-	assert.Nil(t, resp.Msg.NotificationInput)
+	assert.True(t, resp.FeeIsEstimate)
+	assert.Positive(t, resp.FeeSats)
+	assert.Equal(t, bip47send.EstimateNotificationFee(rate), resp.NotificationFeeSats)
+	assert.Empty(t, resp.Inputs, "the payment coin does not exist before the notification")
+	assert.Nil(t, resp.NotificationInput)
 	assert.Empty(t, chain.broadcast)
 
-	_, err = h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err = h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:           w.ID,
 		Destinations:       map[string]int64{code: 50_000},
 		FeeRateSatPerVbyte: rate,
-	}))
+	})
 	require.NoError(t, err)
 	assert.Len(t, chain.broadcast, 2, "the notification and the payment both go out")
 }
@@ -560,12 +560,12 @@ func TestPreviewSendBip47OneCoinRefusesWhatTheChangeCannotPay(t *testing.T) {
 	recipient, err := bip47.PaymentCodeFromSeed(strings.Repeat("ab", 32), net)
 	require.NoError(t, err)
 
-	_, err = h.PreviewSend(context.Background(), connect.NewRequest(&pb.PreviewSendRequest{
+	_, err = h.PreviewSend(context.Background(), &pb.PreviewSendRequest{
 		WalletId:              w.ID,
 		Destinations:          map[string]int64{recipient.Base58(): coinSats},
 		FeeRateSatPerVbyte:    5,
 		SubtractFeeFromAmount: true,
-	}))
+	})
 	require.ErrorContains(t, err, "after the BIP47 notification")
 }
 
@@ -603,10 +603,10 @@ func TestSendTransactionBip47StampsTheNetworkLockTime(t *testing.T) {
 			recipient, err := bip47.PaymentCodeFromSeed(strings.Repeat("ab", 32), net)
 			require.NoError(t, err)
 
-			_, err = h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+			_, err = h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 				WalletId:     w.ID,
 				Destinations: map[string]int64{recipient.Base58(): 50_000},
-			}))
+			})
 			require.NoError(t, err)
 			require.Len(t, chain.broadcast, 2)
 
diff --git a/sidechain-orchestrator/api/bitcoin_conf_handler.go b/sidechain-orchestrator/api/bitcoin_conf_handler.go
index 8f9ebd85e7..fcf300e820 100644
--- a/sidechain-orchestrator/api/bitcoin_conf_handler.go
+++ b/sidechain-orchestrator/api/bitcoin_conf_handler.go
@@ -7,7 +7,7 @@ import (
 	"path/filepath"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
@@ -27,14 +27,14 @@ func NewBitcoinConfHandler(orch *orchestrator.Orchestrator) *BitcoinConfHandler
 	return &BitcoinConfHandler{orch: orch, conf: orch.BitcoinConf}
 }
 
-func (h *BitcoinConfHandler) GetBitcoinConfig(ctx context.Context, req *connect.Request[pb.GetBitcoinConfigRequest]) (*connect.Response[pb.GetBitcoinConfigResponse], error) {
+func (h *BitcoinConfHandler) GetBitcoinConfig(ctx context.Context, req *pb.GetBitcoinConfigRequest) (*pb.GetBitcoinConfigResponse, error) {
 	if h.conf == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bitcoin config manager not initialized"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bitcoin config manager not initialized")
 	}
 
 	// Reload from disk to get latest state
 	if err := h.conf.LoadConfig(false); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("reload config: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("reload config: %w", err).Error())
 	}
 
 	network := h.conf.Network
@@ -69,7 +69,7 @@ func (h *BitcoinConfHandler) GetBitcoinConfig(ctx context.Context, req *connect.
 		}
 	}
 
-	return connect.NewResponse(&pb.GetBitcoinConfigResponse{
+	return &pb.GetBitcoinConfigResponse{
 		Network:                   string(network),
 		RpcPort:                   int32(h.conf.GetRPCPort()),
 		HasPrivateConf:            h.conf.HasPrivateConf,
@@ -86,26 +86,26 @@ func (h *BitcoinConfHandler) GetBitcoinConfig(ctx context.Context, req *connect.
 		EcashEsploraUrl:           config.EsploraURLForNetwork(config.NetworkECash),
 		EcashExplorerHost:         config.ECashExplorerHost(),
 		MustSelectDatadir:         h.orch.PlanNetworkChange(orchestrator.NetworkChangeRequest{}).MustSelectDatadir,
-	}), nil
+	}, nil
 }
 
-func (h *BitcoinConfHandler) PrepareNetworkChange(ctx context.Context, req *connect.Request[pb.PrepareNetworkChangeRequest]) (*connect.Response[pb.NetworkChangePlan], error) {
-	network := strings.TrimSpace(req.Msg.Network)
+func (h *BitcoinConfHandler) PrepareNetworkChange(ctx context.Context, req *pb.PrepareNetworkChangeRequest) (*pb.NetworkChangePlan, error) {
+	network := strings.TrimSpace(req.Network)
 	if _, known := h.orch.NetworkForOption(network); !known {
 		if _, named := config.LookupNetwork(network); network != "" && !named {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("unknown network %q", network))
+			return nil, connect.Errorf(connect.CodeInvalidArgument, "unknown network %q", network)
 		}
 	}
 	plan := h.orch.PlanNetworkChange(orchestrator.NetworkChangeRequest{
 		Network:       network,
-		WalletBackend: walletBackendFromProto(req.Msg.WalletBackend),
-		WalletID:      strings.TrimSpace(req.Msg.WalletId),
+		WalletBackend: walletBackendFromProto(req.WalletBackend),
+		WalletID:      strings.TrimSpace(req.WalletId),
 	})
-	return connect.NewResponse(networkChangePlanToProto(plan)), nil
+	return networkChangePlanToProto(plan), nil
 }
 
-func (h *BitcoinConfHandler) ListNetworks(ctx context.Context, req *connect.Request[pb.ListNetworksRequest]) (*connect.Response[pb.ListNetworksResponse], error) {
-	return connect.NewResponse(&pb.ListNetworksResponse{Networks: networkOptionsToProto(h.orch.ListNetworks())}), nil
+func (h *BitcoinConfHandler) ListNetworks(ctx context.Context, req *pb.ListNetworksRequest) (*pb.ListNetworksResponse, error) {
+	return &pb.ListNetworksResponse{Networks: networkOptionsToProto(h.orch.ListNetworks())}, nil
 }
 
 func networkOptionsToProto(options []orchestrator.NetworkOption) []*pb.NetworkOption {
@@ -121,16 +121,16 @@ func networkOptionsToProto(options []orchestrator.NetworkOption) []*pb.NetworkOp
 	return rows
 }
 
-func (h *BitcoinConfHandler) TakeNewNetworks(ctx context.Context, req *connect.Request[pb.TakeNewNetworksRequest]) (*connect.Response[pb.TakeNewNetworksResponse], error) {
-	return connect.NewResponse(&pb.TakeNewNetworksResponse{Networks: networkOptionsToProto(h.orch.TakeNewNetworks())}), nil
+func (h *BitcoinConfHandler) TakeNewNetworks(ctx context.Context, req *pb.TakeNewNetworksRequest) (*pb.TakeNewNetworksResponse, error) {
+	return &pb.TakeNewNetworksResponse{Networks: networkOptionsToProto(h.orch.TakeNewNetworks())}, nil
 }
 
-func (h *BitcoinConfHandler) PlanECashSwitch(ctx context.Context, req *connect.Request[pb.PlanECashSwitchRequest]) (*connect.Response[pb.PlanECashSwitchResponse], error) {
-	plan, err := h.orch.PlanECashSwitch(strings.TrimSpace(req.Msg.NetworkId))
+func (h *BitcoinConfHandler) PlanECashSwitch(ctx context.Context, req *pb.PlanECashSwitchRequest) (*pb.PlanECashSwitchResponse, error) {
+	plan, err := h.orch.PlanECashSwitch(strings.TrimSpace(req.NetworkId))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.PlanECashSwitchResponse{
+	return &pb.PlanECashSwitchResponse{
 		FromId:        plan.FromID,
 		ToId:          plan.ToID,
 		RewindHeight:  plan.RewindHeight,
@@ -138,38 +138,38 @@ func (h *BitcoinConfHandler) PlanECashSwitch(ctx context.Context, req *connect.R
 		Blocked:       plan.Blocked,
 		HasChainData:  plan.HasChainData,
 		ChainId:       plan.ChainID,
-	}), nil
+	}, nil
 }
 
-func (h *BitcoinConfHandler) SetBitcoinConfigNetwork(ctx context.Context, req *connect.Request[pb.SetBitcoinConfigNetworkRequest]) (*connect.Response[pb.SetBitcoinConfigNetworkResponse], error) {
+func (h *BitcoinConfHandler) SetBitcoinConfigNetwork(ctx context.Context, req *pb.SetBitcoinConfigNetworkRequest) (*pb.SetBitcoinConfigNetworkResponse, error) {
 	if h.conf == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bitcoin config manager not initialized"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bitcoin config manager not initialized")
 	}
 
-	selection := strings.TrimSpace(req.Msg.Network)
+	selection := strings.TrimSpace(req.Network)
 	if selection == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("network is required"))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "network is required")
 	}
 
 	network, ok := h.orch.NetworkForOption(selection)
 	if !ok {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("unknown network %q", selection))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "unknown network %q", selection)
 	}
 	networkStr := string(network)
 
-	if dataDir := strings.TrimSpace(req.Msg.DataDir); dataDir != "" {
+	if dataDir := strings.TrimSpace(req.DataDir); dataDir != "" {
 		if err := validateDirWritable(dataDir); err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("directory not writable: %w", err))
+			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("directory not writable: %w", err).Error())
 		}
 		if err := h.orch.EditBitcoinConfig(func() error {
 			return h.conf.UpdateDataDir(dataDir, network)
 		}); err != nil {
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("update datadir: %w", err))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("update datadir: %w", err).Error())
 		}
 	}
 
 	if _, known := config.LookupNetwork(networkStr); networkStr != "" && !known {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("unknown network %q", networkStr))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "unknown network %q", networkStr)
 	}
 	// Apply is authoritative: re-plan so a stale prepare can't smuggle through a
 	// requirement the user never resolved.
@@ -191,21 +191,21 @@ func (h *BitcoinConfHandler) SetBitcoinConfigNetwork(ctx context.Context, req *c
 		// live chain; from another network the pick alone is the change.
 		if onECash && planErr == nil && ecashPlan.FromID != "" && ecashPlan.FromID != ecashPlan.ToID {
 			if err := h.orch.ApplyECashSwitch(ctx, selection); err != nil {
-				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("switch ecash network: %w", err))
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("switch ecash network: %w", err).Error())
 			}
-			return connect.NewResponse(&pb.SetBitcoinConfigNetworkResponse{
+			return &pb.SetBitcoinConfigNetworkResponse{
 				Applied: networkChangePlanToProto(h.orch.PlanNetworkChange(orchestrator.NetworkChangeRequest{})),
-			}), nil
+			}, nil
 		}
 		if err := h.orch.SelectECashNetwork(selection); err != nil {
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("select ecash network: %w", err))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("select ecash network: %w", err).Error())
 		}
 		// The swap below writes the conf and starts the binaries, and both read
 		// the id from memory. A pick that only reached the settings file would
 		// boot the network the user just left.
 		if planErr == nil {
 			if err := h.orch.AdoptECashID(ecashPlan.ToID); err != nil {
-				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("select ecash network: %w", err))
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("select ecash network: %w", err).Error())
 			}
 			previousECashID = ecashPlan.FromID
 		}
@@ -215,19 +215,19 @@ func (h *BitcoinConfHandler) SetBitcoinConfigNetwork(ctx context.Context, req *c
 	}
 
 	if err := h.orch.SwapNetwork(ctx, network); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("swap network: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("swap network: %w", err).Error())
 	}
 
-	return connect.NewResponse(&pb.SetBitcoinConfigNetworkResponse{Applied: networkChangePlanToProto(plan)}), nil
+	return &pb.SetBitcoinConfigNetworkResponse{Applied: networkChangePlanToProto(plan)}, nil
 }
 
-func (h *BitcoinConfHandler) WriteBitcoinConfig(ctx context.Context, req *connect.Request[pb.WriteBitcoinConfigRequest]) (*connect.Response[pb.WriteBitcoinConfigResponse], error) {
+func (h *BitcoinConfHandler) WriteBitcoinConfig(ctx context.Context, req *pb.WriteBitcoinConfigRequest) (*pb.WriteBitcoinConfigResponse, error) {
 	if h.conf == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bitcoin config manager not initialized"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bitcoin config manager not initialized")
 	}
 
 	if err := h.orch.EditBitcoinConfig(func() error {
-		if err := h.conf.WriteConfig(req.Msg.ConfigContent); err != nil {
+		if err := h.conf.WriteConfig(req.ConfigContent); err != nil {
 			return fmt.Errorf("write config: %w", err)
 		}
 		if err := h.conf.LoadConfig(false); err != nil {
@@ -235,42 +235,42 @@ func (h *BitcoinConfHandler) WriteBitcoinConfig(ctx context.Context, req *connec
 		}
 		return nil
 	}); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.WriteBitcoinConfigResponse{}), nil
+	return &pb.WriteBitcoinConfigResponse{}, nil
 }
 
-func (h *BitcoinConfHandler) SetBitcoinConfigDataDir(ctx context.Context, req *connect.Request[pb.SetBitcoinConfigDataDirRequest]) (*connect.Response[pb.SetBitcoinConfigDataDirResponse], error) {
+func (h *BitcoinConfHandler) SetBitcoinConfigDataDir(ctx context.Context, req *pb.SetBitcoinConfigDataDirRequest) (*pb.SetBitcoinConfigDataDirResponse, error) {
 	if h.conf == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bitcoin config manager not initialized"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bitcoin config manager not initialized")
 	}
 
-	networkStr := strings.TrimSpace(req.Msg.Network)
+	networkStr := strings.TrimSpace(req.Network)
 	if networkStr == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("network is required"))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "network is required")
 	}
 	forNetwork, known := config.LookupNetwork(networkStr)
 	if !known {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("unknown network %q", networkStr))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "unknown network %q", networkStr)
 	}
 
-	dataDir := strings.TrimSpace(req.Msg.DataDir)
+	dataDir := strings.TrimSpace(req.DataDir)
 
 	// Validate writability when setting (not clearing) a datadir.
 	if dataDir != "" {
 		if err := validateDirWritable(dataDir); err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("directory not writable: %w", err))
+			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("directory not writable: %w", err).Error())
 		}
 	}
 
 	if err := h.orch.EditBitcoinConfig(func() error {
 		return h.conf.UpdateDataDir(dataDir, forNetwork)
 	}); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("update datadir: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("update datadir: %w", err).Error())
 	}
 
-	return connect.NewResponse(&pb.SetBitcoinConfigDataDirResponse{}), nil
+	return &pb.SetBitcoinConfigDataDirResponse{}, nil
 }
 
 // validateDirWritable creates and removes a probe file to confirm the
diff --git a/sidechain-orchestrator/api/bitcoin_conf_handler_extra_test.go b/sidechain-orchestrator/api/bitcoin_conf_handler_extra_test.go
index 9e15ecf2b0..0c67e355ef 100644
--- a/sidechain-orchestrator/api/bitcoin_conf_handler_extra_test.go
+++ b/sidechain-orchestrator/api/bitcoin_conf_handler_extra_test.go
@@ -7,7 +7,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -42,14 +42,14 @@ rpcport=18443
 	require.NotNil(t, orch.BitcoinConf, "BitcoinConfManager must be initialised; without it the handler returns FailedPrecondition")
 
 	h := NewBitcoinConfHandler(orch)
-	resp, err := h.GetBitcoinConfig(context.Background(), connect.NewRequest(&pb.GetBitcoinConfigRequest{}))
+	resp, err := h.GetBitcoinConfig(context.Background(), &pb.GetBitcoinConfigRequest{})
 	require.NoError(t, err)
-	require.NotNil(t, resp.Msg)
+	require.NotNil(t, resp)
 
-	assert.Equal(t, "trusty", resp.Msg.RpcUser, "rpc_user must propagate from bitwindow-bitcoin.conf — bitwindowd's btc-buf proxy needs it")
-	assert.Equal(t, "hunter2", resp.Msg.RpcPassword, "rpc_password must propagate")
-	assert.Equal(t, "signet", resp.Msg.Network)
-	assert.NotEmpty(t, resp.Msg.ConfigContent, "config_content must be non-empty so the conf editor UI has something to render")
+	assert.Equal(t, "trusty", resp.RpcUser, "rpc_user must propagate from bitwindow-bitcoin.conf — bitwindowd's btc-buf proxy needs it")
+	assert.Equal(t, "hunter2", resp.RpcPassword, "rpc_password must propagate")
+	assert.Equal(t, "signet", resp.Network)
+	assert.NotEmpty(t, resp.ConfigContent, "config_content must be non-empty so the conf editor UI has something to render")
 }
 
 // TestSetBitcoinConfigNetwork_RejectsEmpty closes the trivial-but-easy-to-
@@ -60,7 +60,7 @@ func TestSetBitcoinConfigNetwork_RejectsEmpty(t *testing.T) {
 	require.NotNil(t, orch.BitcoinConf)
 	h := NewBitcoinConfHandler(orch)
 
-	_, err := h.SetBitcoinConfigNetwork(context.Background(), connect.NewRequest(&pb.SetBitcoinConfigNetworkRequest{Network: ""}))
+	_, err := h.SetBitcoinConfigNetwork(context.Background(), &pb.SetBitcoinConfigNetworkRequest{Network: ""})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err), "empty network must be rejected as InvalidArgument; %v", err)
 }
@@ -75,7 +75,7 @@ func TestSetBitcoinConfigNetwork_NoConfManager(t *testing.T) {
 	orch.BitcoinConf = nil
 	h := NewBitcoinConfHandler(orch)
 
-	_, err := h.SetBitcoinConfigNetwork(context.Background(), connect.NewRequest(&pb.SetBitcoinConfigNetworkRequest{Network: "regtest"}))
+	_, err := h.SetBitcoinConfigNetwork(context.Background(), &pb.SetBitcoinConfigNetworkRequest{Network: "regtest"})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 }
@@ -102,10 +102,10 @@ func TestGetBitcoinConfigReportsCookieCredentials(t *testing.T) {
 	require.NoError(t, os.WriteFile(cookie, []byte("__cookie__:s3cret"), 0o600))
 	t.Cleanup(func() { _ = os.Remove(cookie) })
 
-	resp, err := NewBitcoinConfHandler(orch).GetBitcoinConfig(context.Background(), connect.NewRequest(&pb.GetBitcoinConfigRequest{}))
+	resp, err := NewBitcoinConfHandler(orch).GetBitcoinConfig(context.Background(), &pb.GetBitcoinConfigRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, "__cookie__", resp.Msg.RpcUser)
-	assert.Equal(t, "s3cret", resp.Msg.RpcPassword)
+	assert.Equal(t, "__cookie__", resp.RpcUser)
+	assert.Equal(t, "s3cret", resp.RpcPassword)
 }
 
 // The pick clears the retired eCash chain and moves what the next boot runs.
@@ -135,10 +135,10 @@ func TestSetBitcoinConfigNetwork_RefusesBeforeMovingTheECashPick(t *testing.T) {
 	require.Equal(t, "drynet4", orch.RunningECashID(orch.Catalog))
 
 	h := NewBitcoinConfHandler(orch)
-	_, err := h.SetBitcoinConfigNetwork(context.Background(), connect.NewRequest(&pb.SetBitcoinConfigNetworkRequest{
+	_, err := h.SetBitcoinConfigNetwork(context.Background(), &pb.SetBitcoinConfigNetworkRequest{
 		Network: "alphanet",
 		DataDir: filepath.Join(confPath, "not-a-directory"),
-	}))
+	})
 	require.Error(t, err, "an unwritable datadir must be refused")
 
 	assert.Equal(t, "drynet4", orch.RunningECashID(orch.Catalog),
diff --git a/sidechain-orchestrator/api/bmm_bids_enforcer_test.go b/sidechain-orchestrator/api/bmm_bids_enforcer_test.go
index 60207e968c..67aa1af907 100644
--- a/sidechain-orchestrator/api/bmm_bids_enforcer_test.go
+++ b/sidechain-orchestrator/api/bmm_bids_enforcer_test.go
@@ -1,12 +1,13 @@
 package api
 
 import (
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"context"
 	"io"
 	"net/http"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -29,11 +30,11 @@ type bidValidator struct {
 }
 
 func (v *bidValidator) GetSeenBmmRequests(
-	_ context.Context, req *connect.Request[enforcerpb.GetSeenBmmRequestsRequest],
-) (*connect.Response[enforcerpb.GetSeenBmmRequestsResponse], error) {
-	v.askedParent = req.Msg.GetPrevBlockHash().GetHex().GetValue()
-	v.askedSlot = req.Msg.GetSidechainNumber().GetValue()
-	return connect.NewResponse(&enforcerpb.GetSeenBmmRequestsResponse{
+	_ context.Context, req *enforcerpb.GetSeenBmmRequestsRequest,
+) (*enforcerpb.GetSeenBmmRequestsResponse, error) {
+	v.askedParent = req.GetPrevBlockHash().GetHex().GetValue()
+	v.askedSlot = req.GetSidechainNumber().GetValue()
+	return &enforcerpb.GetSeenBmmRequestsResponse{
 		Requests: []*enforcerpb.GetSeenBmmRequestsResponse_BmmRequest{
 			{
 				SidechainNumber: 9,
@@ -48,7 +49,7 @@ func (v *bidValidator) GetSeenBmmRequests(
 				BidSats:         25_000,
 			},
 		},
-	}), nil
+	}, nil
 }
 
 // The enforcer holds every bid the mainchain mempool carries, so both modes
@@ -59,8 +60,9 @@ func TestListBidsReadsTheEnforcerInBothModes(t *testing.T) {
 		t.Run(string(mode), func(t *testing.T) {
 			validator := &bidValidator{}
 			mux := http.NewServeMux()
-			path, handler := enforcerrpc.NewValidatorServiceHandler(validator)
-			mux.Handle(path, handler)
+			rpcServer := connect.NewServer()
+			enforcerrpc.RegisterValidatorServiceHandler(rpcServer, validator)
+			connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 			server := h2cServer(mux)
 			t.Cleanup(server.Close)
 			host, port := hostPort(t, server)
@@ -81,18 +83,18 @@ func TestListBidsReadsTheEnforcerInBothModes(t *testing.T) {
 			require.Equal(t, mode, orch.NodeMode())
 
 			resp, err := NewBMMHandler(orch, nil).ListBids(context.Background(),
-				connect.NewRequest(&bmmpb.ListBidsRequest{
+				&bmmpb.ListBidsRequest{
 					Sidechain:    pb.BinaryType_BINARY_TYPE_THUNDER,
 					PrevMainHash: "parent-1",
-				}))
+				})
 			require.NoError(t, err)
 
-			require.Len(t, resp.Msg.Bids, 2)
-			assert.Equal(t, "rich", resp.Msg.Bids[0].Txid, "the highest bid comes first")
-			assert.EqualValues(t, 25_000, resp.Msg.Bids[0].BidSats)
-			assert.Equal(t, "block-b", resp.Msg.Bids[0].CriticalHash)
-			assert.Equal(t, "parent-1", resp.Msg.Bids[0].PrevMainHash)
-			assert.Equal(t, "cheap", resp.Msg.Bids[1].Txid)
+			require.Len(t, resp.Bids, 2)
+			assert.Equal(t, "rich", resp.Bids[0].Txid, "the highest bid comes first")
+			assert.EqualValues(t, 25_000, resp.Bids[0].BidSats)
+			assert.Equal(t, "block-b", resp.Bids[0].CriticalHash)
+			assert.Equal(t, "parent-1", resp.Bids[0].PrevMainHash)
+			assert.Equal(t, "cheap", resp.Bids[1].Txid)
 
 			assert.Equal(t, "parent-1", validator.askedParent)
 			assert.EqualValues(t, 9, validator.askedSlot)
diff --git a/sidechain-orchestrator/api/bmm_cancel.go b/sidechain-orchestrator/api/bmm_cancel.go
index 82ef90a86a..bce60b767d 100644
--- a/sidechain-orchestrator/api/bmm_cancel.go
+++ b/sidechain-orchestrator/api/bmm_cancel.go
@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"math"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	bmmpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1"
 	wpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
@@ -24,34 +24,34 @@ const defaultIncrementalFeeSatPerKvB = 1000
 // together. It carries no M8, so the mempool drops the request and the coins
 // come back.
 func (h *BMMHandler) CancelBid(
-	ctx context.Context, req *connect.Request[bmmpb.CancelBidRequest],
-) (*connect.Response[bmmpb.CancelBidResponse], error) {
+	ctx context.Context, req *bmmpb.CancelBidRequest,
+) (*bmmpb.CancelBidResponse, error) {
 	if h.wallet == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("no wallet is loaded"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "no wallet is loaded")
 	}
-	if req.Msg.Txid == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("name the bid to cancel"))
+	if req.Txid == "" {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "name the bid to cancel")
 	}
-	walletID, err := h.wallet.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.wallet.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	own := h.ownBids()
 	tip, err := own.tip(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
-	if err := requireStrandedBid(ctx, own, walletID, req.Msg.Txid, tip); err != nil {
+	if err := requireStrandedBid(ctx, own, walletID, req.Txid, tip); err != nil {
 		return nil, err
 	}
 
-	replacement, err := bidSource{h: h, own: own}.Replacement(ctx, walletID, req.Msg.Txid)
+	replacement, err := bidSource{h: h, own: own}.Replacement(ctx, walletID, req.Txid)
 	if err != nil {
 		return nil, err
 	}
 	inputs, evicted := replacement.Inputs, replacement.Evicted
-	if err := requireNoLiveBid(ctx, own, walletID, evicted, tip, req.Msg.Txid); err != nil {
+	if err := requireNoLiveBid(ctx, own, walletID, evicted, tip, req.Txid); err != nil {
 		return nil, err
 	}
 
@@ -61,7 +61,7 @@ func (h *BMMHandler) CancelBid(
 	}
 	incrementalSatPerKvB, err := own.incrementalFeeSatPerKvB(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	totalSats, err := inputValueSats(ctx, own, walletID, inputs)
 	if err != nil {
@@ -70,58 +70,58 @@ func (h *BMMHandler) CancelBid(
 	feeSats := wallet.CancelFeeSats(replacement.EvictedFeeSats, vsize, incrementalSatPerKvB, 0)
 	recoveredSats := totalSats - feeSats
 	if recoveredSats < wallet.CancelDustSats {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
 			"the coins under %s hold %d sats, under the %d sat replacement fee plus dust",
-			req.Msg.Txid, totalSats, feeSats))
+			req.Txid, totalSats, feeSats)
 	}
 
-	address, err := h.wallet.GetNewAddress(ctx, connect.NewRequest(&wpb.GetNewAddressRequest{
+	address, err := h.wallet.GetNewAddress(ctx, &wpb.GetNewAddressRequest{
 		WalletId: walletID,
-	}))
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	send, err := h.wallet.SendTransaction(ctx, connect.NewRequest(&wpb.SendTransactionRequest{
+	send, err := h.wallet.SendTransaction(ctx, &wpb.SendTransactionRequest{
 		WalletId:       walletID,
-		Destinations:   map[string]int64{address.Msg.Address: recoveredSats},
+		Destinations:   map[string]int64{address.Address: recoveredSats},
 		RequiredInputs: inputs,
 		FixedFeeSats:   feeSats,
 		Replaceable:    true,
-	}))
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	return connect.NewResponse(&bmmpb.CancelBidResponse{
-		ReplacementTxid: send.Msg.Txid,
+	return &bmmpb.CancelBidResponse{
+		ReplacementTxid: send.Txid,
 		RecoveredSats:   recoveredSats,
 		FeeSats:         feeSats,
 		CancelledTxids:  evicted,
-	}), nil
+	}, nil
 }
 
 // requireStrandedBid refuses a bid the next block can still take. Cancelling
 // one throws away a round the wallet already paid for.
 func requireStrandedBid(ctx context.Context, own ownBids, walletID, txid, tip string) error {
 	if !own.pending(ctx, walletID, txid) {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-			"%s is not an unconfirmed BMM bid", txid))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"%s is not an unconfirmed BMM bid", txid)
 	}
 	if !own.live(ctx, walletID, txid) {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-			"bid %s is not in the mempool", txid))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"bid %s is not in the mempool", txid)
 	}
 	bid, err := own.request(ctx, walletID, txid)
 	if err != nil {
-		return connect.NewError(connect.CodeNotFound, err)
+		return connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	}
 	if bid == nil {
-		return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("%s is not a BMM bid", txid))
+		return connect.Errorf(connect.CodeInvalidArgument, "%s is not a BMM bid", txid)
 	}
 	if bid.PrevMainHash == tip {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-			"bid %s builds on the current tip and can still win", txid))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"bid %s builds on the current tip and can still win", txid)
 	}
 	return nil
 }
@@ -136,7 +136,7 @@ func cancelVsize(ctx context.Context, own ownBids, walletID string, roots []stri
 			return 0, err
 		}
 		if vsize <= 0 {
-			return 0, connect.NewError(connect.CodeInternal, fmt.Errorf("bid %s reports no size", root))
+			return 0, connect.Errorf(connect.CodeInternal, "bid %s reports no size", root)
 		}
 		total += vsize
 	}
@@ -175,8 +175,8 @@ func requireNoLiveBid(ctx context.Context, own ownBids, walletID string, evicted
 			continue
 		}
 		if req.PrevMainHash == tip {
-			return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-				"cancelling %s would evict the live bid %s", cancelling, txid))
+			return connect.Errorf(connect.CodeFailedPrecondition,
+				"cancelling %s would evict the live bid %s", cancelling, txid)
 		}
 	}
 	return nil
@@ -198,8 +198,8 @@ func inputValueSats(ctx context.Context, own ownBids, walletID string, inputs []
 			values[in.Txid] = outs
 		}
 		if int(in.Vout) >= len(outs) {
-			return 0, connect.NewError(connect.CodeInternal, fmt.Errorf(
-				"transaction %s has no output %d", in.Txid, in.Vout))
+			return 0, connect.Errorf(connect.CodeInternal,
+				"transaction %s has no output %d", in.Txid, in.Vout)
 		}
 		total += outs[in.Vout]
 	}
diff --git a/sidechain-orchestrator/api/bmm_cancel_test.go b/sidechain-orchestrator/api/bmm_cancel_test.go
index 8e10f5d88e..99caba5873 100644
--- a/sidechain-orchestrator/api/bmm_cancel_test.go
+++ b/sidechain-orchestrator/api/bmm_cancel_test.go
@@ -9,7 +9,7 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/require"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
@@ -157,11 +157,11 @@ func cancelHandler(t *testing.T, node *cancelNode, w *fakeBidWallet) *BMMHandler
 func cancel(t *testing.T, node *cancelNode, w *fakeBidWallet, txid string) (*bmmpb.CancelBidResponse, error) {
 	t.Helper()
 	resp, err := cancelHandler(t, node, w).CancelBid(
-		context.Background(), connect.NewRequest(&bmmpb.CancelBidRequest{Txid: txid}))
+		context.Background(), &bmmpb.CancelBidRequest{Txid: txid})
 	if err != nil {
 		return nil, err
 	}
-	return resp.Msg, nil
+	return resp, nil
 }
 
 func TestCancelBidPaysTheCoinsBackToItsOwnWallet(t *testing.T) {
diff --git a/sidechain-orchestrator/api/bmm_frozen.go b/sidechain-orchestrator/api/bmm_frozen.go
index 48e0751807..d69dfc21e1 100644
--- a/sidechain-orchestrator/api/bmm_frozen.go
+++ b/sidechain-orchestrator/api/bmm_frozen.go
@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"slices"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
@@ -165,7 +165,7 @@ func (c *bidCache) get(ctx context.Context, txid string) (*orchestrator.BmmReque
 	}
 	bid, err := c.h.m8Request(ctx, txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	c.read[txid] = bid
 	return bid, nil
@@ -176,12 +176,12 @@ func (h *BMMHandler) mempoolAncestors(ctx context.Context, txid string) ([]strin
 	raw, err := h.coreCall(ctx, "getmempoolancestors", fmt.Sprintf("[%q]", txid))
 	if err != nil {
 		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf(
-			"read the ancestors of %s: %w", txid, err))
+			"read the ancestors of %s: %w", txid, err).Error())
 	}
 	var ancestors []string
 	if err := json.Unmarshal(raw, &ancestors); err != nil {
 		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf(
-			"decode the ancestors of %s: %w", txid, err))
+			"decode the ancestors of %s: %w", txid, err).Error())
 	}
 	return ancestors, nil
 }
@@ -213,12 +213,12 @@ func (h *BMMHandler) readSpenderBatch(
 	}
 	params, err := json.Marshal([]any{outputs})
 	if err != nil {
-		return connect.NewError(connect.CodeInternal, fmt.Errorf("build the spender query: %w", err))
+		return connect.NewError(connect.CodeInternal, fmt.Errorf("build the spender query: %w", err).Error())
 	}
 
 	raw, err := h.coreCall(ctx, "gettxspendingprevout", string(params))
 	if err != nil {
-		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the spenders of the wallet coins: %w", err))
+		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the spenders of the wallet coins: %w", err).Error())
 	}
 	var spends []struct {
 		Txid         string `json:"txid"`
@@ -226,7 +226,7 @@ func (h *BMMHandler) readSpenderBatch(
 		SpendingTxid string `json:"spendingtxid"`
 	}
 	if err := json.Unmarshal(raw, &spends); err != nil {
-		return connect.NewError(connect.CodeInternal, fmt.Errorf("decode the spenders of the wallet coins: %w", err))
+		return connect.NewError(connect.CodeInternal, fmt.Errorf("decode the spenders of the wallet coins: %w", err).Error())
 	}
 
 	for _, s := range spends {
diff --git a/sidechain-orchestrator/api/bmm_handler.go b/sidechain-orchestrator/api/bmm_handler.go
index a8faf46972..5113155358 100644
--- a/sidechain-orchestrator/api/bmm_handler.go
+++ b/sidechain-orchestrator/api/bmm_handler.go
@@ -14,7 +14,7 @@ import (
 
 	"github.com/rs/zerolog"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 
@@ -23,6 +23,7 @@ import (
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/engines"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/engines/bmmstate"
 	bmmpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1"
+	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1/bmmv1connect"
 	commonv1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/common/v1"
 	enforcerpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
@@ -59,22 +60,22 @@ type bidWallet interface {
 	// its coin by hand and pins it, so the coin has to leave the list here.
 	HeldCoins() map[string]bool
 	ListUnspent(
-		context.Context, *connect.Request[wpb.ListUnspentRequest],
-	) (*connect.Response[wpb.ListUnspentResponse], error)
+		context.Context, *wpb.ListUnspentRequest,
+	) (*wpb.ListUnspentResponse, error)
 	GetNewAddress(
-		context.Context, *connect.Request[wpb.GetNewAddressRequest],
-	) (*connect.Response[wpb.GetNewAddressResponse], error)
+		context.Context, *wpb.GetNewAddressRequest,
+	) (*wpb.GetNewAddressResponse, error)
 	SendTransaction(
-		context.Context, *connect.Request[wpb.SendTransactionRequest],
-	) (*connect.Response[wpb.SendTransactionResponse], error)
+		context.Context, *wpb.SendTransactionRequest,
+	) (*wpb.SendTransactionResponse, error)
 	// GetTransactionDetails and ListTransactions read our own bids. An install
 	// with no Bitcoin Core reads them here.
 	GetTransactionDetails(
-		context.Context, *connect.Request[wpb.GetTransactionDetailsRequest],
-	) (*connect.Response[wpb.GetTransactionDetailsResponse], error)
+		context.Context, *wpb.GetTransactionDetailsRequest,
+	) (*wpb.GetTransactionDetailsResponse, error)
 	ListTransactions(
-		context.Context, *connect.Request[wpb.ListTransactionsRequest],
-	) (*connect.Response[wpb.ListTransactionsResponse], error)
+		context.Context, *wpb.ListTransactionsRequest,
+	) (*wpb.ListTransactionsResponse, error)
 	// TxStatus reads the chain status of one transaction from the chain source.
 	TxStatus(ctx context.Context, txid string) (wallet.EsploraStatus, error)
 }
@@ -153,7 +154,7 @@ func (h *BMMHandler) requireEnforcerSynced(ctx context.Context) error {
 	}
 	status, err := read(ctx)
 	if err != nil {
-		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("read sync status: %w", err))
+		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("read sync status: %w", err).Error())
 	}
 	return enforcerBiddingBlocked(status, h.runsLocalCore())
 }
@@ -163,22 +164,22 @@ func (h *BMMHandler) requireEnforcerSynced(ctx context.Context) error {
 // Bitcoin Core, which reports a mainchain error at all times.
 func enforcerBiddingBlocked(status *orchestrator.SyncStatus, readsCore bool) error {
 	if status == nil || status.Enforcer == nil || (readsCore && status.Mainchain == nil) {
-		return connect.NewError(connect.CodeUnavailable, fmt.Errorf("sync status unavailable"))
+		return connect.Errorf(connect.CodeUnavailable, "sync status unavailable")
 	}
 	if readsCore && status.Mainchain.Error != "" {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-			"bitcoin core is not available: %s", status.Mainchain.Error))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"bitcoin core is not available: %s", status.Mainchain.Error)
 	}
 	if msg := status.Enforcer.Error; msg != "" {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("enforcer is not available: %s", msg))
+		return connect.Errorf(connect.CodeFailedPrecondition, "enforcer is not available: %s", msg)
 	}
 	if !readsCore {
 		return enforcerLevelWithChainSource(status)
 	}
 	if status.Enforcer.Headers <= 0 || status.Enforcer.Blocks != status.Enforcer.Headers {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
+		return connect.Errorf(connect.CodeFailedPrecondition,
 			"enforcer is still syncing: %d of %d blocks", status.Enforcer.Blocks, status.Enforcer.Headers,
-		))
+		)
 	}
 	return nil
 }
@@ -190,77 +191,77 @@ func enforcerBiddingBlocked(status *orchestrator.SyncStatus, readsCore bool) err
 func enforcerLevelWithChainSource(status *orchestrator.SyncStatus) error {
 	source := status.ChainSource
 	if source == nil || source.Error != "" || source.Blocks <= 0 {
-		return connect.NewError(connect.CodeUnavailable, fmt.Errorf(
-			"the wallet chain source reports no tip to measure the enforcer against"))
+		return connect.Errorf(connect.CodeUnavailable,
+			"the wallet chain source reports no tip to measure the enforcer against")
 	}
 	if status.Enforcer.Blocks < source.Blocks {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
+		return connect.Errorf(connect.CodeFailedPrecondition,
 			"enforcer is still syncing: %d of %d blocks", status.Enforcer.Blocks, source.Blocks,
-		))
+		)
 	}
 	return nil
 }
 
 func (h *BMMHandler) Start(
-	ctx context.Context, req *connect.Request[bmmpb.StartRequest],
-) (*connect.Response[bmmpb.StartResponse], error) {
+	ctx context.Context, req *bmmpb.StartRequest,
+) (*bmmpb.StartResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bmm engine not wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bmm engine not wired")
 	}
-	if _, err := h.sidechainConfig(req.Msg.Sidechain); err != nil {
+	if _, err := h.sidechainConfig(req.Sidechain); err != nil {
 		return nil, err
 	}
-	if req.Msg.MaxBidSats <= 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("max_bid_sats must be positive"))
+	if req.MaxBidSats <= 0 {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "max_bid_sats must be positive")
 	}
 	if err := h.requireEnforcerSynced(ctx); err != nil {
 		return nil, err
 	}
 	// Past validation, an engine failure is a storage one, not a client one.
-	if err := h.engine.Start(ctx, req.Msg.Sidechain, req.Msg.WalletId,
-		req.Msg.MaxBidSats, req.Msg.CapToBlockWorth); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+	if err := h.engine.Start(ctx, req.Sidechain, req.WalletId,
+		req.MaxBidSats, req.CapToBlockWorth); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&bmmpb.StartResponse{}), nil
+	return &bmmpb.StartResponse{}, nil
 }
 
 func (h *BMMHandler) Stop(
-	ctx context.Context, req *connect.Request[bmmpb.StopRequest],
-) (*connect.Response[bmmpb.StopResponse], error) {
+	ctx context.Context, req *bmmpb.StopRequest,
+) (*bmmpb.StopResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bmm engine not wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bmm engine not wired")
 	}
-	if err := h.engine.Stop(req.Msg.Sidechain); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+	if err := h.engine.Stop(req.Sidechain); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&bmmpb.StopResponse{}), nil
+	return &bmmpb.StopResponse{}, nil
 }
 
 func (h *BMMHandler) ClearHistory(
-	ctx context.Context, req *connect.Request[bmmpb.ClearHistoryRequest],
-) (*connect.Response[bmmpb.ClearHistoryResponse], error) {
+	ctx context.Context, req *bmmpb.ClearHistoryRequest,
+) (*bmmpb.ClearHistoryResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bmm engine not wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bmm engine not wired")
 	}
-	if err := h.engine.ClearHistory(req.Msg.Sidechain); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+	if err := h.engine.ClearHistory(req.Sidechain); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&bmmpb.ClearHistoryResponse{}), nil
+	return &bmmpb.ClearHistoryResponse{}, nil
 }
 
 // Watch streams the full bidding state on every change, so a reconnect needs
 // no delta merge.
 func (h *BMMHandler) Watch(
-	ctx context.Context, req *connect.Request[bmmpb.WatchRequest], stream *connect.ServerStream[bmmpb.WatchResponse],
+	ctx context.Context, req *bmmpb.WatchRequest, stream bmmv1connect.BMMServiceWatchServerStream,
 ) error {
 	if h.engine == nil {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bmm engine not wired"))
+		return connect.Errorf(connect.CodeFailedPrecondition, "bmm engine not wired")
 	}
 
 	changed := h.engine.Subscribe(ctx)
 
 	send := func() error {
-		state, err := h.state(ctx, req.Msg.Sidechain)
+		state, err := h.state(ctx, req.Sidechain)
 		if err != nil {
 			return err
 		}
@@ -295,7 +296,7 @@ func (h *BMMHandler) state(ctx context.Context, sidechain pb.BinaryType) (*bmmpb
 
 	history, err := h.engine.History(sidechain)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	out := &bmmpb.WatchResponse{
@@ -312,19 +313,19 @@ func (h *BMMHandler) state(ctx context.Context, sidechain pb.BinaryType) (*bmmpb
 }
 
 func (h *BMMHandler) GetRoundBids(
-	ctx context.Context, req *connect.Request[bmmpb.GetRoundBidsRequest],
-) (*connect.Response[bmmpb.GetRoundBidsResponse], error) {
+	ctx context.Context, req *bmmpb.GetRoundBidsRequest,
+) (*bmmpb.GetRoundBidsResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("bmm engine not wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "bmm engine not wired")
 	}
-	round, err := h.engine.Round(req.Msg.Sidechain, req.Msg.PrevMainHash)
+	round, err := h.engine.Round(req.Sidechain, req.PrevMainHash)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	if round == nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("round %s not found", req.Msg.PrevMainHash))
+		return nil, connect.Errorf(connect.CodeNotFound, "round %s not found", req.PrevMainHash)
 	}
-	return connect.NewResponse(&bmmpb.GetRoundBidsResponse{Round: roundToProto(*round)}), nil
+	return &bmmpb.GetRoundBidsResponse{Round: roundToProto(*round)}, nil
 }
 
 func roundToProto(r bmmstate.Round) *bmmpb.Round {
@@ -421,15 +422,15 @@ func (h *BMMHandler) TemplateWorth(ctx context.Context, sidechainType pb.BinaryT
 // CreateBid assembles a sidechain block and broadcasts an M8 bid for it. The
 // bid is the transaction's fee, which is the only thing a miner can collect.
 func (h *BMMHandler) CreateBid(
-	ctx context.Context, req *connect.Request[bmmpb.CreateBidRequest],
-) (*connect.Response[bmmpb.CreateBidResponse], error) {
-	if err := checkBidInput(req.Msg.BidSats, req.Msg.FeeRateSatVb); err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	ctx context.Context, req *bmmpb.CreateBidRequest,
+) (*bmmpb.CreateBidResponse, error) {
+	if err := checkBidInput(req.BidSats, req.FeeRateSatVb); err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	if err := h.requireEnforcerSynced(ctx); err != nil {
 		return nil, err
 	}
-	cfg, proxy, err := h.sidechainTarget(req.Msg.Sidechain)
+	cfg, proxy, err := h.sidechainTarget(req.Sidechain)
 	if err != nil {
 		return nil, err
 	}
@@ -437,30 +438,30 @@ func (h *BMMHandler) CreateBid(
 	template, err := proxy.GetBlockTemplate(ctx)
 	if errors.Is(err, sidechain.ErrNotReady) {
 		// FailedPrecondition makes the engine ask again on this tip.
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("get block template: %w", err))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("get block template: %w", err).Error())
 	}
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get block template: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get block template: %w", err).Error())
 	}
 	prevMainHash, err := templatePrevMainHash(template.Block)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode block header: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode block header: %w", err).Error())
 	}
 
 	// A bid only reaches the next block, so building on a tip the caller has
 	// already moved past would spend the fee on a round that cannot be won.
-	if want := req.Msg.ExpectPrevMainHash; want != "" && want != prevMainHash {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
+	if want := req.ExpectPrevMainHash; want != "" && want != prevMainHash {
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
 			"sidechain builds on %s, not the current tip %s", prevMainHash, want,
-		))
+		)
 	}
 
 	sizing := bidInput{
-		bidSats:         req.Msg.BidSats,
-		rateSatVb:       req.Msg.FeeRateSatVb,
+		bidSats:         req.BidSats,
+		rateSatVb:       req.FeeRateSatVb,
 		blockWorthSats:  template.FeesSats,
-		maxBidSats:      req.Msg.MaxBidSats,
-		capToBlockWorth: req.Msg.CapToBlockWorth,
+		maxBidSats:      req.MaxBidSats,
+		capToBlockWorth: req.CapToBlockWorth,
 	}
 	bidSats, byRate := bidSizing(sizing)
 
@@ -468,14 +469,14 @@ func (h *BMMHandler) CreateBid(
 		uint8(cfg.Slot), template.CriticalHash, prevMainHash,
 	)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("build bmm request: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("build bmm request: %w", err).Error())
 	}
 
 	// Spending the earlier bid's inputs again replaces it, rather than
 	// bidding against it: only one M8 per slot can be accepted.
 	var requiredInputs []*wpb.UnspentOutput
-	if req.Msg.ReplaceTxid != "" {
-		replacement, err := h.bids().Replacement(ctx, req.Msg.WalletId, req.Msg.ReplaceTxid)
+	if req.ReplaceTxid != "" {
+		replacement, err := h.bids().Replacement(ctx, req.WalletId, req.ReplaceTxid)
 		if err != nil {
 			return nil, err
 		}
@@ -483,15 +484,15 @@ func (h *BMMHandler) CreateBid(
 		ceiling := bidCeiling(sizing)
 		raised, ok := replacementBid(bidSats, replacement.FloorSats, ceiling)
 		if !ok {
-			return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
+			return nil, connect.Errorf(connect.CodeFailedPrecondition,
 				"replacing %s costs %d sats, over the %d sat ceiling",
-				req.Msg.ReplaceTxid, replacement.FloorSats, ceiling))
+				req.ReplaceTxid, replacement.FloorSats, ceiling)
 		}
 		if raised != bidSats {
 			bidSats, byRate = raised, false
 		}
 	} else {
-		coin, err := h.slotCoin(ctx, req.Msg, cfg.Slot, pinSats(bidSats, byRate, req.Msg.FeeRateSatVb))
+		coin, err := h.slotCoin(ctx, req, cfg.Slot, pinSats(bidSats, byRate, req.FeeRateSatVb))
 		if err != nil {
 			return nil, err
 		}
@@ -505,7 +506,7 @@ func (h *BMMHandler) CreateBid(
 	// inputs, or signs a multisig descriptor, builds a larger transaction than
 	// any fixed amount assumes, and would then pay under the rate it asked for.
 	sendReq := &wpb.SendTransactionRequest{
-		WalletId: req.Msg.WalletId,
+		WalletId: req.WalletId,
 		RawOutputs: []*wpb.RawOutput{{
 			ValueSats: 0,
 			ScriptHex: hex.EncodeToString(script),
@@ -514,12 +515,12 @@ func (h *BMMHandler) CreateBid(
 		Replaceable:    true,
 	}
 	if byRate {
-		sendReq.FeeRateSatPerVbyte = int64(math.Ceil(req.Msg.FeeRateSatVb))
+		sendReq.FeeRateSatPerVbyte = int64(math.Ceil(req.FeeRateSatVb))
 	} else {
 		sendReq.FixedFeeSats = bidSats
 	}
 
-	send, err := h.wallet.SendTransaction(ctx, connect.NewRequest(sendReq))
+	send, err := h.wallet.SendTransaction(ctx, sendReq)
 	if err != nil {
 		return nil, err
 	}
@@ -530,79 +531,79 @@ func (h *BMMHandler) CreateBid(
 	// The fee is spent by now, so a lookup that misses — an electrum broadcast
 	// the local node has not seen, or a block that already took it — reports
 	// the asking price rather than losing the bid.
-	paid, ok, err := h.bids().PaidSats(ctx, req.Msg.WalletId, send.Msg.Txid)
+	paid, ok, err := h.bids().PaidSats(ctx, req.WalletId, send.Txid)
 	switch {
 	case err != nil:
-		bidSats = askingBidSats(bidSats, byRate, req.Msg.FeeRateSatVb)
-		zerolog.Ctx(ctx).Warn().Err(err).Str("txid", send.Msg.Txid).
+		bidSats = askingBidSats(bidSats, byRate, req.FeeRateSatVb)
+		zerolog.Ctx(ctx).Warn().Err(err).Str("txid", send.Txid).
 			Msg("could not read what the bid paid, reporting what it asked for")
 	case ok:
 		bidSats = paid
 	default:
-		bidSats = askingBidSats(bidSats, byRate, req.Msg.FeeRateSatVb)
+		bidSats = askingBidSats(bidSats, byRate, req.FeeRateSatVb)
 	}
 
-	return connect.NewResponse(&bmmpb.CreateBidResponse{
+	return &bmmpb.CreateBidResponse{
 		CriticalHash: template.CriticalHash,
-		BmmTxid:      send.Msg.Txid,
+		BmmTxid:      send.Txid,
 		FeesSats:     template.FeesSats,
 		BlockJson:    string(template.Block),
 		PrevMainHash: prevMainHash,
 		BidSats:      bidSats,
-	}), nil
+	}, nil
 }
 
 func (h *BMMHandler) ConnectBid(
-	ctx context.Context, req *connect.Request[bmmpb.ConnectBidRequest],
-) (*connect.Response[bmmpb.ConnectBidResponse], error) {
-	_, proxy, err := h.sidechainTarget(req.Msg.Sidechain)
+	ctx context.Context, req *bmmpb.ConnectBidRequest,
+) (*bmmpb.ConnectBidResponse, error) {
+	_, proxy, err := h.sidechainTarget(req.Sidechain)
 	if err != nil {
 		return nil, err
 	}
 
 	// A sidechain reports an inclusion only for a block it already holds, and it
 	// gets ours from this very call.
-	mainBlockHash := req.Msg.MainBlockHash
+	mainBlockHash := req.MainBlockHash
 	if mainBlockHash == "" {
-		inclusions, err := bmmInclusions(ctx, proxy, req.Msg.CriticalHash)
+		inclusions, err := bmmInclusions(ctx, proxy, req.CriticalHash)
 		if err != nil {
 			return nil, err
 		}
 		mainBlockHash = connectTarget("", inclusions)
 		if mainBlockHash == "" {
-			return connect.NewResponse(&bmmpb.ConnectBidResponse{}), nil
+			return &bmmpb.ConnectBidResponse{}, nil
 		}
 	}
 
-	connected, err := proxy.ConnectBlock(ctx, json.RawMessage(req.Msg.BlockJson), mainBlockHash)
+	connected, err := proxy.ConnectBlock(ctx, json.RawMessage(req.BlockJson), mainBlockHash)
 	if err != nil {
 		if code, ok := jsonrpc.ErrorCode(err); ok && code == jsonrpcInvalidParams {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("connect block: %w", err))
+			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("connect block: %w", err).Error())
 		}
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("connect block: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("connect block: %w", err).Error())
 	}
 	var held bool
 	if !connected {
 		// A sidechain learns of an inclusion by polling, and refuses every block
 		// until it does. The empty answer names no block, which is how the caller
 		// tells that wait from a refusal it must not repeat.
-		inclusions, err := bmmInclusions(ctx, proxy, req.Msg.CriticalHash)
+		inclusions, err := bmmInclusions(ctx, proxy, req.CriticalHash)
 		if err != nil {
 			return nil, err
 		}
 		if connectTarget(mainBlockHash, inclusions) == "" {
-			return connect.NewResponse(&bmmpb.ConnectBidResponse{}), nil
+			return &bmmpb.ConnectBidResponse{}, nil
 		}
-		held, err = proxy.ChainHolds(ctx, req.Msg.CriticalHash, heldBlockDepth)
+		held, err = proxy.ChainHolds(ctx, req.CriticalHash, heldBlockDepth)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the sidechain chain: %w", err))
+			return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the sidechain chain: %w", err).Error())
 		}
 	}
-	return connect.NewResponse(&bmmpb.ConnectBidResponse{
+	return &bmmpb.ConnectBidResponse{
 		Connected:     connected,
 		MainBlockHash: mainBlockHash,
 		Held:          held,
-	}), nil
+	}, nil
 }
 
 // jsonrpcInvalidParams is the answer of a node that cannot decode the block it got.
@@ -614,7 +615,7 @@ const heldBlockDepth = 11
 func bmmInclusions(ctx context.Context, proxy sidechain.BMMNode, criticalHash string) ([]string, error) {
 	inclusions, err := proxy.GetBmmInclusions(ctx, criticalHash)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get bmm inclusions: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get bmm inclusions: %w", err).Error())
 	}
 	return inclusions, nil
 }
@@ -641,47 +642,47 @@ func connectTarget(want string, inclusions []string) string {
 // that one can mine it. An empty prev main hash reads the tip, which is the
 // round a bidder opens now.
 func (h *BMMHandler) ListBids(
-	ctx context.Context, req *connect.Request[bmmpb.ListBidsRequest],
-) (*connect.Response[bmmpb.ListBidsResponse], error) {
-	cfg, err := h.sidechainConfig(req.Msg.Sidechain)
+	ctx context.Context, req *bmmpb.ListBidsRequest,
+) (*bmmpb.ListBidsResponse, error) {
+	cfg, err := h.sidechainConfig(req.Sidechain)
 	if err != nil {
 		return nil, err
 	}
-	bids, err := h.bids().Rivals(ctx, cfg.Slot, req.Msg.PrevMainHash)
+	bids, err := h.bids().Rivals(ctx, cfg.Slot, req.PrevMainHash)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&bmmpb.ListBidsResponse{Bids: bids}), nil
+	return &bmmpb.ListBidsResponse{Bids: bids}, nil
 }
 
 // enforcerBids reads the seen BMM requests of one parent block. An empty prev
 // main hash reads the mainchain tip.
 func (h *BMMHandler) enforcerBids(ctx context.Context, slot int, prevMainHash string) ([]*bmmpb.Bid, error) {
 	if h.orch == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not wired")
 	}
 	if prevMainHash == "" {
 		tip, _, err := h.orch.ChainTip(ctx)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the mainchain tip: %w", err))
+			return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the mainchain tip: %w", err).Error())
 		}
 		prevMainHash = tip
 	}
 
 	validator, err := h.orch.EnforcerValidator()
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
-	resp, err := validator.GetSeenBmmRequests(ctx, connect.NewRequest(&enforcerpb.GetSeenBmmRequestsRequest{
+	resp, err := validator.GetSeenBmmRequests(ctx, &enforcerpb.GetSeenBmmRequestsRequest{
 		PrevBlockHash:   &commonv1.ReverseHex{Hex: wrapperspb.String(prevMainHash)},
 		SidechainNumber: wrapperspb.UInt32(uint32(slot)),
-	}))
+	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the bmm bids: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the bmm bids: %w", err).Error())
 	}
 
-	bids := make([]*bmmpb.Bid, 0, len(resp.Msg.GetRequests()))
-	for _, request := range resp.Msg.GetRequests() {
+	bids := make([]*bmmpb.Bid, 0, len(resp.GetRequests()))
+	for _, request := range resp.GetRequests() {
 		bids = append(bids, &bmmpb.Bid{
 			Txid:         request.GetTxid().GetHex().GetValue(),
 			CriticalHash: request.GetCriticalHash().GetHex().GetValue(),
@@ -763,8 +764,8 @@ func (h *BMMHandler) slotCoin(
 	if coin == nil {
 		// PrepareBMM pays the missing coins. The engine opens the round again on
 		// the next tick, once one of them lands.
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-			"the wallet holds no coin of its own for slot %d", slot))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
+			"the wallet holds no coin of its own for slot %d", slot)
 	}
 	return coin, nil
 }
@@ -786,13 +787,13 @@ func betterSlotCoin(a, b *wpb.UnspentOutput, slotSats int64) bool {
 // PrepareBMM gives every bidding sidechain a coin of its own, and splits one
 // large coin when a wallet holds too few.
 func (h *BMMHandler) PrepareBMM(
-	ctx context.Context, req *connect.Request[bmmpb.PrepareBMMRequest],
-) (*connect.Response[bmmpb.PrepareBMMResponse], error) {
-	if len(req.Msg.Targets) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("targets must name a sidechain"))
+	ctx context.Context, req *bmmpb.PrepareBMMRequest,
+) (*bmmpb.PrepareBMMResponse, error) {
+	if len(req.Targets) == 0 {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "targets must name a sidechain")
 	}
 	if h.wallet == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("no wallet is wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "no wallet is wired")
 	}
 
 	// Two targets can name one wallet, by its id and by the empty active id, and
@@ -801,15 +802,15 @@ func (h *BMMHandler) PrepareBMM(
 		sidechains int32
 		maxBidSats int64
 	}
-	wants := make(map[string]*want, len(req.Msg.Targets))
+	wants := make(map[string]*want, len(req.Targets))
 	var order []string
-	for _, target := range req.Msg.Targets {
+	for _, target := range req.Targets {
 		if target.MaxBidSats <= 0 {
-			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("max_bid_sats must be positive"))
+			return nil, connect.Errorf(connect.CodeInvalidArgument, "max_bid_sats must be positive")
 		}
 		walletID, err := h.wallet.ResolveWalletID(target.WalletId)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+			return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 		}
 		w, ok := wants[walletID]
 		if !ok {
@@ -841,7 +842,7 @@ func (h *BMMHandler) PrepareBMM(
 	if failure != nil {
 		return nil, failure
 	}
-	return connect.NewResponse(out), nil
+	return out, nil
 }
 
 // prepareWallet counts the coins one wallet can bid from, and pays the missing
@@ -918,15 +919,15 @@ func (h *BMMHandler) readWalletCoins(
 	ctx context.Context, walletID string, slot int,
 ) (*walletCoins, error) {
 	if h.wallet == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("no wallet is wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "no wallet is wired")
 	}
 	resolved, err := h.wallet.ResolveWalletID(walletID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	unspent, err := h.wallet.ListUnspent(ctx, connect.NewRequest(&wpb.ListUnspentRequest{
+	unspent, err := h.wallet.ListUnspent(ctx, &wpb.ListUnspentRequest{
 		WalletId: resolved,
-	}))
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -938,7 +939,7 @@ func (h *BMMHandler) readWalletCoins(
 	// catches up. An opening bid over one of those conflicts with that bid, and
 	// the node refuses it at the same fee.
 	bids := newBidCache(h)
-	spent, err := h.bidSpentCoins(ctx, lo.Map(unspent.Msg.Utxos, func(u *wpb.UnspentOutput, _ int) wallet.Outpoint {
+	spent, err := h.bidSpentCoins(ctx, lo.Map(unspent.Utxos, func(u *wpb.UnspentOutput, _ int) wallet.Outpoint {
 		return wallet.Outpoint{TxID: u.Txid, Vout: int(u.Vout), Confirmed: u.Confirmations > 0}
 	}), bids)
 	if err != nil {
@@ -948,7 +949,7 @@ func (h *BMMHandler) readWalletCoins(
 	frozen := h.wallet.HeldCoins()
 
 	out := &walletCoins{held: held}
-	for _, u := range unspent.Msg.Utxos {
+	for _, u := range unspent.Utxos {
 		if !u.Spendable {
 			continue
 		}
@@ -1003,37 +1004,37 @@ func (h *BMMHandler) splitBMMCoins(
 ) (string, error) {
 	want := int64(count)*coinSats + bmmSlotCoinFeeSats
 	if source == nil || source.AmountSats < want {
-		return "", connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-			"no coin holds the %d sats that %d more bmm coins cost", want, count))
+		return "", connect.Errorf(connect.CodeFailedPrecondition,
+			"no coin holds the %d sats that %d more bmm coins cost", want, count)
 	}
 
 	destinations := make(map[string]int64, count)
 	for range count {
-		addr, err := h.wallet.GetNewAddress(ctx, connect.NewRequest(&wpb.GetNewAddressRequest{
+		addr, err := h.wallet.GetNewAddress(ctx, &wpb.GetNewAddressRequest{
 			WalletId: walletID,
-		}))
+		})
 		if err != nil {
 			return "", err
 		}
-		destinations[addr.Msg.Address] = coinSats
+		destinations[addr.Address] = coinSats
 	}
 	if len(destinations) != count {
-		return "", connect.NewError(connect.CodeInternal, fmt.Errorf(
-			"the wallet named %d addresses for %d bmm coins", len(destinations), count))
+		return "", connect.Errorf(connect.CodeInternal,
+			"the wallet named %d addresses for %d bmm coins", len(destinations), count)
 	}
 
-	send, err := h.wallet.SendTransaction(ctx, connect.NewRequest(&wpb.SendTransactionRequest{
+	send, err := h.wallet.SendTransaction(ctx, &wpb.SendTransactionRequest{
 		WalletId:       walletID,
 		Destinations:   destinations,
 		RequiredInputs: []*wpb.UnspentOutput{source},
 		// The source pays this exact fee, or coin selection reaches for a second
 		// coin and puts the split on another slot's lineage.
 		FixedFeeSats: bmmSlotCoinFeeSats,
-	}))
+	})
 	if err != nil {
 		return "", err
 	}
-	return send.Msg.Txid, nil
+	return send.Txid, nil
 }
 
 // pendingSplit is a coin split a wallet waits for.
@@ -1146,14 +1147,14 @@ func (h *BMMHandler) Commitment(
 		return "", err
 	}
 
-	resp, err := validator.GetBmmHStarCommitment(ctx, connect.NewRequest(&enforcerpb.GetBmmHStarCommitmentRequest{
+	resp, err := validator.GetBmmHStarCommitment(ctx, &enforcerpb.GetBmmHStarCommitmentRequest{
 		BlockHash:   &commonv1.ReverseHex{Hex: wrapperspb.String(mainBlockHash)},
 		SidechainId: wrapperspb.UInt32(uint32(cfg.Slot)),
-	}))
+	})
 	if err != nil {
 		return "", fmt.Errorf("get bmm commitment: %w", err)
 	}
-	return resp.Msg.GetCommitment().GetCommitment().GetHex().GetValue(), nil
+	return resp.GetCommitment().GetCommitment().GetHex().GetValue(), nil
 }
 
 // BlockAfter returns the mainchain block that follows prevMainHash on the chain
@@ -1167,14 +1168,14 @@ func (h *BMMHandler) BlockAfter(ctx context.Context, prevMainHash, tipHash strin
 		return "", err
 	}
 
-	resp, err := validator.GetBlockHeaderInfo(ctx, connect.NewRequest(&enforcerpb.GetBlockHeaderInfoRequest{
+	resp, err := validator.GetBlockHeaderInfo(ctx, &enforcerpb.GetBlockHeaderInfoRequest{
 		BlockHash:    &commonv1.ReverseHex{Hex: wrapperspb.String(tipHash)},
 		MaxAncestors: lo.ToPtr(uint32(bmmAncestorWalk)),
-	}))
+	})
 	if err != nil {
 		return "", fmt.Errorf("get block header info: %w", err)
 	}
-	for _, info := range resp.Msg.GetHeaderInfos() {
+	for _, info := range resp.GetHeaderInfos() {
 		if info.GetPrevBlockHash().GetHex().GetValue() == prevMainHash {
 			return info.GetBlockHash().GetHex().GetValue(), nil
 		}
@@ -1191,7 +1192,7 @@ func (h *BMMHandler) sidechainTarget(
 	}
 	node, err := bmmNode(cfg, config.NetworkFromString(h.orch.CurrentNetwork()))
 	if err != nil {
-		return orchestrator.BinaryConfig{}, nil, connect.NewError(connect.CodeUnavailable, err)
+		return orchestrator.BinaryConfig{}, nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	return cfg, node, nil
 }
@@ -1200,8 +1201,8 @@ func (h *BMMHandler) sidechainTarget(
 // claims on the mainchain.
 func (h *BMMHandler) sidechainConfig(binary pb.BinaryType) (orchestrator.BinaryConfig, error) {
 	if h.orch == nil {
-		return orchestrator.BinaryConfig{}, connect.NewError(
-			connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not wired"),
+		return orchestrator.BinaryConfig{}, connect.Errorf(
+			connect.CodeFailedPrecondition, "orchestrator not wired",
 		)
 	}
 	name, _, err := sidechainNames(binary)
@@ -1210,13 +1211,13 @@ func (h *BMMHandler) sidechainConfig(binary pb.BinaryType) (orchestrator.BinaryC
 	}
 	cfg, ok := h.orch.Configs()[name]
 	if !ok {
-		return orchestrator.BinaryConfig{}, connect.NewError(
-			connect.CodeNotFound, fmt.Errorf("sidechain %s is not configured", name),
+		return orchestrator.BinaryConfig{}, connect.Errorf(
+			connect.CodeNotFound, "sidechain %s is not configured", name,
 		)
 	}
 	if cfg.Slot < 0 || cfg.Slot > 255 {
-		return orchestrator.BinaryConfig{}, connect.NewError(
-			connect.CodeFailedPrecondition, fmt.Errorf("sidechain %s has no valid slot", name),
+		return orchestrator.BinaryConfig{}, connect.Errorf(
+			connect.CodeFailedPrecondition, "sidechain %s has no valid slot", name,
 		)
 	}
 	return cfg, nil
diff --git a/sidechain-orchestrator/api/bmm_light_cancel_test.go b/sidechain-orchestrator/api/bmm_light_cancel_test.go
index 2be2bc8109..d8bf251c24 100644
--- a/sidechain-orchestrator/api/bmm_light_cancel_test.go
+++ b/sidechain-orchestrator/api/bmm_light_cancel_test.go
@@ -5,7 +5,7 @@ import (
 	"encoding/hex"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -61,11 +61,11 @@ func lightCancel(t *testing.T, w *fakeBidWallet, txid string) (*bmmpb.CancelBidR
 	h := lightHandler(t)
 	h.wallet = w
 	h.chainTip = func(context.Context) (string, error) { return cancelTip, nil }
-	resp, err := h.CancelBid(context.Background(), connect.NewRequest(&bmmpb.CancelBidRequest{Txid: txid}))
+	resp, err := h.CancelBid(context.Background(), &bmmpb.CancelBidRequest{Txid: txid})
 	if err != nil {
 		return nil, err
 	}
-	return resp.Msg, nil
+	return resp, nil
 }
 
 func TestDescendantsWalksEveryChild(t *testing.T) {
diff --git a/sidechain-orchestrator/api/bmm_mode_test.go b/sidechain-orchestrator/api/bmm_mode_test.go
index da6fe6ac97..cf9d7f1927 100644
--- a/sidechain-orchestrator/api/bmm_mode_test.go
+++ b/sidechain-orchestrator/api/bmm_mode_test.go
@@ -7,7 +7,7 @@ import (
 	"io"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -82,12 +82,12 @@ func TestBMMLightModePreparesCoins(t *testing.T) {
 	}}
 	h.wallet = wallet
 
-	resp, err := h.PrepareBMM(context.Background(), connect.NewRequest(&bmmpb.PrepareBMMRequest{
+	resp, err := h.PrepareBMM(context.Background(), &bmmpb.PrepareBMMRequest{
 		Targets: []*bmmpb.PrepareBMMTarget{{WalletId: "bidder", MaxBidSats: 30_000}},
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, resp.Msg.Wallets, 1)
-	assert.EqualValues(t, 1, resp.Msg.Wallets[0].UsableCoins)
+	require.Len(t, resp.Wallets, 1)
+	assert.EqualValues(t, 1, resp.Wallets[0].UsableCoins)
 	assert.Empty(t, wallet.sends, "one coin funds one sidechain")
 }
 
@@ -107,15 +107,15 @@ func TestBMMLightModeSplitsPastAnUnconfirmedCoin(t *testing.T) {
 	}
 	h.wallet = wallet
 
-	resp, err := h.PrepareBMM(context.Background(), connect.NewRequest(&bmmpb.PrepareBMMRequest{
+	resp, err := h.PrepareBMM(context.Background(), &bmmpb.PrepareBMMRequest{
 		Targets: []*bmmpb.PrepareBMMTarget{
 			{WalletId: "bidder", MaxBidSats: 30_000},
 			{WalletId: "bidder", MaxBidSats: 30_000},
 		},
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, resp.Msg.Wallets, 1)
-	assert.EqualValues(t, 1, resp.Msg.Wallets[0].UsableCoins, "the unconfirmed coin counts for nothing")
+	require.Len(t, resp.Wallets, 1)
+	assert.EqualValues(t, 1, resp.Wallets[0].UsableCoins, "the unconfirmed coin counts for nothing")
 	require.Len(t, wallet.sends, 1, "the wallet splits the confirmed coin")
 	assert.Equal(t, confirmed, wallet.sends[0].RequiredInputs[0].Txid)
 }
@@ -135,7 +135,7 @@ func TestBMMListBidsReadsNoCore(t *testing.T) {
 			// No enforcer answers this handler, so the call fails on that
 			// rather than on the node mode.
 			_, err := h.ListBids(context.Background(),
-				connect.NewRequest(&bmmpb.ListBidsRequest{Sidechain: pb.BinaryType_BINARY_TYPE_THUNDER}))
+				&bmmpb.ListBidsRequest{Sidechain: pb.BinaryType_BINARY_TYPE_THUNDER})
 			require.Error(t, err)
 			assert.NotEqual(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 		})
@@ -149,15 +149,15 @@ func TestBMMLightModeKeepsStopAndPaidHistory(t *testing.T) {
 	round := bmmstate.Round{Sidechain: int32(sidechain), PrevMainHash: "paid", Result: engines.ResultWon, WinnerBidSats: 1000}
 	require.NoError(t, store.Save(round))
 	require.NoError(t, orchestrator.WriteNodeMode(h.orch.BitwindowDir, orchestrator.NodeModeLight))
-	_, err := h.Stop(context.Background(), connect.NewRequest(&bmmpb.StopRequest{Sidechain: sidechain}))
+	_, err := h.Stop(context.Background(), &bmmpb.StopRequest{Sidechain: sidechain})
 	require.NoError(t, err)
 	targets, err := store.Targets()
 	require.NoError(t, err)
 	require.Empty(t, targets)
-	response, err := h.GetRoundBids(context.Background(), connect.NewRequest(&bmmpb.GetRoundBidsRequest{Sidechain: sidechain, PrevMainHash: "paid"}))
+	response, err := h.GetRoundBids(context.Background(), &bmmpb.GetRoundBidsRequest{Sidechain: sidechain, PrevMainHash: "paid"})
 	require.NoError(t, err)
-	require.Equal(t, engines.ResultWon, response.Msg.Round.Result)
-	require.EqualValues(t, 1000, response.Msg.Round.WinnerBidSats)
+	require.Equal(t, engines.ResultWon, response.Round.Result)
+	require.EqualValues(t, 1000, response.Round.WinnerBidSats)
 	state, err := h.state(context.Background(), sidechain)
 	require.NoError(t, err)
 	require.False(t, state.Running)
diff --git a/sidechain-orchestrator/api/bmm_slot_coin_test.go b/sidechain-orchestrator/api/bmm_slot_coin_test.go
index da8e89f683..2d99fde7c9 100644
--- a/sidechain-orchestrator/api/bmm_slot_coin_test.go
+++ b/sidechain-orchestrator/api/bmm_slot_coin_test.go
@@ -10,7 +10,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -143,25 +143,25 @@ func (w *fakeBidWallet) TxStatus(_ context.Context, txid string) (wallet.Esplora
 }
 
 func (w *fakeBidWallet) GetTransactionDetails(
-	_ context.Context, req *connect.Request[wpb.GetTransactionDetailsRequest],
-) (*connect.Response[wpb.GetTransactionDetailsResponse], error) {
-	details, ok := w.details[req.Msg.Txid]
+	_ context.Context, req *wpb.GetTransactionDetailsRequest,
+) (*wpb.GetTransactionDetailsResponse, error) {
+	details, ok := w.details[req.Txid]
 	if !ok {
-		return nil, fmt.Errorf("the wallet knows no transaction %s", req.Msg.Txid)
+		return nil, fmt.Errorf("the wallet knows no transaction %s", req.Txid)
 	}
-	return connect.NewResponse(details), nil
+	return details, nil
 }
 
 func (w *fakeBidWallet) ListTransactions(
-	_ context.Context, req *connect.Request[wpb.ListTransactionsRequest],
-) (*connect.Response[wpb.ListTransactionsResponse], error) {
-	w.listed = append(w.listed, req.Msg)
-	if err, ok := w.listErr[req.Msg.WalletId]; ok {
+	_ context.Context, req *wpb.ListTransactionsRequest,
+) (*wpb.ListTransactionsResponse, error) {
+	w.listed = append(w.listed, req)
+	if err, ok := w.listErr[req.WalletId]; ok {
 		return nil, err
 	}
 	// The handler defaults an unset count to 100, and the electrum backend cuts
 	// the list at it after sorting an unconfirmed row last.
-	count := int(req.Msg.Count)
+	count := int(req.Count)
 	if count <= 0 {
 		count = 100
 	}
@@ -169,7 +169,7 @@ func (w *fakeBidWallet) ListTransactions(
 	if count < len(txs) {
 		txs = txs[:count]
 	}
-	return connect.NewResponse(&wpb.ListTransactionsResponse{Transactions: txs}), nil
+	return &wpb.ListTransactionsResponse{Transactions: txs}, nil
 }
 
 // heldCoins names the coins a test froze, keyed txid:vout.
@@ -183,29 +183,29 @@ func (w *fakeBidWallet) ResolveWalletID(walletID string) (string, error) {
 }
 
 func (w *fakeBidWallet) ListUnspent(
-	_ context.Context, req *connect.Request[wpb.ListUnspentRequest],
-) (*connect.Response[wpb.ListUnspentResponse], error) {
+	_ context.Context, req *wpb.ListUnspentRequest,
+) (*wpb.ListUnspentResponse, error) {
 	utxos := w.utxos
 	if w.byWallet != nil {
-		utxos = w.byWallet[req.Msg.WalletId]
+		utxos = w.byWallet[req.WalletId]
 	}
-	return connect.NewResponse(&wpb.ListUnspentResponse{Utxos: utxos}), nil
+	return &wpb.ListUnspentResponse{Utxos: utxos}, nil
 }
 
 func (w *fakeBidWallet) GetNewAddress(
-	_ context.Context, _ *connect.Request[wpb.GetNewAddressRequest],
-) (*connect.Response[wpb.GetNewAddressResponse], error) {
+	_ context.Context, _ *wpb.GetNewAddressRequest,
+) (*wpb.GetNewAddressResponse, error) {
 	w.addresses++
-	return connect.NewResponse(&wpb.GetNewAddressResponse{
+	return &wpb.GetNewAddressResponse{
 		Address: fmt.Sprintf("address-%d", w.addresses),
-	}), nil
+	}, nil
 }
 
 func (w *fakeBidWallet) SendTransaction(
-	_ context.Context, req *connect.Request[wpb.SendTransactionRequest],
-) (*connect.Response[wpb.SendTransactionResponse], error) {
-	w.sends = append(w.sends, req.Msg)
-	return connect.NewResponse(&wpb.SendTransactionResponse{Txid: w.sendTxid}), nil
+	_ context.Context, req *wpb.SendTransactionRequest,
+) (*wpb.SendTransactionResponse, error) {
+	w.sends = append(w.sends, req)
+	return &wpb.SendTransactionResponse{Txid: w.sendTxid}, nil
 }
 
 func slotCoinHandler(t *testing.T, mempool *fakeSlotMempool, wallet *fakeBidWallet) *BMMHandler {
@@ -310,19 +310,19 @@ func TestSlotCoinGivesTwoSlotsTwoCoins(t *testing.T) {
 	assert.Empty(t, wallet.sends, "two free coins need no split")
 }
 
-func prepareRequest(sidechains int) *connect.Request[bmmpb.PrepareBMMRequest] {
+func prepareRequest(sidechains int) *bmmpb.PrepareBMMRequest {
 	targets := make([]*bmmpb.PrepareBMMTarget, 0, sidechains)
 	for range sidechains {
 		targets = append(targets, &bmmpb.PrepareBMMTarget{WalletId: "bidder", MaxBidSats: 30_000})
 	}
-	return connect.NewRequest(&bmmpb.PrepareBMMRequest{Targets: targets})
+	return &bmmpb.PrepareBMMRequest{Targets: targets}
 }
 
 // prepared reads the one wallet the tests below prepare.
-func prepared(t *testing.T, resp *connect.Response[bmmpb.PrepareBMMResponse]) *bmmpb.PrepareBMMWallet {
+func prepared(t *testing.T, resp *bmmpb.PrepareBMMResponse) *bmmpb.PrepareBMMWallet {
 	t.Helper()
-	require.Len(t, resp.Msg.Wallets, 1)
-	return resp.Msg.Wallets[0]
+	require.Len(t, resp.Wallets, 1)
+	return resp.Wallets[0]
 }
 
 // workingSats is the balance one sidechain bids many rounds from.
@@ -528,12 +528,12 @@ func TestPrepareBMMJoinsTheAliasesOfOneWallet(t *testing.T) {
 	}
 	h := slotCoinHandler(t, &fakeSlotMempool{}, wallet)
 
-	resp, err := h.PrepareBMM(context.Background(), connect.NewRequest(&bmmpb.PrepareBMMRequest{
+	resp, err := h.PrepareBMM(context.Background(), &bmmpb.PrepareBMMRequest{
 		Targets: []*bmmpb.PrepareBMMTarget{
 			{WalletId: "", MaxBidSats: 30_000},
 			{WalletId: "active", MaxBidSats: 45_000},
 		},
-	}))
+	})
 	require.NoError(t, err)
 
 	only := prepared(t, resp)
@@ -580,13 +580,13 @@ func TestPrepareBMMPreparesEveryWalletAfterAFailure(t *testing.T) {
 	}
 	h := slotCoinHandler(t, &fakeSlotMempool{}, wallet)
 
-	_, err := h.PrepareBMM(context.Background(), connect.NewRequest(&bmmpb.PrepareBMMRequest{
+	_, err := h.PrepareBMM(context.Background(), &bmmpb.PrepareBMMRequest{
 		Targets: []*bmmpb.PrepareBMMTarget{
 			{WalletId: "poor", MaxBidSats: 30_000},
 			{WalletId: "rich", MaxBidSats: 30_000},
 			{WalletId: "rich", MaxBidSats: 30_000},
 		},
-	}))
+	})
 
 	require.Error(t, err, "the poor wallet cannot pay for its coin")
 	require.Len(t, wallet.sends, 1, "the rich wallet still gets its coins")
diff --git a/sidechain-orchestrator/api/bmm_sync_gate_test.go b/sidechain-orchestrator/api/bmm_sync_gate_test.go
index 012f4a3f1e..d1f6cbaa6d 100644
--- a/sidechain-orchestrator/api/bmm_sync_gate_test.go
+++ b/sidechain-orchestrator/api/bmm_sync_gate_test.go
@@ -3,7 +3,7 @@ package api
 import (
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
diff --git a/sidechain-orchestrator/api/connect_compat_test.go b/sidechain-orchestrator/api/connect_compat_test.go
new file mode 100644
index 0000000000..8d34e54349
--- /dev/null
+++ b/sidechain-orchestrator/api/connect_compat_test.go
@@ -0,0 +1,64 @@
+package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
+	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
+	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
+	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
+	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+)
+
+func TestV1ClientReadsNetworkPlanError(t *testing.T) {
+	home := config.HomeDir()
+	if home == config.UserHomeDir() {
+		home = ""
+	}
+	config.SetHomeDir(t.TempDir())
+	t.Cleanup(func() { config.SetHomeDir(home) })
+	orch := orchestrator.New(t.TempDir(), "signet", t.TempDir(), nil, zerolog.Nop())
+	orch.BitcoinConf.Config.SetGroupDatadir(config.DatadirGroupECash, "")
+	server := connect.NewServer()
+	rpc.RegisterBitcoinConfServiceHandler(server, NewBitcoinConfHandler(orch))
+	mux := http.NewServeMux()
+	connecthttp.Mount(mux, server, connecthttp.WithReadMaxBytes(0))
+	httpServer := httptest.NewUnstartedServer(mux)
+	httpServer.EnableHTTP2 = true
+	httpServer.StartTLS()
+	t.Cleanup(httpServer.Close)
+
+	for _, protocol := range []struct {
+		name    string
+		options []connectv1.ClientOption
+	}{
+		{name: "Connect"},
+		{name: "gRPC", options: []connectv1.ClientOption{connectv1.WithGRPC()}},
+		{name: "gRPC-Web", options: []connectv1.ClientOption{connectv1.WithGRPCWeb()}},
+	} {
+		t.Run(protocol.name, func(t *testing.T) {
+			client := connectv1.NewClient[pb.SetBitcoinConfigNetworkRequest, pb.SetBitcoinConfigNetworkResponse](
+				httpServer.Client(), httpServer.URL+rpc.BitcoinConfServiceSetBitcoinConfigNetworkProcedure, protocol.options...,
+			)
+			_, err := client.CallUnary(t.Context(), connectv1.NewRequest(&pb.SetBitcoinConfigNetworkRequest{Network: "ecash"}))
+			var rpcErr *connectv1.Error
+			require.ErrorAs(t, err, &rpcErr)
+			require.Equal(t, connectv1.CodeFailedPrecondition, rpcErr.Code())
+			require.Equal(t, "datadir not configured for ecash", rpcErr.Message())
+			require.Len(t, rpcErr.Details(), 1)
+			detail, err := rpcErr.Details()[0].Value()
+			require.NoError(t, err)
+			plan, ok := detail.(*pb.NetworkChangePlan)
+			require.True(t, ok)
+			require.Equal(t, "ecash", plan.Network)
+			require.True(t, plan.MustSelectDatadir)
+			require.Equal(t, string(config.DatadirGroupECash), plan.DatadirGroup)
+		})
+	}
+}
diff --git a/sidechain-orchestrator/api/datadir_network_handler.go b/sidechain-orchestrator/api/datadir_network_handler.go
index 11b7f9226d..277666e54b 100644
--- a/sidechain-orchestrator/api/datadir_network_handler.go
+++ b/sidechain-orchestrator/api/datadir_network_handler.go
@@ -3,16 +3,16 @@ package api
 import (
 	"context"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 )
 
-func (h *Handler) GetDatadirNetwork(ctx context.Context, _ *connect.Request[pb.GetDatadirNetworkRequest]) (*connect.Response[pb.GetDatadirNetworkResponse], error) {
+func (h *Handler) GetDatadirNetwork(ctx context.Context, _ *pb.GetDatadirNetworkRequest) (*pb.GetDatadirNetworkResponse, error) {
 	out, err := h.orch.ReadDatadirNetwork(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.GetDatadirNetworkResponse{
+	return &pb.GetDatadirNetworkResponse{
 		Magic:             out.Magic,
 		DetectedId:        out.DetectedID,
 		DetectedName:      out.DetectedName,
@@ -28,5 +28,5 @@ func (h *Handler) GetDatadirNetwork(ctx context.Context, _ *connect.Request[pb.G
 		ConvertFromName:   out.ConvertFromName,
 		ConvertToId:       out.ConvertToID,
 		ConvertToName:     out.ConvertToName,
-	}), nil
+	}, nil
 }
diff --git a/sidechain-orchestrator/api/deposit.go b/sidechain-orchestrator/api/deposit.go
index 7abf8795a6..d68bb16e9e 100644
--- a/sidechain-orchestrator/api/deposit.go
+++ b/sidechain-orchestrator/api/deposit.go
@@ -8,13 +8,14 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
-	"github.com/samber/lo"
 	"strconv"
 	"strings"
 	"sync"
 
-	"connectrpc.com/connect"
+	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
+	"github.com/samber/lo"
+
+	"connectrpc.com/connect/v2"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
@@ -25,33 +26,33 @@ import (
 // CreateDeposit builds a BIP300 M5: it spends the sidechain's current treasury
 // output and pays a larger one back, naming the depositor in an OP_RETURN.
 func (h *WalletHandler) CreateDeposit(
-	ctx context.Context, req *connect.Request[wpb.CreateDepositRequest],
-) (*connect.Response[wpb.CreateDepositResponse], error) {
-	if req.Msg.AmountSats <= 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("amount_sats must be positive"))
+	ctx context.Context, req *wpb.CreateDepositRequest,
+) (*wpb.CreateDepositResponse, error) {
+	if req.AmountSats <= 0 {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "amount_sats must be positive")
 	}
-	if req.Msg.FeeSats <= 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("fee_sats must be positive"))
+	if req.FeeSats <= 0 {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "fee_sats must be positive")
 	}
-	if req.Msg.Destination == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("destination must be set"))
+	if req.Destination == "" {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "destination must be set")
 	}
-	if req.Msg.Slot < 0 || req.Msg.Slot > 255 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("slot must be 0-255"))
+	if req.Slot < 0 || req.Slot > 255 {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "slot must be 0-255")
 	}
-	slot := uint8(req.Msg.Slot)
+	slot := uint8(req.Slot)
 
-	destination, err := depositDestination(slot, req.Msg.Destination)
+	destination, err := depositDestination(slot, req.Destination)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// Held past the broadcast and the record below: two overlapping calls would
@@ -65,10 +66,10 @@ func (h *WalletHandler) CreateDeposit(
 	}
 	walletHeight, err := h.engine.ChainForWallet(walletID).TipHeight(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the mainchain tip: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the mainchain tip: %w", err).Error())
 	}
 	if err := depositTreasuryReady(treasury, walletHeight, slot); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 	treasuryHex := hex.EncodeToString(orchestrator.M8TreasuryScript(slot))
 	var externalInputs []*wpb.ExternalInput
@@ -77,17 +78,17 @@ func (h *WalletHandler) CreateDeposit(
 	start, startErr := h.depositStart(ctx, treasury, walletID, slot)
 	switch {
 	case errors.Is(startErr, errTreasuryAmbiguous):
-		return nil, connect.NewError(connect.CodeResourceExhausted, startErr)
+		return nil, connect.NewError(connect.CodeResourceExhausted, startErr.Error()).WithCause(startErr)
 	case startErr != nil:
-		return nil, connect.NewError(connect.CodeUnavailable, startErr)
+		return nil, connect.NewError(connect.CodeUnavailable, startErr.Error()).WithCause(startErr)
 	}
 	if start != nil {
 		tip, tipErr := treasuryTip(ctx, h.engine.ChainForWallet(walletID), slot, *start, h.recordedTipOf(slot))
 		switch {
 		case errors.Is(tipErr, errTreasuryChainFull), errors.Is(tipErr, errTreasurySpentElsewhere):
-			return nil, connect.NewError(connect.CodeResourceExhausted, tipErr)
+			return nil, connect.NewError(connect.CodeResourceExhausted, tipErr.Error()).WithCause(tipErr)
 		case tipErr != nil:
-			return nil, connect.NewError(connect.CodeUnavailable, tipErr)
+			return nil, connect.NewError(connect.CodeUnavailable, tipErr.Error()).WithCause(tipErr)
 		}
 		if tip.ancestors > 0 {
 			h.svc.Log().Info().Uint8("slot", slot).Int("ancestors", tip.ancestors).
@@ -102,50 +103,50 @@ func (h *WalletHandler) CreateDeposit(
 		}}
 	}
 
-	treasurySats := oldTreasurySats + req.Msg.AmountSats
+	treasurySats := oldTreasurySats + req.AmountSats
 
 	h.svc.Log().Info().Uint8("slot", slot).Str("destination", destination).
-		Int64("amount_sats", req.Msg.AmountSats).Int64("fee_sats", req.Msg.FeeSats).
+		Int64("amount_sats", req.AmountSats).Int64("fee_sats", req.FeeSats).
 		Int64("old_treasury_sats", oldTreasurySats).Int64("new_treasury_sats", treasurySats).
 		Int("external_inputs", len(externalInputs)).Msg("building the deposit")
 
-	send, err := h.SendTransaction(ctx, connect.NewRequest(&wpb.SendTransactionRequest{
-		WalletId:       req.Msg.WalletId,
+	send, err := h.SendTransaction(ctx, &wpb.SendTransactionRequest{
+		WalletId:       req.WalletId,
 		RawOutputs:     []*wpb.RawOutput{{ValueSats: treasurySats, ScriptHex: treasuryHex}},
 		OpReturnHex:    hex.EncodeToString([]byte(destination)),
 		ExternalInputs: externalInputs,
-		FixedFeeSats:   req.Msg.FeeSats,
-	}))
+		FixedFeeSats:   req.FeeSats,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	h.svc.Log().Info().Str("txid", send.Msg.Txid).Uint8("slot", slot).
-		Int64("amount_sats", req.Msg.AmountSats).Msg("broadcast the deposit")
+	h.svc.Log().Info().Str("txid", send.Txid).Uint8("slot", slot).
+		Int64("amount_sats", req.AmountSats).Msg("broadcast the deposit")
 
 	// An M5 is an ordinary transaction on the wire, so nothing later can tell
 	// it apart from a normal send. Record it while we still know.
 	if err := h.recordDeposit(ctx, wallet.SidechainDeposit{
-		Txid:        send.Msg.Txid,
+		Txid:        send.Txid,
 		WalletID:    walletID,
 		Slot:        uint32(slot),
 		Destination: destination,
-		AmountSats:  req.Msg.AmountSats,
-		FeeSats:     req.Msg.FeeSats,
+		AmountSats:  req.AmountSats,
+		FeeSats:     req.FeeSats,
 	}); err != nil {
 		// The broadcast already happened, so failing the call would report a
 		// deposit that did not land. This row is the only record of it, and
 		// the next deposit to the slot builds on it, so the slot is now in an
 		// unknown state until a block settles it.
 		h.depositSlotBlind.Store(h.blindKey(slot), treasury.ctip.GetTxid().GetHex().GetValue())
-		h.svc.Log().Error().Err(err).Str("txid", send.Msg.Txid).Uint8("slot", slot).
+		h.svc.Log().Error().Err(err).Str("txid", send.Txid).Uint8("slot", slot).
 			Msg("could not record the deposit, holding the slot until a block lands")
 	}
 
-	return connect.NewResponse(&wpb.CreateDepositResponse{
-		Txid:         send.Msg.Txid,
+	return &wpb.CreateDepositResponse{
+		Txid:         send.Txid,
 		TreasurySats: treasurySats,
-	}), nil
+	}, nil
 }
 
 // depositDestination unwraps the s<slot>_<address>_<checksum> deposit form to
@@ -215,31 +216,31 @@ func (h *WalletHandler) lockDepositSlot(slot uint8) func() {
 // whether the slot holds an active sidechain.
 func (h *WalletHandler) enforcerTreasury(ctx context.Context, slot uint32) (sidechainTreasury, error) {
 	if h.orch == nil {
-		return sidechainTreasury{}, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not wired"))
+		return sidechainTreasury{}, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not wired")
 	}
 
 	validator, err := h.orch.EnforcerValidator()
 	if err != nil {
-		return sidechainTreasury{}, connect.NewError(connect.CodeFailedPrecondition, err)
+		return sidechainTreasury{}, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 	_, height, err := h.orch.ChainTip(ctx)
 	if err != nil {
-		return sidechainTreasury{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the enforcer tip: %w", err))
+		return sidechainTreasury{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read the enforcer tip: %w", err).Error())
 	}
-	ctip, err := validator.GetCtip(ctx, connect.NewRequest(&enforcerpb.GetCtipRequest{
+	ctip, err := validator.GetCtip(ctx, &enforcerpb.GetCtipRequest{
 		SidechainNumber: wrapperspb.UInt32(slot),
-	}))
+	})
 	if err != nil {
-		return sidechainTreasury{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get ctip: %w", err))
+		return sidechainTreasury{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get ctip: %w", err).Error())
 	}
-	sidechains, err := validator.GetSidechains(ctx, connect.NewRequest(&enforcerpb.GetSidechainsRequest{}))
+	sidechains, err := validator.GetSidechains(ctx, &enforcerpb.GetSidechainsRequest{})
 	if err != nil {
-		return sidechainTreasury{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get sidechains: %w", err))
+		return sidechainTreasury{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("get sidechains: %w", err).Error())
 	}
 	return sidechainTreasury{
 		enforcerHeight: int(height),
-		ctip:           ctip.Msg.GetCtip(),
-		slotActive: lo.ContainsBy(sidechains.Msg.GetSidechains(), func(s *enforcerpb.GetSidechainsResponse_SidechainInfo) bool {
+		ctip:           ctip.GetCtip(),
+		slotActive: lo.ContainsBy(sidechains.GetSidechains(), func(s *enforcerpb.GetSidechainsResponse_SidechainInfo) bool {
 			return s.GetSidechainNumber().GetValue() == slot
 		}),
 	}, nil
@@ -249,13 +250,13 @@ func (h *WalletHandler) enforcerTreasury(ctx context.Context, slot uint32) (side
 // enforcer used to keep a global list in its own wallet; it runs none, so only
 // our own deposits are knowable.
 func (h *WalletHandler) ListSidechainDeposits(
-	ctx context.Context, req *connect.Request[wpb.ListSidechainDepositsRequest],
-) (*connect.Response[wpb.ListSidechainDepositsResponse], error) {
-	deposits, err := h.svc.SidechainDeposits(ctx, req.Msg.Slot, req.Msg.WalletId)
+	ctx context.Context, req *wpb.ListSidechainDepositsRequest,
+) (*wpb.ListSidechainDepositsResponse, error) {
+	deposits, err := h.svc.SidechainDeposits(ctx, req.Slot, req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&wpb.ListSidechainDepositsResponse{
+	return &wpb.ListSidechainDepositsResponse{
 		Deposits: lo.Map(deposits, func(d wallet.SidechainDeposit, _ int) *wpb.SidechainDeposit {
 			return &wpb.SidechainDeposit{
 				Txid:          d.Txid,
@@ -269,7 +270,7 @@ func (h *WalletHandler) ListSidechainDeposits(
 				DroppedAt:     isoOrEmpty(d.DroppedAt),
 			}
 		}),
-	}), nil
+	}, nil
 }
 
 func isoOrEmpty(t time.Time) string {
@@ -301,14 +302,14 @@ func (h *WalletHandler) depositConfirmations(ctx context.Context, d wallet.Sidec
 // GetSidechainDepositTotals sums what this install deposited. The wallet
 // overview shows it, and only our own record knows it.
 func (h *WalletHandler) GetSidechainDepositTotals(
-	ctx context.Context, req *connect.Request[wpb.GetSidechainDepositTotalsRequest],
-) (*connect.Response[wpb.GetSidechainDepositTotalsResponse], error) {
-	total, recent, err := h.svc.SidechainDepositTotals(ctx, time.Unix(req.Msg.SinceUnix, 0), req.Msg.WalletId)
+	ctx context.Context, req *wpb.GetSidechainDepositTotalsRequest,
+) (*wpb.GetSidechainDepositTotalsResponse, error) {
+	total, recent, err := h.svc.SidechainDepositTotals(ctx, time.Unix(req.SinceUnix, 0), req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&wpb.GetSidechainDepositTotalsResponse{
+	return &wpb.GetSidechainDepositTotalsResponse{
 		TotalSats:  total,
 		RecentSats: recent,
-	}), nil
+	}, nil
 }
diff --git a/sidechain-orchestrator/api/deposit_pending_balance_test.go b/sidechain-orchestrator/api/deposit_pending_balance_test.go
index 2d6bfb9be8..bc2d1a0785 100644
--- a/sidechain-orchestrator/api/deposit_pending_balance_test.go
+++ b/sidechain-orchestrator/api/deposit_pending_balance_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -102,11 +101,9 @@ func newDepositTestHandler(t *testing.T, state *depositNodeState) (*Handler, *wa
 
 func thunderBalance(t *testing.T, handler *Handler) (confirmed, pending uint64) {
 	t.Helper()
-	response, err := handler.GetSidechainBalance(context.Background(), connect.NewRequest(
-		&pb.GetSidechainBalanceRequest{Sidechain: pb.BinaryType_BINARY_TYPE_THUNDER},
-	))
+	response, err := handler.GetSidechainBalance(context.Background(), &pb.GetSidechainBalanceRequest{Sidechain: pb.BinaryType_BINARY_TYPE_THUNDER})
 	require.NoError(t, err)
-	return response.Msg.ConfirmedSats, response.Msg.PendingSats
+	return response.ConfirmedSats, response.PendingSats
 }
 
 // depositCoins writes the coin listing a sidechain answers for these deposit
diff --git a/sidechain-orchestrator/api/deposit_test.go b/sidechain-orchestrator/api/deposit_test.go
index 3c000f15ae..13118139fb 100644
--- a/sidechain-orchestrator/api/deposit_test.go
+++ b/sidechain-orchestrator/api/deposit_test.go
@@ -1,12 +1,13 @@
 package api
 
 import (
+	"connectrpc.com/connect/v2/connecthttp"
 	"context"
 	"io"
 	"net/http"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
@@ -65,8 +66,9 @@ func TestCreateDepositRefusesAStaleTreasury(t *testing.T) {
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			mux := http.NewServeMux()
-			path, handler := enforcerrpc.NewValidatorServiceHandler(tc.validator)
-			mux.Handle(path, handler)
+			rpcServer := connect.NewServer()
+			enforcerrpc.RegisterValidatorServiceHandler(rpcServer, tc.validator)
+			connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 			server := h2cServer(mux)
 			t.Cleanup(server.Close)
 			host, port := hostPort(t, server)
@@ -90,13 +92,13 @@ func TestCreateDepositRefusesAStaleTreasury(t *testing.T) {
 			h.SetEngine(wallet.NewWalletEngine(svc, wallet.NewBackendRouter(svc, nil, eb), wallet.StaticParams(net), log))
 			h.SetOrchestrator(orch)
 
-			_, err = h.CreateDeposit(context.Background(), connect.NewRequest(&wpb.CreateDepositRequest{
+			_, err = h.CreateDeposit(context.Background(), &wpb.CreateDepositRequest{
 				WalletId:    w.ID,
 				Slot:        9,
 				Destination: "sidechainaddress",
 				AmountSats:  100_000,
 				FeeSats:     1_000,
-			}))
+			})
 			if tc.code == 0 {
 				require.NoError(t, err)
 				require.Len(t, chain.broadcast, 1)
diff --git a/sidechain-orchestrator/api/download_binary_stream_test.go b/sidechain-orchestrator/api/download_binary_stream_test.go
index 5b89fdb7b0..c49db1fdc3 100644
--- a/sidechain-orchestrator/api/download_binary_stream_test.go
+++ b/sidechain-orchestrator/api/download_binary_stream_test.go
@@ -12,7 +12,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
 
@@ -67,21 +68,22 @@ func TestDownloadBinary_DispatchesAndCompletes(t *testing.T) {
 	})
 
 	mux := http.NewServeMux()
-	path, h := rpc.NewOrchestratorServiceHandler(NewHandler(orch))
-	mux.Handle(path, h)
+	rpcServer := connect.NewServer()
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, NewHandler(orch))
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 	connectSrv := h2cServer(mux)
 	defer connectSrv.Close()
 
-	client := rpc.NewOrchestratorServiceClient(h2cClient(), connectSrv.URL, connect.WithGRPC())
+	client := rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(h2cClient(), connectSrv.URL, connecthttp.WithReadMaxBytes(0), connecthttp.WithGRPC())))
 
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
 	// Unary call returns immediately — boot goroutine runs server-side.
-	resp, err := client.DownloadBinary(ctx, connect.NewRequest(&pb.DownloadBinaryRequest{
+	resp, err := client.DownloadBinary(ctx, &pb.DownloadBinaryRequest{
 		Name:  "streamtest",
 		Force: true,
-	}))
+	})
 	require.NoError(t, err)
 	require.NotNil(t, resp)
 
@@ -111,15 +113,16 @@ func TestDownloadBinary_RejectsUnknownBinary(t *testing.T) {
 		Files:          map[string]string{currentPlatform(): "streamtest.zip"},
 	})
 	mux := http.NewServeMux()
-	path, h := rpc.NewOrchestratorServiceHandler(NewHandler(orch))
-	mux.Handle(path, h)
+	rpcServer := connect.NewServer()
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, NewHandler(orch))
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 	srv := h2cServer(mux)
 	defer srv.Close()
 
-	client := rpc.NewOrchestratorServiceClient(h2cClient(), srv.URL, connect.WithGRPC())
-	_, err := client.DownloadBinary(context.Background(), connect.NewRequest(&pb.DownloadBinaryRequest{
+	client := rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(h2cClient(), srv.URL, connecthttp.WithReadMaxBytes(0), connecthttp.WithGRPC())))
+	_, err := client.DownloadBinary(context.Background(), &pb.DownloadBinaryRequest{
 		Name: "no-such-binary",
-	}))
+	})
 	require.Error(t, err, "unknown binary must surface as an RPC error")
 }
 
diff --git a/sidechain-orchestrator/api/ecash_migration_config_test.go b/sidechain-orchestrator/api/ecash_migration_config_test.go
index 32e2f47456..e721faea18 100644
--- a/sidechain-orchestrator/api/ecash_migration_config_test.go
+++ b/sidechain-orchestrator/api/ecash_migration_config_test.go
@@ -11,7 +11,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
@@ -77,14 +76,14 @@ func TestECashMigrationBlocksConfigEdits(t *testing.T) {
 					return o.SetDatadirForCurrentNetwork(t.TempDir())
 				}
 				if name == "config content" {
-					_, err := handler.WriteBitcoinConfig(t.Context(), connect.NewRequest(&pb.WriteBitcoinConfigRequest{ConfigContent: string(before) + "\nmaxconnections=17\n"}))
+					_, err := handler.WriteBitcoinConfig(t.Context(), &pb.WriteBitcoinConfigRequest{ConfigContent: string(before) + "\nmaxconnections=17\n"})
 					return err
 				}
 				if name == "network selection" {
-					_, err := handler.SetBitcoinConfigNetwork(t.Context(), connect.NewRequest(&pb.SetBitcoinConfigNetworkRequest{DataDir: t.TempDir(), Network: "ecash"}))
+					_, err := handler.SetBitcoinConfigNetwork(t.Context(), &pb.SetBitcoinConfigNetworkRequest{DataDir: t.TempDir(), Network: "ecash"})
 					return err
 				}
-				_, err := handler.SetBitcoinConfigDataDir(t.Context(), connect.NewRequest(&pb.SetBitcoinConfigDataDirRequest{DataDir: t.TempDir(), Network: "ecash"}))
+				_, err := handler.SetBitcoinConfigDataDir(t.Context(), &pb.SetBitcoinConfigDataDirRequest{DataDir: t.TempDir(), Network: "ecash"})
 				return err
 			}
 			err = edit()
diff --git a/sidechain-orchestrator/api/ecash_migration_handler.go b/sidechain-orchestrator/api/ecash_migration_handler.go
index 82b944e62d..72013a4c05 100644
--- a/sidechain-orchestrator/api/ecash_migration_handler.go
+++ b/sidechain-orchestrator/api/ecash_migration_handler.go
@@ -2,51 +2,50 @@ package api
 
 import (
 	"context"
-	"errors"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 )
 
-func (h *Handler) PreviewECashMigration(ctx context.Context, req *connect.Request[pb.PreviewECashMigrationRequest]) (*connect.Response[pb.PreviewECashMigrationResponse], error) {
-	fromID, toID, err := ecashMigrationNetworks(req.Msg.FromId, req.Msg.ToId)
+func (h *Handler) PreviewECashMigration(ctx context.Context, req *pb.PreviewECashMigrationRequest) (*pb.PreviewECashMigrationResponse, error) {
+	fromID, toID, err := ecashMigrationNetworks(req.FromId, req.ToId)
 	if err != nil {
 		return nil, err
 	}
 	status, err := h.orch.PreviewECashMigration(ctx, fromID, toID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.PreviewECashMigrationResponse{Status: ecashMigrationStatusToProto(status)}), nil
+	return &pb.PreviewECashMigrationResponse{Status: ecashMigrationStatusToProto(status)}, nil
 }
 
-func (h *Handler) StartECashMigration(ctx context.Context, req *connect.Request[pb.StartECashMigrationRequest]) (*connect.Response[pb.StartECashMigrationResponse], error) {
-	fromID, toID, err := ecashMigrationNetworks(req.Msg.FromId, req.Msg.ToId)
+func (h *Handler) StartECashMigration(ctx context.Context, req *pb.StartECashMigrationRequest) (*pb.StartECashMigrationResponse, error) {
+	fromID, toID, err := ecashMigrationNetworks(req.FromId, req.ToId)
 	if err != nil {
 		return nil, err
 	}
 	status, err := h.orch.StartECashMigration(ctx, fromID, toID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.StartECashMigrationResponse{Status: ecashMigrationStatusToProto(status)}), nil
+	return &pb.StartECashMigrationResponse{Status: ecashMigrationStatusToProto(status)}, nil
 }
 
-func (h *Handler) GetECashMigrationStatus(_ context.Context, _ *connect.Request[pb.GetECashMigrationStatusRequest]) (*connect.Response[pb.GetECashMigrationStatusResponse], error) {
+func (h *Handler) GetECashMigrationStatus(_ context.Context, _ *pb.GetECashMigrationStatusRequest) (*pb.GetECashMigrationStatusResponse, error) {
 	status, err := h.orch.ECashMigrationStatus()
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.GetECashMigrationStatusResponse{Status: ecashMigrationStatusToProto(status)}), nil
+	return &pb.GetECashMigrationStatusResponse{Status: ecashMigrationStatusToProto(status)}, nil
 }
 
 func ecashMigrationNetworks(fromID, toID string) (string, string, error) {
 	fromID = strings.TrimSpace(fromID)
 	toID = strings.TrimSpace(toID)
 	if fromID == "" || toID == "" || fromID == toID {
-		return "", "", connect.NewError(connect.CodeInvalidArgument, errors.New("select different source and target network IDs"))
+		return "", "", connect.NewError(connect.CodeInvalidArgument, "select different source and target network IDs")
 	}
 	return fromID, toID, nil
 }
diff --git a/sidechain-orchestrator/api/ecash_migration_handler_test.go b/sidechain-orchestrator/api/ecash_migration_handler_test.go
index 788fde8648..2ed6095743 100644
--- a/sidechain-orchestrator/api/ecash_migration_handler_test.go
+++ b/sidechain-orchestrator/api/ecash_migration_handler_test.go
@@ -4,12 +4,14 @@ import (
 	"context"
 	"encoding/json"
 	"io"
+	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect"
@@ -30,15 +32,15 @@ func TestECashMigrationHandlersRejectInvalidNetworks(t *testing.T) {
 		{name: "same network", fromID: "alphanet", toID: " alphanet "},
 	} {
 		t.Run(test.name, func(t *testing.T) {
-			_, err := handler.PreviewECashMigration(context.Background(), connect.NewRequest(&pb.PreviewECashMigrationRequest{
+			_, err := handler.PreviewECashMigration(context.Background(), &pb.PreviewECashMigrationRequest{
 				FromId: test.fromID,
 				ToId:   test.toID,
-			}))
+			})
 			require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
-			_, err = handler.StartECashMigration(context.Background(), connect.NewRequest(&pb.StartECashMigrationRequest{
+			_, err = handler.StartECashMigration(context.Background(), &pb.StartECashMigrationRequest{
 				FromId: test.fromID,
 				ToId:   test.toID,
-			}))
+			})
 			require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		})
 	}
@@ -77,15 +79,18 @@ func TestECashMigrationStatusReadsTheSavedDaemonRecord(t *testing.T) {
 			require.NoError(t, err)
 			require.NoError(t, os.WriteFile(filepath.Join(dir, "ecash-migration.json"), data, 0o600))
 			orch := orchestrator.New(t.TempDir(), "signet", dir, nil, zerolog.New(io.Discard))
-			_, handler := rpc.NewOrchestratorServiceHandler(NewHandler(orch))
+			rpcServer := connect.NewServer()
+			rpc.RegisterOrchestratorServiceHandler(rpcServer, NewHandler(orch))
+			handler := http.NewServeMux()
+			connecthttp.Mount(handler, rpcServer, connecthttp.WithReadMaxBytes(0))
 			server := httptest.NewServer(handler)
 			t.Cleanup(server.Close)
-			client := rpc.NewOrchestratorServiceClient(server.Client(), server.URL)
+			client := rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 
-			resp, err := client.GetECashMigrationStatus(t.Context(), connect.NewRequest(&pb.GetECashMigrationStatusRequest{}))
+			resp, err := client.GetECashMigrationStatus(t.Context(), &pb.GetECashMigrationStatusRequest{})
 
 			require.NoError(t, err)
-			status := resp.Msg.Status
+			status := resp.Status
 			require.Equal(t, "migration-1", status.JobId)
 			require.Equal(t, "alphanet", status.FromId)
 			require.Equal(t, "betanet", status.ToId)
@@ -106,7 +111,7 @@ func TestECashMigrationStatusReturnsReadFailure(t *testing.T) {
 	require.NoError(t, os.WriteFile(filepath.Join(dir, "ecash-migration.json"), []byte("invalid"), 0o600))
 	orch := orchestrator.New(t.TempDir(), "signet", dir, nil, zerolog.New(io.Discard))
 
-	_, err := NewHandler(orch).GetECashMigrationStatus(t.Context(), connect.NewRequest(&pb.GetECashMigrationStatusRequest{}))
+	_, err := NewHandler(orch).GetECashMigrationStatus(t.Context(), &pb.GetECashMigrationStatusRequest{})
 
 	require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 	require.ErrorContains(t, err, "decode ECX migration")
diff --git a/sidechain-orchestrator/api/ecash_switch_plan_test.go b/sidechain-orchestrator/api/ecash_switch_plan_test.go
index 5ea57fea13..22eee93dc2 100644
--- a/sidechain-orchestrator/api/ecash_switch_plan_test.go
+++ b/sidechain-orchestrator/api/ecash_switch_plan_test.go
@@ -2,12 +2,14 @@ package api
 
 import (
 	"io"
+	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config/netcatalog"
@@ -47,14 +49,17 @@ func TestPlanECashSwitchHandlerReportsChainData(t *testing.T) {
 			if test.badBlocksDir {
 				o.BitcoinConf.Config.SetSetting("blocksdir", "[", "main")
 			}
-			_, handler := rpc.NewBitcoinConfServiceHandler(NewBitcoinConfHandler(o))
+			rpcServer := connect.NewServer()
+			rpc.RegisterBitcoinConfServiceHandler(rpcServer, NewBitcoinConfHandler(o))
+			handler := http.NewServeMux()
+			connecthttp.Mount(handler, rpcServer, connecthttp.WithReadMaxBytes(0))
 			server := httptest.NewServer(handler)
 			t.Cleanup(server.Close)
-			client := rpc.NewBitcoinConfServiceClient(server.Client(), server.URL)
+			client := rpc.NewBitcoinConfServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 
-			response, err := client.PlanECashSwitch(t.Context(), connect.NewRequest(&pb.PlanECashSwitchRequest{
+			response, err := client.PlanECashSwitch(t.Context(), &pb.PlanECashSwitchRequest{
 				NetworkId: " betanet ",
-			}))
+			})
 
 			if test.errorText != "" {
 				require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
@@ -63,9 +68,9 @@ func TestPlanECashSwitchHandlerReportsChainData(t *testing.T) {
 				return
 			}
 			require.NoError(t, err)
-			require.Equal(t, "betanet", response.Msg.ToId)
-			require.Equal(t, test.hasChainData, response.Msg.HasChainData)
-			require.Equal(t, test.chainID, response.Msg.ChainId)
+			require.Equal(t, "betanet", response.ToId)
+			require.Equal(t, test.hasChainData, response.HasChainData)
+			require.Equal(t, test.chainID, response.ChainId)
 		})
 	}
 }
diff --git a/sidechain-orchestrator/api/enforcer_conf_handler.go b/sidechain-orchestrator/api/enforcer_conf_handler.go
index c78588c86d..0d514201b5 100644
--- a/sidechain-orchestrator/api/enforcer_conf_handler.go
+++ b/sidechain-orchestrator/api/enforcer_conf_handler.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
@@ -22,14 +22,14 @@ func NewEnforcerConfHandler(conf *config.EnforcerConfManager) *EnforcerConfHandl
 	return &EnforcerConfHandler{conf: conf}
 }
 
-func (h *EnforcerConfHandler) GetEnforcerConfig(ctx context.Context, req *connect.Request[pb.GetEnforcerConfigRequest]) (*connect.Response[pb.GetEnforcerConfigResponse], error) {
+func (h *EnforcerConfHandler) GetEnforcerConfig(ctx context.Context, req *pb.GetEnforcerConfigRequest) (*pb.GetEnforcerConfigResponse, error) {
 	if h.conf == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("enforcer config manager not initialized"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "enforcer config manager not initialized")
 	}
 
 	// Reload from disk to get latest state
 	if err := h.conf.LoadConfig(); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("reload config: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("reload config: %w", err).Error())
 	}
 
 	var configContent string
@@ -37,7 +37,7 @@ func (h *EnforcerConfHandler) GetEnforcerConfig(ctx context.Context, req *connec
 		configContent = h.conf.Config.Serialize()
 	}
 
-	return connect.NewResponse(&pb.GetEnforcerConfigResponse{
+	return &pb.GetEnforcerConfigResponse{
 		ConfigContent: configContent,
 		ConfigPath:    h.conf.ConfigPath,
 		// node-rpc-* are no longer persisted in enforcer.conf — they're
@@ -48,29 +48,29 @@ func (h *EnforcerConfHandler) GetEnforcerConfig(ctx context.Context, req *connec
 		DefaultConfig:           h.conf.GetDefaultConfig(),
 		CliArgs:                 h.conf.GetCliArgs(),
 		ExpectedNodeRpcSettings: h.conf.GetExpectedNodeRpcSettings(),
-	}), nil
+	}, nil
 }
 
-func (h *EnforcerConfHandler) WriteEnforcerConfig(ctx context.Context, req *connect.Request[pb.WriteEnforcerConfigRequest]) (*connect.Response[pb.WriteEnforcerConfigResponse], error) {
+func (h *EnforcerConfHandler) WriteEnforcerConfig(ctx context.Context, req *pb.WriteEnforcerConfigRequest) (*pb.WriteEnforcerConfigResponse, error) {
 	if h.conf == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("enforcer config manager not initialized"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "enforcer config manager not initialized")
 	}
 
-	h.conf.Config = config.ParseEnforcerConfig(req.Msg.ConfigContent)
+	h.conf.Config = config.ParseEnforcerConfig(req.ConfigContent)
 
 	if err := h.conf.SaveConfig(); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save config: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save config: %w", err).Error())
 	}
 
-	return connect.NewResponse(&pb.WriteEnforcerConfigResponse{}), nil
+	return &pb.WriteEnforcerConfigResponse{}, nil
 }
 
-func (h *EnforcerConfHandler) SyncNodeRpcFromBitcoinConf(ctx context.Context, req *connect.Request[pb.SyncNodeRpcFromBitcoinConfRequest]) (*connect.Response[pb.SyncNodeRpcFromBitcoinConfResponse], error) {
+func (h *EnforcerConfHandler) SyncNodeRpcFromBitcoinConf(ctx context.Context, req *pb.SyncNodeRpcFromBitcoinConfRequest) (*pb.SyncNodeRpcFromBitcoinConfResponse, error) {
 	if h.conf == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("enforcer config manager not initialized"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "enforcer config manager not initialized")
 	}
 	// No-op: node-rpc-* are now overlaid from bitcoin.conf at boot, so
 	// there's nothing to sync into the persisted file. Kept callable so
 	// older clients that still invoke this RPC don't error out.
-	return connect.NewResponse(&pb.SyncNodeRpcFromBitcoinConfResponse{}), nil
+	return &pb.SyncNodeRpcFromBitcoinConfResponse{}, nil
 }
diff --git a/sidechain-orchestrator/api/explorer_blocks.go b/sidechain-orchestrator/api/explorer_blocks.go
index db80b1525b..70d1cf6fbe 100644
--- a/sidechain-orchestrator/api/explorer_blocks.go
+++ b/sidechain-orchestrator/api/explorer_blocks.go
@@ -3,7 +3,7 @@ package api
 import (
 	"context"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/explorer/v1"
 )
@@ -14,22 +14,22 @@ const blockPageLimit = 20
 
 // ListBlocks reads a page of block headers, newest first.
 func (h *ExplorerHandler) ListBlocks(
-	ctx context.Context, req *connect.Request[pb.ListBlocksRequest],
-) (*connect.Response[pb.ListBlocksResponse], error) {
-	src, err := h.sourceOf(req.Msg.GetChain())
+	ctx context.Context, req *pb.ListBlocksRequest,
+) (*pb.ListBlocksResponse, error) {
+	src, err := h.sourceOf(req.GetChain())
 	if err != nil {
 		return nil, err
 	}
-	limit := int(req.Msg.GetLimit())
+	limit := int(req.GetLimit())
 	if limit <= 0 || limit > blockPageLimit {
 		limit = blockPageLimit
 	}
 
 	out := &pb.ListBlocksResponse{}
 	if src.index != nil {
-		rows, err := src.index.BlocksBefore(ctx, req.Msg.GetBeforeHeight())
+		rows, err := src.index.BlocksBefore(ctx, req.GetBeforeHeight())
 		if err != nil {
-			return nil, connect.NewError(connect.CodeUnavailable, err)
+			return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 		}
 		out.Blocks = blockList(rows)
 		if len(out.Blocks) > limit {
@@ -37,7 +37,7 @@ func (h *ExplorerHandler) ListBlocks(
 		}
 		fillIndexBlockDeposits(ctx, src, out.Blocks)
 	} else {
-		out.Blocks, err = nodeBlocksBefore(ctx, src, req.Msg.GetBeforeHeight(), limit)
+		out.Blocks, err = nodeBlocksBefore(ctx, src, req.GetBeforeHeight(), limit)
 		if err != nil {
 			return nil, err
 		}
@@ -46,7 +46,7 @@ func (h *ExplorerHandler) ListBlocks(
 		out.Blocks = out.Blocks[:limit]
 	}
 	h.resolveMainchain(ctx, out.GetBlocks()...)
-	return connect.NewResponse(out), nil
+	return out, nil
 }
 
 // nodeBlocksBefore walks the chain down from one height. A node reads a block
@@ -56,7 +56,7 @@ func nodeBlocksBefore(
 ) ([]*pb.Block, error) {
 	count, err := src.node.GetBlockCount(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	// Core reports the tip height, a sidechain node the block count.
 	tip := count - 1
diff --git a/sidechain-orchestrator/api/explorer_broadcast.go b/sidechain-orchestrator/api/explorer_broadcast.go
index 499211bd89..b84998f3f5 100644
--- a/sidechain-orchestrator/api/explorer_broadcast.go
+++ b/sidechain-orchestrator/api/explorer_broadcast.go
@@ -2,33 +2,32 @@ package api
 
 import (
 	"context"
-	"errors"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/explorer/v1"
 )
 
 var errNoBroadcast = connect.NewError(connect.CodeUnimplemented,
-	errors.New("the sidechain node does not export or broadcast signed transactions"))
+	"the sidechain node does not export or broadcast signed transactions")
 
 // GetSignedTransaction is not available: no sidechain node exports its signed transactions.
 func (h *ExplorerHandler) GetSignedTransaction(
-	context.Context, *connect.Request[pb.GetSignedTransactionRequest],
-) (*connect.Response[pb.GetSignedTransactionResponse], error) {
+	context.Context, *pb.GetSignedTransactionRequest,
+) (*pb.GetSignedTransactionResponse, error) {
 	return nil, errNoBroadcast
 }
 
 // RebroadcastTransaction is not available: no sidechain node rebroadcasts a transaction.
 func (h *ExplorerHandler) RebroadcastTransaction(
-	context.Context, *connect.Request[pb.RebroadcastTransactionRequest],
-) (*connect.Response[pb.RebroadcastTransactionResponse], error) {
+	context.Context, *pb.RebroadcastTransactionRequest,
+) (*pb.RebroadcastTransactionResponse, error) {
 	return nil, errNoBroadcast
 }
 
 // BroadcastTransaction is not available: no sidechain node takes a signed transaction.
 func (h *ExplorerHandler) BroadcastTransaction(
-	context.Context, *connect.Request[pb.BroadcastTransactionRequest],
-) (*connect.Response[pb.BroadcastTransactionResponse], error) {
+	context.Context, *pb.BroadcastTransactionRequest,
+) (*pb.BroadcastTransactionResponse, error) {
 	return nil, errNoBroadcast
 }
diff --git a/sidechain-orchestrator/api/explorer_broadcast_test.go b/sidechain-orchestrator/api/explorer_broadcast_test.go
index 3c6782cc94..eb49cebaed 100644
--- a/sidechain-orchestrator/api/explorer_broadcast_test.go
+++ b/sidechain-orchestrator/api/explorer_broadcast_test.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/require"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/explorer/v1"
@@ -18,12 +18,12 @@ func TestExplorerBroadcastIsUnimplemented(t *testing.T) {
 	}}
 	ctx := context.Background()
 
-	_, err := h.GetSignedTransaction(ctx, connect.NewRequest(&pb.GetSignedTransactionRequest{Chain: "bitnames", Txid: txid}))
+	_, err := h.GetSignedTransaction(ctx, &pb.GetSignedTransactionRequest{Chain: "bitnames", Txid: txid})
 	require.Equal(t, connect.CodeUnimplemented, connect.CodeOf(err))
-	_, err = h.RebroadcastTransaction(ctx, connect.NewRequest(&pb.RebroadcastTransactionRequest{Chain: "bitnames", Txid: txid}))
+	_, err = h.RebroadcastTransaction(ctx, &pb.RebroadcastTransactionRequest{Chain: "bitnames", Txid: txid})
 	require.Equal(t, connect.CodeUnimplemented, connect.CodeOf(err))
-	_, err = h.BroadcastTransaction(ctx, connect.NewRequest(&pb.BroadcastTransactionRequest{
+	_, err = h.BroadcastTransaction(ctx, &pb.BroadcastTransactionRequest{
 		Chain: "bitassets", SignedTransaction: `{"transaction":{},"authorizations":[]}`,
-	}))
+	})
 	require.Equal(t, connect.CodeUnimplemented, connect.CodeOf(err))
 }
diff --git a/sidechain-orchestrator/api/explorer_cache.go b/sidechain-orchestrator/api/explorer_cache.go
index e0662b3d71..12aecb15d6 100644
--- a/sidechain-orchestrator/api/explorer_cache.go
+++ b/sidechain-orchestrator/api/explorer_cache.go
@@ -5,7 +5,6 @@ import (
 	"slices"
 	"sync"
 
-	"connectrpc.com/connect"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 
@@ -187,11 +186,11 @@ func (h *ExplorerHandler) anchorFromEnforcer(ctx context.Context, hash string) (
 		return mainchainAnchor{}, false
 	}
 	out := mainchainAnchor{parentHeight: parent[0].GetHeight()}
-	tip, err := validator.GetChainTip(ctx, connect.NewRequest(&enforcerpb.GetChainTipRequest{}))
+	tip, err := validator.GetChainTip(ctx, &enforcerpb.GetChainTipRequest{})
 	if err != nil {
 		return out, true
 	}
-	from := tip.Msg.GetBlockHeaderInfo()
+	from := tip.GetBlockHeaderInfo()
 	for from.GetHeight() > out.parentHeight {
 		headers, err := enforcerHeaders(ctx, validator,
 			from.GetBlockHash().GetHex().GetValue(), min(from.GetHeight()-out.parentHeight-1, enforcerHeaderPage))
@@ -225,15 +224,14 @@ func (h *ExplorerHandler) anchorFromEnforcer(ctx context.Context, hash string) (
 func enforcerHeaders(
 	ctx context.Context, validator enforcerrpc.ValidatorServiceClient, hash string, ancestors uint32,
 ) ([]*enforcerpb.BlockHeaderInfo, error) {
-	resp, err := validator.GetBlockHeaderInfo(ctx, connect.NewRequest(
-		&enforcerpb.GetBlockHeaderInfoRequest{
-			BlockHash:    &commonv1.ReverseHex{Hex: wrapperspb.String(hash)},
-			MaxAncestors: &ancestors,
-		}))
+	resp, err := validator.GetBlockHeaderInfo(ctx, &enforcerpb.GetBlockHeaderInfoRequest{
+		BlockHash:    &commonv1.ReverseHex{Hex: wrapperspb.String(hash)},
+		MaxAncestors: &ancestors,
+	})
 	if err != nil {
 		return nil, err
 	}
-	return resp.Msg.GetHeaderInfos(), nil
+	return resp.GetHeaderInfos(), nil
 }
 
 // carrierAnchors names, for each header, the anchor of the block before it.
diff --git a/sidechain-orchestrator/api/explorer_core.go b/sidechain-orchestrator/api/explorer_core.go
index b8ef27fe2d..2cbb5f179c 100644
--- a/sidechain-orchestrator/api/explorer_core.go
+++ b/sidechain-orchestrator/api/explorer_core.go
@@ -9,7 +9,7 @@ import (
 	"strconv"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/explorer/v1"
 )
@@ -30,7 +30,7 @@ type coreBlock struct {
 func coreOverview(ctx context.Context, src source) (*pb.GetOverviewResponse, error) {
 	count, err := src.node.GetBlockCount(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	out := &pb.GetOverviewResponse{Source: "node", Mempool: &pb.Mempool{}}
 	if count < 0 {
@@ -67,12 +67,12 @@ func coreOverview(ctx context.Context, src source) (*pb.GetOverviewResponse, err
 func coreBlockAtHeight(ctx context.Context, src source, height uint32) (*pb.Block, []*pb.Activity, error) {
 	raw, err := src.node.CallRaw(ctx, "getblockhash", []uint32{height})
 	if err != nil {
-		return nil, nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	var hash string
 	if err := json.Unmarshal(raw, &hash); err != nil {
 		return nil, nil, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read the hash at height %d: %w", height, err))
+			fmt.Errorf("read the hash at height %d: %w", height, err).Error())
 	}
 	return coreBlockByHash(ctx, src, hash)
 }
@@ -95,12 +95,12 @@ func coreBlockByHash(ctx context.Context, src source, hash string) (*pb.Block, [
 func readCoreBlock(ctx context.Context, src source, hash string) (*pb.Block, []*pb.Activity, error) {
 	raw, err := src.node.CallRaw(ctx, "getblock", []any{hash, 1})
 	if err != nil {
-		return nil, nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	var block coreBlock
 	if err := json.Unmarshal(raw, &block); err != nil {
 		return nil, nil, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read block %s: %w", hash, err))
+			fmt.Errorf("read block %s: %w", hash, err).Error())
 	}
 
 	out := &pb.Block{
@@ -189,7 +189,7 @@ func nodeTransaction(ctx context.Context, src source, txid string) (*pb.Transact
 	// "Invalid params", whatever the schema declares.
 	raw, err := src.node.CallRaw(ctx, "get_transaction", []string{txid})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	if len(raw) == 0 || string(raw) == "null" {
 		// A node answers only for what its wallet or its mempool holds. A
@@ -207,7 +207,7 @@ func nodeTransaction(ctx context.Context, src source, txid string) (*pb.Transact
 	var tx nodeTx
 	if err := json.Unmarshal(body, &tx); err != nil {
 		return nil, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read transaction %s: %w", txid, err))
+			fmt.Errorf("read transaction %s: %w", txid, err).Error())
 	}
 
 	out := &pb.Transaction{Txid: txid, Kind: pb.Kind_KIND_TRANSFER}
@@ -227,7 +227,7 @@ func nodeTransaction(ctx context.Context, src source, txid string) (*pb.Transact
 			mainTxid, vout, err := parseMainchainOutpoint(*in.Deposit)
 			if err != nil {
 				return nil, connect.NewError(connect.CodeInternal,
-					fmt.Errorf("read transaction %s: %w", txid, err))
+					fmt.Errorf("read transaction %s: %w", txid, err).Error())
 			}
 			out.Inputs = append(out.Inputs, &pb.Coin{
 				Txid: mainTxid, Vout: vout, OutpointKind: "deposit",
@@ -302,7 +302,7 @@ func coreTransaction(ctx context.Context, src source, txid string) (*pb.Transact
 		}
 		raw, err = src.node.CallRaw(ctx, "getrawtransaction", []any{txid, true, hash})
 		if err != nil {
-			return nil, connect.NewError(connect.CodeNotFound, err)
+			return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 		}
 	}
 	var tx struct {
@@ -324,7 +324,7 @@ func coreTransaction(ctx context.Context, src source, txid string) (*pb.Transact
 	}
 	if err := json.Unmarshal(raw, &tx); err != nil {
 		return nil, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read transaction %s: %w", txid, err))
+			fmt.Errorf("read transaction %s: %w", txid, err).Error())
 	}
 
 	out := &pb.Transaction{
@@ -363,19 +363,19 @@ const searchBlockDepth = 200
 func minedTransaction(ctx context.Context, src source, txid string) (*pb.Transaction, error) {
 	count, err := src.node.GetBlockCount(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	if count <= 0 {
 		return nil, notFoundTransaction(src, txid)
 	}
 	raw, err := src.node.CallRaw(ctx, "get_best_sidechain_block_hash", nil)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	var hash string
 	if err := json.Unmarshal(raw, &hash); err != nil {
 		return nil, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read the tip hash: %w", err))
+			fmt.Errorf("read the tip hash: %w", err).Error())
 	}
 
 	for height := count - 1; height >= 0 && hash != ""; height-- {
@@ -400,9 +400,9 @@ func minedTransaction(ctx context.Context, src source, txid string) (*pb.Transac
 // notFoundTransaction says a node holds no such transaction, and why the
 // search is bounded.
 func notFoundTransaction(src source, txid string) error {
-	return connect.NewError(connect.CodeNotFound, fmt.Errorf(
+	return connect.Errorf(connect.CodeNotFound,
 		"%s holds no transaction %s in its newest %d blocks. A node keeps no transaction index",
-		src.name, txid, searchBlockDepth))
+		src.name, txid, searchBlockDepth)
 }
 
 // blockTransaction reads one transaction out of the block that carries it.
@@ -455,7 +455,7 @@ func coinFromContent(address string, content json.RawMessage, tx *pb.Transaction
 func coreBlockOf(ctx context.Context, src source, txid string) (string, error) {
 	count, err := src.node.GetBlockCount(ctx)
 	if err != nil {
-		return "", connect.NewError(connect.CodeUnavailable, err)
+		return "", connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	for height := count; height >= 0 && count-height < searchBlockDepth; height-- {
 		block, activity, err := coreBlockAtHeight(ctx, src, uint32(height))
diff --git a/sidechain-orchestrator/api/explorer_enforcer_anchor_test.go b/sidechain-orchestrator/api/explorer_enforcer_anchor_test.go
index 83cc0d130a..d991b97512 100644
--- a/sidechain-orchestrator/api/explorer_enforcer_anchor_test.go
+++ b/sidechain-orchestrator/api/explorer_enforcer_anchor_test.go
@@ -1,13 +1,14 @@
 package api
 
 import (
+	"connectrpc.com/connect/v2/connecthttp"
 	"context"
 	"fmt"
 	"io"
 	"net/http"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -43,33 +44,34 @@ func (c *headerChain) header(height uint32) *enforcerpb.BlockHeaderInfo {
 }
 
 func (c *headerChain) GetChainTip(
-	context.Context, *connect.Request[enforcerpb.GetChainTipRequest],
-) (*connect.Response[enforcerpb.GetChainTipResponse], error) {
-	return connect.NewResponse(&enforcerpb.GetChainTipResponse{BlockHeaderInfo: c.header(c.tip)}), nil
+	context.Context, *enforcerpb.GetChainTipRequest,
+) (*enforcerpb.GetChainTipResponse, error) {
+	return &enforcerpb.GetChainTipResponse{BlockHeaderInfo: c.header(c.tip)}, nil
 }
 
 func (c *headerChain) GetBlockHeaderInfo(
-	_ context.Context, req *connect.Request[enforcerpb.GetBlockHeaderInfoRequest],
-) (*connect.Response[enforcerpb.GetBlockHeaderInfoResponse], error) {
+	_ context.Context, req *enforcerpb.GetBlockHeaderInfoRequest,
+) (*enforcerpb.GetBlockHeaderInfoResponse, error) {
 	c.calls++
 	var start uint32
-	if _, err := fmt.Sscanf(req.Msg.GetBlockHash().GetHex().GetValue(), "h%d", &start); err != nil || start > c.tip {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("no block %s", req.Msg.GetBlockHash()))
+	if _, err := fmt.Sscanf(req.GetBlockHash().GetHex().GetValue(), "h%d", &start); err != nil || start > c.tip {
+		return nil, connect.Errorf(connect.CodeNotFound, "no block %s", req.GetBlockHash())
 	}
-	count := min(req.Msg.GetMaxAncestors()+1, c.pageSize)
+	count := min(req.GetMaxAncestors()+1, c.pageSize)
 	c.largest = max(c.largest, count)
 	var out []*enforcerpb.BlockHeaderInfo
 	for height := start; height >= 100 && uint32(len(out)) < count; height-- {
 		out = append(out, c.header(height))
 	}
-	return connect.NewResponse(&enforcerpb.GetBlockHeaderInfoResponse{HeaderInfos: out}), nil
+	return &enforcerpb.GetBlockHeaderInfoResponse{HeaderInfos: out}, nil
 }
 
 func lightExplorer(t *testing.T, chain *headerChain) *ExplorerHandler {
 	t.Helper()
 	mux := http.NewServeMux()
-	path, handler := enforcerrpc.NewValidatorServiceHandler(chain)
-	mux.Handle(path, handler)
+	rpcServer := connect.NewServer()
+	enforcerrpc.RegisterValidatorServiceHandler(rpcServer, chain)
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := h2cServer(mux)
 	t.Cleanup(server.Close)
 	host, port := hostPort(t, server)
diff --git a/sidechain-orchestrator/api/explorer_handler.go b/sidechain-orchestrator/api/explorer_handler.go
index 689b144ef8..6b464d1b41 100644
--- a/sidechain-orchestrator/api/explorer_handler.go
+++ b/sidechain-orchestrator/api/explorer_handler.go
@@ -8,7 +8,7 @@ import (
 	"sort"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
@@ -92,18 +92,18 @@ func (s source) cacheKey(hash string) string { return s.origin + ":" + hash }
 // sourceFor selects the local node.
 func (h *ExplorerHandler) sourceFor(chain string) (source, error) {
 	if h.orch == nil {
-		return source{}, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("orchestrator not wired"))
+		return source{}, connect.Errorf(connect.CodeFailedPrecondition,
+			"orchestrator not wired")
 	}
 	chain = strings.TrimSpace(chain)
 	if chain == "" {
-		return source{}, connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("name a chain"))
+		return source{}, connect.Errorf(connect.CodeInvalidArgument,
+			"name a chain")
 	}
 	cfg, ok := h.orch.Configs()[chain]
 	if !ok {
-		return source{}, connect.NewError(connect.CodeNotFound,
-			fmt.Errorf("sidechain %s is not configured", chain))
+		return source{}, connect.Errorf(connect.CodeNotFound,
+			"sidechain %s is not configured", chain)
 	}
 	network := config.NetworkFromString(h.orch.CurrentNetwork())
 
@@ -119,7 +119,7 @@ func (h *ExplorerHandler) sourceFor(chain string) (source, error) {
 	}
 	node, err := sidechainNode(cfg, network)
 	if err != nil {
-		return source{}, connect.NewError(connect.CodeUnavailable, err)
+		return source{}, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	out.node = node
 	return out, nil
@@ -127,9 +127,9 @@ func (h *ExplorerHandler) sourceFor(chain string) (source, error) {
 
 // GetOverview answers the explorer landing page.
 func (h *ExplorerHandler) GetOverview(
-	ctx context.Context, req *connect.Request[pb.GetOverviewRequest],
-) (*connect.Response[pb.GetOverviewResponse], error) {
-	src, err := h.sourceOf(req.Msg.GetChain())
+	ctx context.Context, req *pb.GetOverviewRequest,
+) (*pb.GetOverviewResponse, error) {
+	src, err := h.sourceOf(req.GetChain())
 	if err != nil {
 		return nil, err
 	}
@@ -148,21 +148,21 @@ func (h *ExplorerHandler) GetOverview(
 		out.Treasury = h.enforcerTreasury(ctx, src.slot)
 	}
 	h.resolveMainchain(ctx, out.GetBlocks()...)
-	return connect.NewResponse(out), nil
+	return out, nil
 }
 
 func indexOverview(ctx context.Context, src source) (*pb.GetOverviewResponse, error) {
 	blocks, err := src.index.Blocks(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	recent, err := src.index.RecentActivity(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	pool, err := src.index.Mempool(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 
 	out := &pb.GetOverviewResponse{
@@ -222,7 +222,7 @@ func fillIndexBlockDeposits(ctx context.Context, src source, blocks []*pb.Block)
 func nodeOverview(ctx context.Context, src source) (*pb.GetOverviewResponse, error) {
 	count, err := src.node.GetBlockCount(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	out := &pb.GetOverviewResponse{Source: "node", Mempool: &pb.Mempool{}}
 	if count <= 0 {
@@ -233,12 +233,12 @@ func nodeOverview(ctx context.Context, src source) (*pb.GetOverviewResponse, err
 
 	hash, err := src.node.CallRaw(ctx, "get_best_sidechain_block_hash", nil)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	var next string
 	if err := json.Unmarshal(hash, &next); err != nil {
 		return nil, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read the tip hash: %w", err))
+			fmt.Errorf("read the tip hash: %w", err).Error())
 	}
 
 	// The walk reads far more blocks than the page keeps. Only a kept block,
@@ -299,7 +299,7 @@ func nodeOverview(ctx context.Context, src source) (*pb.GetOverviewResponse, err
 	// The unconfirmed rows lead the mined ones, the way an explorer reads.
 	pool, err := sidechain.Mempool(ctx, src.node)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	out.Mempool.TxCount = uint32(len(pool))
 	out.Recent = append(mempoolActivity(pool), out.Recent...)
@@ -322,12 +322,12 @@ func (h *ExplorerHandler) enforcerTreasury(ctx context.Context, slot uint32) *pb
 	if err != nil {
 		return nil
 	}
-	chains, err := validator.GetSidechains(ctx, connect.NewRequest(&enforcerpb.GetSidechainsRequest{}))
+	chains, err := validator.GetSidechains(ctx, &enforcerpb.GetSidechainsRequest{})
 	if err != nil {
 		return nil
 	}
 	var out *pb.Treasury
-	for _, c := range chains.Msg.GetSidechains() {
+	for _, c := range chains.GetSidechains() {
 		if c.GetSidechainNumber().GetValue() != slot {
 			continue
 		}
@@ -337,13 +337,13 @@ func (h *ExplorerHandler) enforcerTreasury(ctx context.Context, slot uint32) *pb
 		return nil
 	}
 
-	ctip, err := validator.GetCtip(ctx, connect.NewRequest(&enforcerpb.GetCtipRequest{
+	ctip, err := validator.GetCtip(ctx, &enforcerpb.GetCtipRequest{
 		SidechainNumber: wrapperspb.UInt32(slot),
-	}))
+	})
 	if err != nil {
 		return out
 	}
-	if c := ctip.Msg.GetCtip(); c != nil {
+	if c := ctip.GetCtip(); c != nil {
 		out.BalanceSats = int64(c.GetValue())
 		out.CtipTxid = c.GetTxid().GetHex().GetValue()
 		out.CtipVout = c.GetVout()
@@ -353,36 +353,36 @@ func (h *ExplorerHandler) enforcerTreasury(ctx context.Context, slot uint32) *pb
 
 // GetBlock reads one block and what it carried.
 func (h *ExplorerHandler) GetBlock(
-	ctx context.Context, req *connect.Request[pb.GetBlockRequest],
-) (*connect.Response[pb.GetBlockResponse], error) {
-	src, err := h.sourceOf(req.Msg.GetChain())
+	ctx context.Context, req *pb.GetBlockRequest,
+) (*pb.GetBlockResponse, error) {
+	src, err := h.sourceOf(req.GetChain())
 	if err != nil {
 		return nil, err
 	}
-	hash := strings.TrimSpace(req.Msg.GetHash())
+	hash := strings.TrimSpace(req.GetHash())
 
 	if src.index != nil {
 		if hash == "" {
-			hash, err = src.index.BlockHashAtHeight(ctx, req.Msg.GetHeight())
+			hash, err = src.index.BlockHashAtHeight(ctx, req.GetHeight())
 			if err != nil {
-				return nil, connect.NewError(connect.CodeNotFound, err)
+				return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 			}
 			hash = strings.TrimSpace(hash)
 		}
 		block, err := src.index.Block(ctx, hash)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeNotFound, err)
+			return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 		}
 		rows, err := src.index.BlockActivity(ctx, hash)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeUnavailable, err)
+			return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 		}
 		out := &pb.GetBlockResponse{Block: newBlock(block), Activity: activityList(rows)}
 		countDeposits(out.Block, out.Activity)
 		h.resolveMainchain(ctx, out.Block)
 		stampRows(out.Block, out.Activity)
 		h.resolveBid(ctx, src.slot, out.Block)
-		return connect.NewResponse(out), nil
+		return out, nil
 	}
 
 	if src.core {
@@ -391,15 +391,15 @@ func (h *ExplorerHandler) GetBlock(
 		if hash != "" {
 			block, activity, err = coreBlockByHash(ctx, src, hash)
 		} else {
-			block, activity, err = coreBlockAtHeight(ctx, src, req.Msg.GetHeight())
+			block, activity, err = coreBlockAtHeight(ctx, src, req.GetHeight())
 		}
 		if err != nil {
 			return nil, err
 		}
-		return connect.NewResponse(&pb.GetBlockResponse{Block: block, Activity: activity}), nil
+		return &pb.GetBlockResponse{Block: block, Activity: activity}, nil
 	}
 
-	height := req.Msg.GetHeight()
+	height := req.GetHeight()
 	if hash == "" {
 		hash, err = nodeHashAtHeight(ctx, src, height)
 		if err != nil {
@@ -420,7 +420,7 @@ func (h *ExplorerHandler) GetBlock(
 	h.resolveMainchain(ctx, block)
 	stampRows(block, activity)
 	h.resolveBid(ctx, src.slot, block)
-	return connect.NewResponse(&pb.GetBlockResponse{Block: block, Activity: activity}), nil
+	return &pb.GetBlockResponse{Block: block, Activity: activity}, nil
 }
 
 // countDeposits fills in what a block took from the mainchain, for a source
@@ -440,15 +440,15 @@ func countDeposits(block *pb.Block, rows []*pb.Activity) {
 
 // GetTransaction reads one transaction.
 func (h *ExplorerHandler) GetTransaction(
-	ctx context.Context, req *connect.Request[pb.GetTransactionRequest],
-) (*connect.Response[pb.GetTransactionResponse], error) {
-	src, err := h.sourceOf(req.Msg.GetChain())
+	ctx context.Context, req *pb.GetTransactionRequest,
+) (*pb.GetTransactionResponse, error) {
+	src, err := h.sourceOf(req.GetChain())
 	if err != nil {
 		return nil, err
 	}
-	txid := strings.TrimSpace(req.Msg.GetTxid())
+	txid := strings.TrimSpace(req.GetTxid())
 	if txid == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("name a txid"))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "name a txid")
 	}
 	if src.index == nil {
 		read := nodeTransaction
@@ -459,29 +459,29 @@ func (h *ExplorerHandler) GetTransaction(
 		if err != nil {
 			return nil, err
 		}
-		return connect.NewResponse(&pb.GetTransactionResponse{Transaction: out}), nil
+		return &pb.GetTransactionResponse{Transaction: out}, nil
 	}
 	tx, err := src.index.Tx(ctx, txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.GetTransactionResponse{Transaction: newTransaction(tx)}), nil
+	return &pb.GetTransactionResponse{Transaction: newTransaction(tx)}, nil
 }
 
 // nodeHeightOfHash walks down from the tip to the height of one hash.
 func nodeHeightOfHash(ctx context.Context, src source, hash string) (uint32, error) {
 	count, err := src.node.GetBlockCount(ctx)
 	if err != nil {
-		return 0, connect.NewError(connect.CodeUnavailable, err)
+		return 0, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	raw, err := src.node.CallRaw(ctx, "get_best_sidechain_block_hash", nil)
 	if err != nil {
-		return 0, connect.NewError(connect.CodeUnavailable, err)
+		return 0, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	var at string
 	if err := json.Unmarshal(raw, &at); err != nil {
 		return 0, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read the tip hash: %w", err))
+			fmt.Errorf("read the tip hash: %w", err).Error())
 	}
 
 	for height := count - 1; height >= 0; height-- {
@@ -498,21 +498,21 @@ func nodeHeightOfHash(ctx context.Context, src source, hash string) (uint32, err
 		}
 		at = *prev
 	}
-	return 0, connect.NewError(connect.CodeNotFound,
-		fmt.Errorf("no block on %s hashes to %s", src.name, hash))
+	return 0, connect.Errorf(connect.CodeNotFound,
+		"no block on %s hashes to %s", src.name, hash)
 }
 
 // GetAddress reads what an address holds and what it did.
 func (h *ExplorerHandler) GetAddress(
-	ctx context.Context, req *connect.Request[pb.GetAddressRequest],
-) (*connect.Response[pb.GetAddressResponse], error) {
-	src, err := h.sourceOf(req.Msg.GetChain())
+	ctx context.Context, req *pb.GetAddressRequest,
+) (*pb.GetAddressResponse, error) {
+	src, err := h.sourceOf(req.GetChain())
 	if err != nil {
 		return nil, err
 	}
-	address := strings.TrimSpace(req.Msg.GetAddress())
+	address := strings.TrimSpace(req.GetAddress())
 	if address == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("name an address"))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "name an address")
 	}
 	// No node holds an address index, so an address always reads the hosted
 	// one, whether the app runs a full node or a light client.
@@ -521,19 +521,19 @@ func (h *ExplorerHandler) GetAddress(
 		index = h.addressIndex(src.name)
 	}
 	if index == nil {
-		return nil, connect.NewError(connect.CodeUnimplemented,
-			fmt.Errorf("%s has no index, and a node keeps no address history", src.name))
+		return nil, connect.Errorf(connect.CodeUnimplemented,
+			"%s has no index, and a node keeps no address history", src.name)
 	}
 
 	stats, err := index.AddressStats(ctx, address)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	}
 	// The first page already carries the unconfirmed rows, so a separate
 	// mempool read would list every one of them twice.
 	history, err := sidechainesplora.NewWallet(index).AddressHistory(ctx, address)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 
 	out := &pb.GetAddressResponse{
@@ -554,14 +554,14 @@ func (h *ExplorerHandler) GetAddress(
 	// from their own route.
 	deposits, err := index.AddressDeposits(ctx, address)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	for _, deposit := range deposits {
 		out.Transactions = append(out.Transactions, depositTransaction(address, deposit))
 		out.TxCount++
 	}
 	sortNewestFirst(out.Transactions)
-	return connect.NewResponse(out), nil
+	return out, nil
 }
 
 // sortNewestFirst orders an address history the way the view reads it: the
@@ -608,9 +608,9 @@ func depositTransaction(address string, deposit sidechainesplora.UTXO) *pb.Trans
 
 // GetWithdrawals reads the bundle the chain proposes to the mainchain.
 func (h *ExplorerHandler) GetWithdrawals(
-	ctx context.Context, req *connect.Request[pb.GetWithdrawalsRequest],
-) (*connect.Response[pb.GetWithdrawalsResponse], error) {
-	src, err := h.sourceOf(req.Msg.GetChain())
+	ctx context.Context, req *pb.GetWithdrawalsRequest,
+) (*pb.GetWithdrawalsResponse, error) {
+	src, err := h.sourceOf(req.GetChain())
 	if err != nil {
 		return nil, err
 	}
@@ -618,29 +618,29 @@ func (h *ExplorerHandler) GetWithdrawals(
 	if src.index != nil {
 		state, err := src.index.Withdrawals(ctx)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeUnavailable, err)
+			return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 		}
 		out.Bundle = parseBundle(state.Bundle)
 		if state.LastFailedHeight != nil {
 			out.LastFailedHeight = *state.LastFailedHeight
 		}
-		return connect.NewResponse(out), nil
+		return out, nil
 	}
 
 	bundles, err := withdrawalNode(src.node, src.name)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnimplemented, err)
+		return nil, connect.NewError(connect.CodeUnimplemented, err.Error()).WithCause(err)
 	}
 	raw, err := bundles.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	out.Bundle = parseBundle(raw)
 	height, err := bundles.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err == nil && height >= 0 {
 		out.LastFailedHeight = uint32(height)
 	}
-	return connect.NewResponse(out), nil
+	return out, nil
 }
 
 // nodeHashAtHeight walks down from the tip to the hash at one height. No
@@ -648,21 +648,21 @@ func (h *ExplorerHandler) GetWithdrawals(
 func nodeHashAtHeight(ctx context.Context, src source, height uint32) (string, error) {
 	count, err := src.node.GetBlockCount(ctx)
 	if err != nil {
-		return "", connect.NewError(connect.CodeUnavailable, err)
+		return "", connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	if count <= 0 || height > uint32(count-1) {
-		return "", connect.NewError(connect.CodeNotFound,
-			fmt.Errorf("%s holds no block at height %d", src.name, height))
+		return "", connect.Errorf(connect.CodeNotFound,
+			"%s holds no block at height %d", src.name, height)
 	}
 
 	raw, err := src.node.CallRaw(ctx, "get_best_sidechain_block_hash", nil)
 	if err != nil {
-		return "", connect.NewError(connect.CodeUnavailable, err)
+		return "", connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	var hash string
 	if err := json.Unmarshal(raw, &hash); err != nil {
 		return "", connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read the tip hash: %w", err))
+			fmt.Errorf("read the tip hash: %w", err).Error())
 	}
 
 	for at := uint32(count - 1); at > height; at-- {
@@ -838,16 +838,16 @@ func nodeHeader(ctx context.Context, src source, hash string) (nodeHeaderJSON, e
 	// "Invalid params", whatever the older handlers pass.
 	raw, err := src.node.CallRaw(ctx, "get_block", []string{hash})
 	if err != nil {
-		return nodeHeaderJSON{}, connect.NewError(connect.CodeUnavailable, err)
+		return nodeHeaderJSON{}, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	if len(raw) == 0 || string(raw) == "null" {
-		return nodeHeaderJSON{}, connect.NewError(connect.CodeNotFound,
-			fmt.Errorf("no block on %s hashes to %s", src.name, hash))
+		return nodeHeaderJSON{}, connect.Errorf(connect.CodeNotFound,
+			"no block on %s hashes to %s", src.name, hash)
 	}
 	var block nodeHeaderJSON
 	if err := json.Unmarshal(raw, &block); err != nil {
 		return nodeHeaderJSON{}, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read block %s: %w", hash, err))
+			fmt.Errorf("read block %s: %w", hash, err).Error())
 	}
 	return block, nil
 }
@@ -944,7 +944,7 @@ func readNodeBlock(
 	var index nodeBlockIndex
 	if err := json.Unmarshal(rawIndex, &index); err != nil {
 		return nil, nil, state, connect.NewError(connect.CodeInternal,
-			fmt.Errorf("read the block index of %s: %w", hash, err))
+			fmt.Errorf("read the block index of %s: %w", hash, err).Error())
 	}
 
 	// The block index names the txids in body order, so a transaction pairs
diff --git a/sidechain-orchestrator/api/explorer_index_test.go b/sidechain-orchestrator/api/explorer_index_test.go
index ec89154efc..c4cee077d2 100644
--- a/sidechain-orchestrator/api/explorer_index_test.go
+++ b/sidechain-orchestrator/api/explorer_index_test.go
@@ -9,7 +9,7 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/explorer/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain/sidechainesplora"
@@ -224,13 +224,13 @@ func TestGetBlockResolvesTheMainchainForAnIndex(t *testing.T) {
 		return json.RawMessage(`{"height":996817,"time":9581}`), nil
 	})
 
-	resp, err := handler.GetBlock(context.Background(), connect.NewRequest(&pb.GetBlockRequest{
+	resp, err := handler.GetBlock(context.Background(), &pb.GetBlockRequest{
 		Chain: "thunder", Hash: "b43",
-	}))
+	})
 	if err != nil {
 		t.Fatalf("read the block: %v", err)
 	}
-	out := resp.Msg
+	out := resp
 
 	if got := out.GetBlock().GetMainchainHeight(); got != 996816 {
 		t.Errorf("the parent row names block %d, want 996816", got)
@@ -267,9 +267,9 @@ func TestStampRowsKeepsATimeTheRowAlreadyHas(t *testing.T) {
 // through sourceOf, which falls back when no test replaced the seam.
 func TestHandlerWithNoSeamAnswersAnError(t *testing.T) {
 	handler := &ExplorerHandler{}
-	_, err := handler.GetOverview(context.Background(), connect.NewRequest(&pb.GetOverviewRequest{
+	_, err := handler.GetOverview(context.Background(), &pb.GetOverviewRequest{
 		Chain: "thunder",
-	}))
+	})
 	if err == nil {
 		t.Fatal("a handler with no orchestrator answered a page")
 	}
diff --git a/sidechain-orchestrator/api/explorer_test.go b/sidechain-orchestrator/api/explorer_test.go
index 9e2179b923..b4500fbf55 100644
--- a/sidechain-orchestrator/api/explorer_test.go
+++ b/sidechain-orchestrator/api/explorer_test.go
@@ -7,7 +7,7 @@ import (
 	"slices"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/explorer/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
diff --git a/sidechain-orchestrator/api/fork_status_test.go b/sidechain-orchestrator/api/fork_status_test.go
index c9aa3aecac..7d2b528ec1 100644
--- a/sidechain-orchestrator/api/fork_status_test.go
+++ b/sidechain-orchestrator/api/fork_status_test.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
@@ -19,9 +18,9 @@ func TestGetForkStatusReportsTheNetworkReplayLockTime(t *testing.T) {
 		config.SetECashEndpoints(entry)
 
 		response, err := NewHandler(&orchestrator.Orchestrator{Network: "ecash"}).
-			GetForkStatus(context.Background(), connect.NewRequest(&pb.GetForkStatusRequest{}))
+			GetForkStatus(context.Background(), &pb.GetForkStatusRequest{})
 		config.SetECashEndpoints(previous)
 		require.NoError(t, err)
-		require.Equal(t, lockTime, response.Msg.ReplayLockTime)
+		require.Equal(t, lockTime, response.ReplayLockTime)
 	}
 }
diff --git a/sidechain-orchestrator/api/generate_wallet_path_test.go b/sidechain-orchestrator/api/generate_wallet_path_test.go
index 41ef27f373..170dc9296e 100644
--- a/sidechain-orchestrator/api/generate_wallet_path_test.go
+++ b/sidechain-orchestrator/api/generate_wallet_path_test.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -17,12 +17,12 @@ import (
 func TestGenerateWalletAcceptsAStandardPathWithNoScriptType(t *testing.T) {
 	h, _, _, _, _ := newRoutedHandler(t)
 
-	resp, err := h.GenerateWallet(context.Background(), connect.NewRequest(&pb.GenerateWalletRequest{
+	resp, err := h.GenerateWallet(context.Background(), &pb.GenerateWalletRequest{
 		Name:           "Taproot",
 		DerivationPath: "m/86'/1'/0'",
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "taproot", h.svc.GetWalletByID(resp.Msg.WalletId).ScriptType)
+	assert.Equal(t, "taproot", h.svc.GetWalletByID(resp.WalletId).ScriptType)
 }
 
 // A stated type and a path that disagree would scan addresses the wallet does
@@ -30,11 +30,11 @@ func TestGenerateWalletAcceptsAStandardPathWithNoScriptType(t *testing.T) {
 func TestGenerateWalletRefusesAPathThatFightsTheScriptType(t *testing.T) {
 	h, _, _, _, _ := newRoutedHandler(t)
 
-	_, err := h.GenerateWallet(context.Background(), connect.NewRequest(&pb.GenerateWalletRequest{
+	_, err := h.GenerateWallet(context.Background(), &pb.GenerateWalletRequest{
 		Name:           "Mismatch",
 		DerivationPath: "m/86'/1'/0'",
 		ScriptType:     "legacy",
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
@@ -42,10 +42,10 @@ func TestGenerateWalletRefusesAPathThatFightsTheScriptType(t *testing.T) {
 func TestGenerateWalletRefusesABadMnemonic(t *testing.T) {
 	h, _, _, _, _ := newRoutedHandler(t)
 
-	_, err := h.GenerateWallet(context.Background(), connect.NewRequest(&pb.GenerateWalletRequest{
+	_, err := h.GenerateWallet(context.Background(), &pb.GenerateWalletRequest{
 		Name:           "Bad",
 		CustomMnemonic: "abandon abandon abandon",
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
@@ -53,10 +53,10 @@ func TestGenerateWalletRefusesABadMnemonic(t *testing.T) {
 func TestCreateWatchOnlyWalletRefusesABadKey(t *testing.T) {
 	h, _, _, _, _ := newRoutedHandler(t)
 
-	_, err := h.CreateWatchOnlyWallet(context.Background(), connect.NewRequest(&pb.CreateWatchOnlyWalletRequest{
+	_, err := h.CreateWatchOnlyWallet(context.Background(), &pb.CreateWatchOnlyWalletRequest{
 		Name:             "Bad",
 		XpubOrDescriptor: "not-a-key",
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
@@ -65,9 +65,9 @@ func TestDeleteWalletCodes(t *testing.T) {
 	h, _, _, _, coreID := newRoutedHandler(t)
 	require.Equal(t, coreID, h.svc.StarterWalletID())
 
-	_, err := h.DeleteWallet(context.Background(), connect.NewRequest(&pb.DeleteWalletRequest{WalletId: "missing"}))
+	_, err := h.DeleteWallet(context.Background(), &pb.DeleteWalletRequest{WalletId: "missing"})
 	assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 
-	_, err = h.DeleteWallet(context.Background(), connect.NewRequest(&pb.DeleteWalletRequest{WalletId: coreID}))
+	_, err = h.DeleteWallet(context.Background(), &pb.DeleteWalletRequest{WalletId: coreID})
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 }
diff --git a/sidechain-orchestrator/api/get_download_status_test.go b/sidechain-orchestrator/api/get_download_status_test.go
index d2aa180311..792eb5b431 100644
--- a/sidechain-orchestrator/api/get_download_status_test.go
+++ b/sidechain-orchestrator/api/get_download_status_test.go
@@ -8,7 +8,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/stretchr/testify/require"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
@@ -36,9 +37,9 @@ func TestGetDownloadStatus_EmptyWhenNothingInFlight(t *testing.T) {
 	client, stop := startTestOrchService(t, orch)
 	defer stop()
 
-	resp, err := client.GetDownloadStatus(context.Background(), connect.NewRequest(&pb.GetDownloadStatusRequest{}))
+	resp, err := client.GetDownloadStatus(context.Background(), &pb.GetDownloadStatusRequest{})
 	require.NoError(t, err)
-	require.Empty(t, resp.Msg.Downloads)
+	require.Empty(t, resp.Downloads)
 }
 
 // TestGetDownloadStatus_ReportsInFlightDownload exercises the live path:
@@ -90,10 +91,10 @@ func TestGetDownloadStatus_ReportsInFlightDownload(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	_, err := client.DownloadBinary(ctx, connect.NewRequest(&pb.DownloadBinaryRequest{
+	_, err := client.DownloadBinary(ctx, &pb.DownloadBinaryRequest{
 		Name:  "streamtest",
 		Force: true,
-	}))
+	})
 	require.NoError(t, err)
 
 	// Spin until the manager records something running, then sample the RPC.
@@ -104,11 +105,11 @@ func TestGetDownloadStatus_ReportsInFlightDownload(t *testing.T) {
 
 	// streamtest isn't a known BinaryType in the proto enum, so the handler
 	// drops it from the response — exercise the empty-after-drop path.
-	resp, err := client.GetDownloadStatus(ctx, connect.NewRequest(&pb.GetDownloadStatusRequest{}))
+	resp, err := client.GetDownloadStatus(ctx, &pb.GetDownloadStatusRequest{})
 	require.NoError(t, err)
 	require.Empty(
 		t,
-		resp.Msg.Downloads,
+		resp.Downloads,
 		"unknown binary names must be dropped, not shipped as UNSPECIFIED",
 	)
 
@@ -157,10 +158,10 @@ func TestGetDownloadStatus_KnownBinaryReportsTypedEnum(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	_, err := client.DownloadBinary(ctx, connect.NewRequest(&pb.DownloadBinaryRequest{
+	_, err := client.DownloadBinary(ctx, &pb.DownloadBinaryRequest{
 		Name:  "thunder",
 		Force: true,
-	}))
+	})
 	require.NoError(t, err)
 
 	require.Eventually(t, func() bool {
@@ -168,10 +169,10 @@ func TestGetDownloadStatus_KnownBinaryReportsTypedEnum(t *testing.T) {
 		return running
 	}, eventuallyTimeout, eventuallyPoll, "download never registered as running")
 
-	resp, err := client.GetDownloadStatus(ctx, connect.NewRequest(&pb.GetDownloadStatusRequest{}))
+	resp, err := client.GetDownloadStatus(ctx, &pb.GetDownloadStatusRequest{})
 	require.NoError(t, err)
-	require.Len(t, resp.Msg.Downloads, 1)
-	require.Equal(t, pb.BinaryType_BINARY_TYPE_THUNDER, resp.Msg.Downloads[0].Binary)
+	require.Len(t, resp.Downloads, 1)
+	require.Equal(t, pb.BinaryType_BINARY_TYPE_THUNDER, resp.Downloads[0].Binary)
 
 	releaseOnce.Do(func() { close(hold) })
 	waitForDownloadEnd(t, orch, "thunder")
@@ -193,9 +194,10 @@ func waitForDownloadEnd(t *testing.T, orch *orchestrator.Orchestrator, name stri
 func startTestOrchService(t *testing.T, orch *orchestrator.Orchestrator) (rpc.OrchestratorServiceClient, func()) {
 	t.Helper()
 	mux := http.NewServeMux()
-	path, h := rpc.NewOrchestratorServiceHandler(NewHandler(orch))
-	mux.Handle(path, h)
+	rpcServer := connect.NewServer()
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, NewHandler(orch))
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 	srv := h2cServer(mux)
-	client := rpc.NewOrchestratorServiceClient(h2cClient(), srv.URL, connect.WithGRPC())
+	client := rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(h2cClient(), srv.URL, connecthttp.WithReadMaxBytes(0), connecthttp.WithGRPC())))
 	return client, srv.Close
 }
diff --git a/sidechain-orchestrator/api/hardware_handler.go b/sidechain-orchestrator/api/hardware_handler.go
index f7281e754d..0f2e6b9fdb 100644
--- a/sidechain-orchestrator/api/hardware_handler.go
+++ b/sidechain-orchestrator/api/hardware_handler.go
@@ -3,7 +3,7 @@ package api
 import (
 	"context"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
@@ -11,7 +11,7 @@ import (
 
 func (h *WalletHandler) hwiRunner() (*wallet.HWIRunner, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 	return wallet.NewHWIRunner(h.engine.Network()), nil
 }
@@ -25,13 +25,13 @@ func hwiSelector(d *pb.HardwareDeviceSelector) wallet.HardwareSelector {
 
 func (h *WalletHandler) EnumerateHardwareDevices(
 	ctx context.Context,
-	req *connect.Request[pb.EnumerateHardwareDevicesRequest],
-) (*connect.Response[pb.EnumerateHardwareDevicesResponse], error) {
+	req *pb.EnumerateHardwareDevicesRequest,
+) (*pb.EnumerateHardwareDevicesResponse, error) {
 	runner, err := h.hwiRunner()
 	if err != nil {
 		return nil, err
 	}
-	devices, err := runner.Enumerate(ctx, req.Msg.Passphrase)
+	devices, err := runner.Enumerate(ctx, req.Passphrase)
 	if err != nil {
 		return nil, rpcError(err)
 	}
@@ -49,89 +49,89 @@ func (h *WalletHandler) EnumerateHardwareDevices(
 			ErrorCode:       int32(d.Code),
 		})
 	}
-	return connect.NewResponse(&pb.EnumerateHardwareDevicesResponse{Devices: out}), nil
+	return &pb.EnumerateHardwareDevicesResponse{Devices: out}, nil
 }
 
 func (h *WalletHandler) GetHardwareXpub(
 	ctx context.Context,
-	req *connect.Request[pb.GetHardwareXpubRequest],
-) (*connect.Response[pb.GetHardwareXpubResponse], error) {
+	req *pb.GetHardwareXpubRequest,
+) (*pb.GetHardwareXpubResponse, error) {
 	runner, err := h.hwiRunner()
 	if err != nil {
 		return nil, err
 	}
-	xpub, err := runner.GetXpub(ctx, hwiSelector(req.Msg.Device), req.Msg.DerivationPath)
+	xpub, err := runner.GetXpub(ctx, hwiSelector(req.Device), req.DerivationPath)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.GetHardwareXpubResponse{Xpub: xpub}), nil
+	return &pb.GetHardwareXpubResponse{Xpub: xpub}, nil
 }
 
 func (h *WalletHandler) SignPsbtWithDevice(
 	ctx context.Context,
-	req *connect.Request[pb.SignPsbtWithDeviceRequest],
-) (*connect.Response[pb.SignPsbtWithDeviceResponse], error) {
+	req *pb.SignPsbtWithDeviceRequest,
+) (*pb.SignPsbtWithDeviceResponse, error) {
 	runner, err := h.hwiRunner()
 	if err != nil {
 		return nil, err
 	}
-	signed, err := runner.SignPSBT(ctx, hwiSelector(req.Msg.Device), req.Msg.PsbtBase64)
+	signed, err := runner.SignPSBT(ctx, hwiSelector(req.Device), req.PsbtBase64)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.SignPsbtWithDeviceResponse{PsbtBase64: signed}), nil
+	return &pb.SignPsbtWithDeviceResponse{PsbtBase64: signed}, nil
 }
 
 func (h *WalletHandler) PromptDevicePin(
 	ctx context.Context,
-	req *connect.Request[pb.PromptDevicePinRequest],
-) (*connect.Response[pb.PromptDevicePinResponse], error) {
+	req *pb.PromptDevicePinRequest,
+) (*pb.PromptDevicePinResponse, error) {
 	runner, err := h.hwiRunner()
 	if err != nil {
 		return nil, err
 	}
-	if err := runner.PromptPin(ctx, hwiSelector(req.Msg.Device)); err != nil {
+	if err := runner.PromptPin(ctx, hwiSelector(req.Device)); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.PromptDevicePinResponse{}), nil
+	return &pb.PromptDevicePinResponse{}, nil
 }
 
 func (h *WalletHandler) SendDevicePin(
 	ctx context.Context,
-	req *connect.Request[pb.SendDevicePinRequest],
-) (*connect.Response[pb.SendDevicePinResponse], error) {
+	req *pb.SendDevicePinRequest,
+) (*pb.SendDevicePinResponse, error) {
 	runner, err := h.hwiRunner()
 	if err != nil {
 		return nil, err
 	}
-	if err := runner.SendPin(ctx, hwiSelector(req.Msg.Device), req.Msg.Pin); err != nil {
+	if err := runner.SendPin(ctx, hwiSelector(req.Device), req.Pin); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.SendDevicePinResponse{}), nil
+	return &pb.SendDevicePinResponse{}, nil
 }
 
 func (h *WalletHandler) CloseDevice(
 	ctx context.Context,
-	req *connect.Request[pb.CloseDeviceRequest],
-) (*connect.Response[pb.CloseDeviceResponse], error) {
+	req *pb.CloseDeviceRequest,
+) (*pb.CloseDeviceResponse, error) {
 	runner, err := h.hwiRunner()
 	if err != nil {
 		return nil, err
 	}
-	if err := runner.Close(ctx, hwiSelector(req.Msg.Device)); err != nil {
+	if err := runner.Close(ctx, hwiSelector(req.Device)); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.CloseDeviceResponse{}), nil
+	return &pb.CloseDeviceResponse{}, nil
 }
 
 func (h *WalletHandler) DeriveKeystore(
 	ctx context.Context,
-	req *connect.Request[pb.DeriveKeystoreRequest],
-) (*connect.Response[pb.DeriveKeystoreResponse], error) {
+	req *pb.DeriveKeystoreRequest,
+) (*pb.DeriveKeystoreResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	msg := req.Msg
+	msg := req
 	src := wallet.KeystoreSource{Mnemonic: msg.Mnemonic, Passphrase: msg.Passphrase, RawKey: msg.RawKey}
 	if msg.Device != nil {
 		sel := hwiSelector(msg.Device)
@@ -141,10 +141,10 @@ func (h *WalletHandler) DeriveKeystore(
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.DeriveKeystoreResponse{
+	return &pb.DeriveKeystoreResponse{
 		Xpub:        out.Xpub,
 		Fingerprint: out.Fingerprint,
 		OriginPath:  out.OriginPath,
 		Descriptor_: out.Descriptor,
-	}), nil
+	}, nil
 }
diff --git a/sidechain-orchestrator/api/multisiglounge_handler.go b/sidechain-orchestrator/api/multisiglounge_handler.go
index 1965ae16b3..ea709236b8 100644
--- a/sidechain-orchestrator/api/multisiglounge_handler.go
+++ b/sidechain-orchestrator/api/multisiglounge_handler.go
@@ -10,7 +10,7 @@ import (
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/multisiglounge/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/multisiglounge/v1/multisigloungev1connect"
@@ -106,42 +106,42 @@ func protoToLoungeGroup(g *pb.MultisigGroup) wallet.MultisigLoungeGroup {
 
 func (h *MultisigLoungeHandler) BuildDescriptors(
 	ctx context.Context,
-	req *connect.Request[pb.BuildDescriptorsRequest],
-) (*connect.Response[pb.BuildDescriptorsResponse], error) {
-	group := req.Msg.GetGroup()
+	req *pb.BuildDescriptorsRequest,
+) (*pb.BuildDescriptorsResponse, error) {
+	group := req.GetGroup()
 	if group == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup)
+		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup.Error()).WithCause(errMissingGroup)
 	}
-	receive, change, err := wallet.BuildMultisigLoungeDescriptorsTyped(protoToLoungeGroup(group), req.Msg.GetScriptType())
+	receive, change, err := wallet.BuildMultisigLoungeDescriptorsTyped(protoToLoungeGroup(group), req.GetScriptType())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.BuildDescriptorsResponse{
+	return &pb.BuildDescriptorsResponse{
 		ReceiveDescriptor: receive,
 		ChangeDescriptor:  change,
-	}), nil
+	}, nil
 }
 
 func (h *MultisigLoungeHandler) ValidatePsbt(
 	ctx context.Context,
-	req *connect.Request[pb.ValidatePsbtRequest],
-) (*connect.Response[pb.ValidatePsbtResponse], error) {
+	req *pb.ValidatePsbtRequest,
+) (*pb.ValidatePsbtResponse, error) {
 	var group *wallet.MultisigLoungeGroup
-	if g := req.Msg.GetGroup(); g != nil {
+	if g := req.GetGroup(); g != nil {
 		lg := protoToLoungeGroup(g)
 		group = &lg
 	}
 
-	res, err := wallet.ValidateMultisigPsbt(req.Msg.GetPsbtBase64(), int(req.Msg.GetRequiredSigs()), group)
+	res, err := wallet.ValidateMultisigPsbt(req.GetPsbtBase64(), int(req.GetRequiredSigs()), group)
 	if err != nil {
-		return connect.NewResponse(&pb.ValidatePsbtResponse{Error: err.Error()}), nil
+		return &pb.ValidatePsbtResponse{Error: err.Error()}, nil
 	}
-	return connect.NewResponse(&pb.ValidatePsbtResponse{
+	return &pb.ValidatePsbtResponse{
 		HasSignatures:  res.HasSignatures,
 		SignatureCount: uint32(res.SignatureCount),
 		IsComplete:     res.IsComplete,
 		Finalizable:    res.Finalizable,
-	}), nil
+	}, nil
 }
 
 func optStr(s string) *string {
@@ -215,32 +215,32 @@ func groupDataToProto(g wallet.MultisigGroupData) *pb.GroupData {
 
 func (h *MultisigLoungeHandler) PublishGroup(
 	ctx context.Context,
-	req *connect.Request[pb.PublishGroupRequest],
-) (*connect.Response[pb.PublishGroupResponse], error) {
-	group := req.Msg.GetGroup()
+	req *pb.PublishGroupRequest,
+) (*pb.PublishGroupResponse, error) {
+	group := req.GetGroup()
 	if group == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup)
+		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup.Error()).WithCause(errMissingGroup)
 	}
-	if req.Msg.GetWalletId() == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("wallet_id is required"))
+	if req.GetWalletId() == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "wallet_id is required")
 	}
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.GetWalletId())
+	walletID, err := h.engine.ResolveWalletID(req.GetWalletId())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	message, err := wallet.EncodeGroupOpReturn(protoToGroupData(group), uint32(time.Now().Unix()))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("encode group op_return: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("encode group op_return: %w", err).Error())
 	}
 
 	derived, err := h.engine.Backend().NextReceiveAddress(ctx, walletID, wallet.ScriptNativeSegwit)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get receive address: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("get receive address: %w", err).Error())
 	}
 
 	txid, err := h.engine.Backend().Send(ctx, walletID, wallet.SendRequest{
@@ -251,46 +251,46 @@ func (h *MultisigLoungeHandler) PublishGroup(
 		return nil, rpcError(err)
 	}
 
-	return connect.NewResponse(&pb.PublishGroupResponse{Txid: txid}), nil
+	return &pb.PublishGroupResponse{Txid: txid}, nil
 }
 
 func (h *MultisigLoungeHandler) ImportGroupFromTxid(
 	ctx context.Context,
-	req *connect.Request[pb.ImportGroupFromTxidRequest],
-) (*connect.Response[pb.ImportGroupFromTxidResponse], error) {
-	if req.Msg.GetTxid() == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("txid is required"))
+	req *pb.ImportGroupFromTxidRequest,
+) (*pb.ImportGroupFromTxidResponse, error) {
+	if req.GetTxid() == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "txid is required")
 	}
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.GetWalletId())
+	walletID, err := h.engine.ResolveWalletID(req.GetWalletId())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	rawTx, err := h.engine.ChainForWallet(walletID).GetRawTransaction(ctx, req.Msg.GetTxid())
+	rawTx, err := h.engine.ChainForWallet(walletID).GetRawTransaction(ctx, req.GetTxid())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("getrawtransaction: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("getrawtransaction: %w", err).Error())
 	}
 
 	message, err := wallet.ExtractOpReturnMessage(rawTx.Vout)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	}
 
 	groupData, err := wallet.DecodeGroupOpReturn(message)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	indices := h.detectWalletKeys(walletID, groupData)
 
-	return connect.NewResponse(&pb.ImportGroupFromTxidResponse{
+	return &pb.ImportGroupFromTxidResponse{
 		Group:            groupDataToProto(groupData),
 		WalletKeyIndices: indices,
-	}), nil
+	}, nil
 }
 
 // detectWalletKeys returns the indices of group keys whose xpub the wallet can
@@ -363,36 +363,36 @@ func (h *MultisigLoungeHandler) coreCallWallet(ctx context.Context, wallet, meth
 
 func (h *MultisigLoungeHandler) SignTransaction(
 	ctx context.Context,
-	req *connect.Request[pb.SignTransactionRequest],
-) (*connect.Response[pb.SignTransactionResponse], error) {
-	group := req.Msg.GetGroup()
+	req *pb.SignTransactionRequest,
+) (*pb.SignTransactionResponse, error) {
+	group := req.GetGroup()
 	if group == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup)
+		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup.Error()).WithCause(errMissingGroup)
 	}
-	if req.Msg.GetPsbtBase64() == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("psbt_base64 is required"))
+	if req.GetPsbtBase64() == "" {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "psbt_base64 is required")
 	}
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 	if err := h.requireCoreCaller(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.GetWalletId())
+	walletID, err := h.engine.ResolveWalletID(req.GetWalletId())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	seedHex := h.walletSeedHex(walletID)
 	if seedHex == "" {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet has no seed; cannot sign"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "wallet has no seed; cannot sign")
 	}
 
 	loungeGroup := groupDataToLoungeGroup(group)
 
 	// Reject a PSBT that does not belong to this group before signing it.
-	if _, err := wallet.ValidateMultisigPsbt(req.Msg.GetPsbtBase64(), int(group.GetM()), &loungeGroup); err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("psbt does not match group: %w", err))
+	if _, err := wallet.ValidateMultisigPsbt(req.GetPsbtBase64(), int(group.GetM()), &loungeGroup); err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("psbt does not match group: %w", err).Error())
 	}
 
 	// Derive the wallet's xprv for every group key the wallet owns, keyed by xpub
@@ -412,15 +412,15 @@ func (h *MultisigLoungeHandler) SignTransaction(
 		}
 	}
 	if len(signWithXprv) == 0 {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet owns none of the group's keys; cannot sign"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "wallet owns none of the group's keys; cannot sign")
 	}
 
 	receiveDesc, changeDesc, err := wallet.BuildMultisigSigningDescriptors(loungeGroup, signWithXprv)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("build signing descriptors: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("build signing descriptors: %w", err).Error())
 	}
 
-	before := countPsbtSignatures(req.Msg.GetPsbtBase64())
+	before := countPsbtSignatures(req.GetPsbtBase64())
 
 	// descriptorprocesspsbt(psbt, descriptors, sighashtype, bip32derivs, finalize=false)
 	var res struct {
@@ -428,16 +428,16 @@ func (h *MultisigLoungeHandler) SignTransaction(
 		Complete bool   `json:"complete"`
 	}
 	if err := h.coreCall(ctx, "descriptorprocesspsbt", []interface{}{
-		req.Msg.GetPsbtBase64(),
+		req.GetPsbtBase64(),
 		[]string{receiveDesc, changeDesc},
 		"ALL",
 		true,
 		false,
 	}, &res); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("descriptorprocesspsbt: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("descriptorprocesspsbt: %w", err).Error())
 	}
 	if res.PSBT == "" {
-		return nil, connect.NewError(connect.CodeInternal, errors.New("descriptorprocesspsbt returned an empty psbt"))
+		return nil, connect.NewError(connect.CodeInternal, "descriptorprocesspsbt returned an empty psbt")
 	}
 
 	added := countPsbtSignatures(res.PSBT) - before
@@ -445,32 +445,32 @@ func (h *MultisigLoungeHandler) SignTransaction(
 		added = 0
 	}
 
-	return connect.NewResponse(&pb.SignTransactionResponse{
+	return &pb.SignTransactionResponse{
 		PsbtBase64:      res.PSBT,
 		AddedSignatures: uint32(added),
 		IsComplete:      res.Complete,
-	}), nil
+	}, nil
 }
 
 func (h *MultisigLoungeHandler) CombineAndBroadcast(
 	ctx context.Context,
-	req *connect.Request[pb.CombineAndBroadcastRequest],
-) (*connect.Response[pb.CombineAndBroadcastResponse], error) {
-	psbts := req.Msg.GetPsbts()
+	req *pb.CombineAndBroadcastRequest,
+) (*pb.CombineAndBroadcastResponse, error) {
+	psbts := req.GetPsbts()
 	if len(psbts) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("no psbts provided"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "no psbts provided")
 	}
 	if err := h.requireCoreCaller(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	// Reject any PSBT that does not belong to the group before combining, so a
 	// foreign/stale PSBT can't poison the combined transaction.
-	if group := req.Msg.GetGroup(); group != nil {
+	if group := req.GetGroup(); group != nil {
 		loungeGroup := groupDataToLoungeGroup(group)
 		for i, p := range psbts {
 			if _, err := wallet.ValidateMultisigPsbt(p, int(group.GetM()), &loungeGroup); err != nil {
-				return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("psbt %d does not match group: %w", i, err))
+				return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("psbt %d does not match group: %w", i, err).Error())
 			}
 		}
 	}
@@ -482,7 +482,7 @@ func (h *MultisigLoungeHandler) CombineAndBroadcast(
 		unique := dedupeStrings(psbts)
 		if len(unique) > 1 {
 			if err := h.coreCall(ctx, "combinepsbt", []interface{}{unique}, &combined); err != nil {
-				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("combinepsbt: %w", err))
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("combinepsbt: %w", err).Error())
 			}
 		} else {
 			combined = unique[0]
@@ -494,19 +494,19 @@ func (h *MultisigLoungeHandler) CombineAndBroadcast(
 		Complete bool   `json:"complete"`
 	}
 	if err := h.coreCall(ctx, "finalizepsbt", []interface{}{combined}, &fin); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("finalizepsbt: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("finalizepsbt: %w", err).Error())
 	}
 	if !fin.Complete || fin.Hex == "" {
 		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			errors.New("psbt is not finalizable (threshold of signatures not reached); not broadcasting"))
+			"psbt is not finalizable (threshold of signatures not reached); not broadcasting")
 	}
 
 	var txid string
 	if err := h.coreCall(ctx, "sendrawtransaction", []interface{}{fin.Hex}, &txid); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("sendrawtransaction: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("sendrawtransaction: %w", err).Error())
 	}
 
-	return connect.NewResponse(&pb.CombineAndBroadcastResponse{Txid: txid}), nil
+	return &pb.CombineAndBroadcastResponse{Txid: txid}, nil
 }
 
 // watchWalletName returns the group's watch-only wallet name, defaulting to the
@@ -653,19 +653,19 @@ func (h *MultisigLoungeHandler) ensureWatchWallet(ctx context.Context, g *pb.Gro
 
 func (h *MultisigLoungeHandler) SyncGroup(
 	ctx context.Context,
-	req *connect.Request[pb.SyncGroupRequest],
-) (*connect.Response[pb.SyncGroupResponse], error) {
-	group := req.Msg.GetGroup()
+	req *pb.SyncGroupRequest,
+) (*pb.SyncGroupResponse, error) {
+	group := req.GetGroup()
 	if group == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup)
+		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup.Error()).WithCause(errMissingGroup)
 	}
 	if err := h.requireCoreCaller(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	name, err := h.ensureWatchWallet(ctx, group)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	// getbalances reports confirmed (trusted) and pending (untrusted_pending)
@@ -681,7 +681,7 @@ func (h *MultisigLoungeHandler) SyncGroup(
 		} `json:"watchonly"`
 	}
 	if err := h.coreCallWallet(ctx, name, "getbalances", nil, &balances); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("getbalances: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("getbalances: %w", err).Error())
 	}
 	confirmed := balances.Mine.Trusted + balances.Watchonly.Trusted
 	pending := balances.Mine.UntrustedPending + balances.Watchonly.UntrustedPending
@@ -700,7 +700,7 @@ func (h *MultisigLoungeHandler) SyncGroup(
 	// listunspent(minconf=0, maxconf=9999999, [], include_unsafe=true)
 	if err := h.coreCallWallet(ctx, name, "listunspent",
 		[]interface{}{0, 9999999, []string{}, true}, &utxos); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("listunspent: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("listunspent: %w", err).Error())
 	}
 
 	pbUtxos := make([]*pb.MultisigUtxo, 0, len(utxos))
@@ -718,29 +718,29 @@ func (h *MultisigLoungeHandler) SyncGroup(
 		})
 	}
 
-	return connect.NewResponse(&pb.SyncGroupResponse{
+	return &pb.SyncGroupResponse{
 		ConfirmedSats: btcToSatsInt(confirmed),
 		PendingSats:   btcToSatsInt(pending),
 		UtxoCount:     uint32(len(utxos)),
 		Utxos:         pbUtxos,
-	}), nil
+	}, nil
 }
 
 func (h *MultisigLoungeHandler) RestoreHistory(
 	ctx context.Context,
-	req *connect.Request[pb.RestoreHistoryRequest],
-) (*connect.Response[pb.RestoreHistoryResponse], error) {
-	group := req.Msg.GetGroup()
+	req *pb.RestoreHistoryRequest,
+) (*pb.RestoreHistoryResponse, error) {
+	group := req.GetGroup()
 	if group == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup)
+		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup.Error()).WithCause(errMissingGroup)
 	}
 	if err := h.requireCoreCaller(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	name, err := h.ensureWatchWallet(ctx, group)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	// listtransactions("*", 1000, 0, include_watchonly=true)
@@ -754,7 +754,7 @@ func (h *MultisigLoungeHandler) RestoreHistory(
 	}
 	if err := h.coreCallWallet(ctx, name, "listtransactions",
 		[]interface{}{"*", 1000, 0, true}, &txs); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("listtransactions: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("listtransactions: %w", err).Error())
 	}
 
 	seen := map[string]bool{}
@@ -830,35 +830,35 @@ func (h *MultisigLoungeHandler) RestoreHistory(
 		})
 	}
 
-	return connect.NewResponse(&pb.RestoreHistoryResponse{Transactions: out}), nil
+	return &pb.RestoreHistoryResponse{Transactions: out}, nil
 }
 
 func (h *MultisigLoungeHandler) CreateSpendPsbt(
 	ctx context.Context,
-	req *connect.Request[pb.CreateSpendPsbtRequest],
-) (*connect.Response[pb.CreateSpendPsbtResponse], error) {
-	group := req.Msg.GetGroup()
+	req *pb.CreateSpendPsbtRequest,
+) (*pb.CreateSpendPsbtResponse, error) {
+	group := req.GetGroup()
 	if group == nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup)
+		return nil, connect.NewError(connect.CodeInvalidArgument, errMissingGroup.Error()).WithCause(errMissingGroup)
 	}
-	if len(req.Msg.GetDestinations()) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("at least one destination is required"))
+	if len(req.GetDestinations()) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "at least one destination is required")
 	}
 	if err := h.requireCoreCaller(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	name, err := h.ensureWatchWallet(ctx, group)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	// Destinations as {address: btc}, mirroring the Dart walletcreatefundedpsbt
 	// call which passes BTC amounts.
-	outputs := make(map[string]float64, len(req.Msg.GetDestinations()))
-	for _, d := range req.Msg.GetDestinations() {
+	outputs := make(map[string]float64, len(req.GetDestinations()))
+	for _, d := range req.GetDestinations() {
 		if d.GetAddress() == "" || d.GetSats() <= 0 {
-			return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("each destination needs an address and a positive sats amount"))
+			return nil, connect.NewError(connect.CodeInvalidArgument, "each destination needs an address and a positive sats amount")
 		}
 		outputs[d.GetAddress()] = float64(d.GetSats()) / 1e8
 	}
@@ -869,7 +869,7 @@ func (h *MultisigLoungeHandler) CreateSpendPsbt(
 		"includeWatching": true,
 		"changePosition":  1,
 	}
-	if rate := req.Msg.GetFeeRateSatVb(); rate > 0 {
+	if rate := req.GetFeeRateSatVb(); rate > 0 {
 		options["fee_rate"] = rate
 	}
 
@@ -880,16 +880,16 @@ func (h *MultisigLoungeHandler) CreateSpendPsbt(
 	// walletcreatefundedpsbt([], outputs, 0, options)
 	if err := h.coreCallWallet(ctx, name, "walletcreatefundedpsbt",
 		[]interface{}{[]interface{}{}, outputs, 0, options}, &res); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("walletcreatefundedpsbt: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("walletcreatefundedpsbt: %w", err).Error())
 	}
 	if res.PSBT == "" {
-		return nil, connect.NewError(connect.CodeInternal, errors.New("walletcreatefundedpsbt returned an empty psbt"))
+		return nil, connect.NewError(connect.CodeInternal, "walletcreatefundedpsbt returned an empty psbt")
 	}
 
-	return connect.NewResponse(&pb.CreateSpendPsbtResponse{
+	return &pb.CreateSpendPsbtResponse{
 		PsbtBase64: res.PSBT,
 		FeeSats:    btcToSatsInt(res.Fee),
-	}), nil
+	}, nil
 }
 
 func btcToSatsInt(btc float64) int64 {
diff --git a/sidechain-orchestrator/api/multisiglounge_sync_test.go b/sidechain-orchestrator/api/multisiglounge_sync_test.go
index a6e75a58d4..f40fec1bf5 100644
--- a/sidechain-orchestrator/api/multisiglounge_sync_test.go
+++ b/sidechain-orchestrator/api/multisiglounge_sync_test.go
@@ -12,7 +12,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -216,10 +215,10 @@ func TestSyncGroupBalanceE2E(t *testing.T) {
 	group := loungeSyncTestGroup(t)
 
 	// First SyncGroup creates the watch-only wallet from the Phase-1 descriptors.
-	resp, err := h.SyncGroup(context.Background(), connect.NewRequest(&pb.SyncGroupRequest{Group: group}))
+	resp, err := h.SyncGroup(context.Background(), &pb.SyncGroupRequest{Group: group})
 	require.NoError(t, err)
-	require.Equal(t, int64(0), resp.Msg.ConfirmedSats)
-	require.Equal(t, uint32(0), resp.Msg.UtxoCount)
+	require.Equal(t, int64(0), resp.ConfirmedSats)
+	require.Equal(t, uint32(0), resp.UtxoCount)
 
 	// Fund the multisig wallet.
 	rt.rpcInto(t, "", "createwallet", `["fund"]`, nil)
@@ -232,13 +231,13 @@ func TestSyncGroupBalanceE2E(t *testing.T) {
 	rt.rpcInto(t, "fund", "sendtoaddress", fmt.Sprintf(`[%q,"1.0"]`, msAddr), nil)
 	rt.rpcInto(t, "", "generatetoaddress", fmt.Sprintf(`[1,%q]`, fundAddr), nil)
 
-	resp, err = h.SyncGroup(context.Background(), connect.NewRequest(&pb.SyncGroupRequest{Group: group}))
+	resp, err = h.SyncGroup(context.Background(), &pb.SyncGroupRequest{Group: group})
 	require.NoError(t, err)
-	require.Equal(t, int64(100_000_000), resp.Msg.ConfirmedSats, "1 BTC confirmed")
-	require.Equal(t, uint32(1), resp.Msg.UtxoCount)
-	require.Len(t, resp.Msg.Utxos, 1)
-	require.Equal(t, int64(100_000_000), resp.Msg.Utxos[0].AmountSats)
-	require.Equal(t, msAddr, resp.Msg.Utxos[0].Address)
+	require.Equal(t, int64(100_000_000), resp.ConfirmedSats, "1 BTC confirmed")
+	require.Equal(t, uint32(1), resp.UtxoCount)
+	require.Len(t, resp.Utxos, 1)
+	require.Equal(t, int64(100_000_000), resp.Utxos[0].AmountSats)
+	require.Equal(t, msAddr, resp.Utxos[0].Address)
 }
 
 func TestRestoreHistoryE2E(t *testing.T) {
@@ -248,7 +247,7 @@ func TestRestoreHistoryE2E(t *testing.T) {
 	ctx := context.Background()
 
 	// Create + fund the watch-only wallet.
-	_, err := h.SyncGroup(ctx, connect.NewRequest(&pb.SyncGroupRequest{Group: group}))
+	_, err := h.SyncGroup(ctx, &pb.SyncGroupRequest{Group: group})
 	require.NoError(t, err)
 
 	rt.rpcInto(t, "", "createwallet", `["fund"]`, nil)
@@ -289,22 +288,22 @@ func TestRestoreHistoryE2E(t *testing.T) {
 	signedB := signOnce(3, funded.PSBT)
 
 	// Combine + broadcast via the handler.
-	cab, err := h.CombineAndBroadcast(ctx, connect.NewRequest(&pb.CombineAndBroadcastRequest{
+	cab, err := h.CombineAndBroadcast(ctx, &pb.CombineAndBroadcastRequest{
 		Psbts: []string{signedA, signedB},
 		Group: group,
-	}))
+	})
 	require.NoError(t, err)
-	spendTxid := cab.Msg.Txid
+	spendTxid := cab.Txid
 	require.Len(t, spendTxid, 64)
 
 	// Confirm to 6 blocks so the spend reconstructs as "confirmed".
 	rt.rpcInto(t, "", "generatetoaddress", fmt.Sprintf(`[6,%q]`, fundAddr), nil)
 
-	resp, err := h.RestoreHistory(ctx, connect.NewRequest(&pb.RestoreHistoryRequest{Group: group}))
+	resp, err := h.RestoreHistory(ctx, &pb.RestoreHistoryRequest{Group: group})
 	require.NoError(t, err)
 
 	var spend *pb.MultisigHistoryTx
-	for _, tx := range resp.Msg.Transactions {
+	for _, tx := range resp.Transactions {
 		if tx.Txid == spendTxid {
 			spend = tx
 		}
@@ -376,12 +375,12 @@ func TestRestoreHistoryNetsRowsPerTxid(t *testing.T) {
 				return nil, fmt.Errorf("unexpected method %s", method)
 			})
 
-			resp, err := h.RestoreHistory(context.Background(), connect.NewRequest(&pb.RestoreHistoryRequest{
+			resp, err := h.RestoreHistory(context.Background(), &pb.RestoreHistoryRequest{
 				Group: &pb.GroupData{Id: "restore", WatchWalletName: "ms_test"},
-			}))
+			})
 			require.NoError(t, err)
-			require.Len(t, resp.Msg.Transactions, 1)
-			tx := resp.Msg.Transactions[0]
+			require.Len(t, resp.Transactions, 1)
+			tx := resp.Transactions[0]
 			require.Equal(t, tt.isDeposit, tx.IsDeposit)
 			require.Equal(t, tt.amountSats, tx.AmountSats)
 			require.Equal(t, tt.destination, tx.Destination)
@@ -454,7 +453,7 @@ func TestCreateSpendPsbtE2E(t *testing.T) {
 	group := loungeSyncTestGroup(t)
 	ctx := context.Background()
 
-	_, err := h.SyncGroup(ctx, connect.NewRequest(&pb.SyncGroupRequest{Group: group}))
+	_, err := h.SyncGroup(ctx, &pb.SyncGroupRequest{Group: group})
 	require.NoError(t, err)
 
 	rt.rpcInto(t, "", "createwallet", `["fund"]`, nil)
@@ -469,13 +468,13 @@ func TestCreateSpendPsbtE2E(t *testing.T) {
 	var dest string
 	rt.rpcInto(t, "fund", "getnewaddress", "", &dest)
 
-	resp, err := h.CreateSpendPsbt(ctx, connect.NewRequest(&pb.CreateSpendPsbtRequest{
+	resp, err := h.CreateSpendPsbt(ctx, &pb.CreateSpendPsbtRequest{
 		Group:        group,
 		Destinations: []*pb.SpendDestination{{Address: dest, Sats: 50_000_000}},
-	}))
+	})
 	require.NoError(t, err)
-	require.NotEmpty(t, resp.Msg.PsbtBase64)
-	require.Positive(t, resp.Msg.FeeSats)
+	require.NotEmpty(t, resp.PsbtBase64)
+	require.Positive(t, resp.FeeSats)
 
 	// The returned PSBT decodes, draws inputs from the watch wallet, and pays the
 	// destination.
@@ -490,7 +489,7 @@ func TestCreateSpendPsbtE2E(t *testing.T) {
 			} `json:"vout"`
 		} `json:"tx"`
 	}
-	rt.rpcInto(t, "", "decodepsbt", fmt.Sprintf(`[%q]`, resp.Msg.PsbtBase64), &decoded)
+	rt.rpcInto(t, "", "decodepsbt", fmt.Sprintf(`[%q]`, resp.PsbtBase64), &decoded)
 	require.NotEmpty(t, decoded.Tx.Vin, "PSBT must spend wallet inputs")
 	var paysDest bool
 	for _, o := range decoded.Tx.Vout {
@@ -517,10 +516,10 @@ func TestCreateSpendPsbtE2E(t *testing.T) {
 		rt.rpcInto(t, "", "descriptorprocesspsbt", fmt.Sprintf(`[%q,%s,"ALL",true,false]`, base, string(descs)), &r)
 		return r.PSBT
 	}
-	cab, err := h.CombineAndBroadcast(ctx, connect.NewRequest(&pb.CombineAndBroadcastRequest{
-		Psbts: []string{signOnce(2, resp.Msg.PsbtBase64), signOnce(3, resp.Msg.PsbtBase64)},
+	cab, err := h.CombineAndBroadcast(ctx, &pb.CombineAndBroadcastRequest{
+		Psbts: []string{signOnce(2, resp.PsbtBase64), signOnce(3, resp.PsbtBase64)},
 		Group: group,
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, cab.Msg.Txid, 64, "the CreateSpendPsbt output must sign+combine+broadcast end to end")
+	require.Len(t, cab.Txid, 64, "the CreateSpendPsbt output must sign+combine+broadcast end to end")
 }
diff --git a/sidechain-orchestrator/api/network_change_plan.go b/sidechain-orchestrator/api/network_change_plan.go
index cf6f2d800c..3f0db1ddcf 100644
--- a/sidechain-orchestrator/api/network_change_plan.go
+++ b/sidechain-orchestrator/api/network_change_plan.go
@@ -1,9 +1,8 @@
 package api
 
 import (
-	"fmt"
-
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connectproto"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
@@ -50,12 +49,12 @@ func networkChangePlanToProto(p orchestrator.NetworkChangePlan) *pb.NetworkChang
 // requirementsUnmet refuses a change the user has not resolved, carrying the
 // plan as a detail so the frontend reads fields instead of parsing a string.
 func requirementsUnmet(p orchestrator.NetworkChangePlan) *connect.Error {
-	err := connect.NewError(
+	err := connect.Errorf(
 		connect.CodeFailedPrecondition,
-		fmt.Errorf("datadir not configured for %s", p.Network),
+		"datadir not configured for %s", p.Network,
 	)
-	if detail, derr := connect.NewErrorDetail(networkChangePlanToProto(p)); derr == nil {
-		err.AddDetail(detail)
+	if detail, derr := connectproto.NewErrorDetail(networkChangePlanToProto(p)); derr == nil {
+		err = err.WithDetail(detail)
 	}
 	return err
 }
diff --git a/sidechain-orchestrator/api/node_mode.go b/sidechain-orchestrator/api/node_mode.go
index deb8e2e6bb..d269f28e57 100644
--- a/sidechain-orchestrator/api/node_mode.go
+++ b/sidechain-orchestrator/api/node_mode.go
@@ -2,9 +2,8 @@ package api
 
 import (
 	"context"
-	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
@@ -44,39 +43,39 @@ func (h *WalletHandler) currentNetwork() config.Network {
 // GetNodeMode reports the mode the user picked. UNSPECIFIED means they never
 // picked, so the frontend must ask before it boots anything.
 func (h *WalletHandler) GetNodeMode(
-	ctx context.Context, req *connect.Request[pb.GetNodeModeRequest],
-) (*connect.Response[pb.GetNodeModeResponse], error) {
+	ctx context.Context, req *pb.GetNodeModeRequest,
+) (*pb.GetNodeModeResponse, error) {
 	if h.orch == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not wired")
 	}
 	network := h.currentNetwork()
 	mode := orchestrator.NodeModeForNetwork(orchestrator.ReadNodeMode(h.orch.BitwindowDir), network)
-	return connect.NewResponse(&pb.GetNodeModeResponse{
+	return &pb.GetNodeModeResponse{
 		Mode:                    nodeModeToProto(mode),
 		LightModeAvailable:      config.SupportsLightMode(network),
 		RemoteEnforcerAvailable: config.RemoteEnforcerURLForNetwork(network) != "",
 		RemoteEnforcerNetworks:  config.RemoteEnforcerNetworks(),
-	}), nil
+	}, nil
 }
 
 // SetNodeMode changes the mode and restarts active sidechains.
 func (h *WalletHandler) SetNodeMode(
-	ctx context.Context, req *connect.Request[pb.SetNodeModeRequest],
-) (*connect.Response[pb.SetNodeModeResponse], error) {
+	ctx context.Context, req *pb.SetNodeModeRequest,
+) (*pb.SetNodeModeResponse, error) {
 	if h.orch == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not wired"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not wired")
 	}
-	mode := nodeModeFromProto(req.Msg.Mode)
+	mode := nodeModeFromProto(req.Mode)
 	if mode == orchestrator.NodeModeUnset {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("pick full or light"))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "pick full or light")
 	}
 	network := h.currentNetwork()
 	if mode == orchestrator.NodeModeLight && !config.SupportsLightMode(network) {
-		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("%s has no remote enforcer or Bitcoin wallet server", network))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
+			"%s has no remote enforcer or Bitcoin wallet server", network)
 	}
 	if err := h.orch.SetNodeMode(ctx, mode); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.SetNodeModeResponse{}), nil
+	return &pb.SetNodeModeResponse{}, nil
 }
diff --git a/sidechain-orchestrator/api/node_mode_test.go b/sidechain-orchestrator/api/node_mode_test.go
index c871bb2b04..75d3c12371 100644
--- a/sidechain-orchestrator/api/node_mode_test.go
+++ b/sidechain-orchestrator/api/node_mode_test.go
@@ -5,7 +5,6 @@ import (
 	"io"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
 
@@ -21,12 +20,12 @@ func TestBitcoinLightModeWithoutRemoteEnforcer(t *testing.T) {
 			require.NoError(t, orchestrator.WriteNodeMode(orch.BitwindowDir, orchestrator.NodeModeLight))
 			handler := &WalletHandler{orch: orch}
 
-			response, err := handler.GetNodeMode(context.Background(), connect.NewRequest(&pb.GetNodeModeRequest{}))
+			response, err := handler.GetNodeMode(context.Background(), &pb.GetNodeModeRequest{})
 
 			require.NoError(t, err)
-			require.Equal(t, pb.NodeMode_NODE_MODE_LIGHT, response.Msg.Mode)
-			require.True(t, response.Msg.LightModeAvailable)
-			require.False(t, response.Msg.RemoteEnforcerAvailable)
+			require.Equal(t, pb.NodeMode_NODE_MODE_LIGHT, response.Mode)
+			require.True(t, response.LightModeAvailable)
+			require.False(t, response.RemoteEnforcerAvailable)
 		})
 	}
 }
@@ -43,9 +42,9 @@ func TestNodeModeUsesThePublishedRemoteEnforcer(t *testing.T) {
 		entry.Services.Enforcer.URL = endpoint
 		config.SetNetworkEndpoints(network, entry)
 
-		response, err := handler.GetNodeMode(context.Background(), connect.NewRequest(&pb.GetNodeModeRequest{}))
+		response, err := handler.GetNodeMode(context.Background(), &pb.GetNodeModeRequest{})
 
 		require.NoError(t, err)
-		require.Equal(t, endpoint != "", response.Msg.RemoteEnforcerAvailable)
+		require.Equal(t, endpoint != "", response.RemoteEnforcerAvailable)
 	}
 }
diff --git a/sidechain-orchestrator/api/orchestrator_handler.go b/sidechain-orchestrator/api/orchestrator_handler.go
index 8f8b3cf0d4..047dc44c78 100644
--- a/sidechain-orchestrator/api/orchestrator_handler.go
+++ b/sidechain-orchestrator/api/orchestrator_handler.go
@@ -4,14 +4,13 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/samber/lo"
 
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
@@ -48,48 +47,48 @@ func (h *Handler) SetSidechainBalance(name string, read SidechainBalanceFunc) {
 	h.sidechainBalances[name] = read
 }
 
-func (h *Handler) ListBinaries(ctx context.Context, req *connect.Request[pb.ListBinariesRequest]) (*connect.Response[pb.ListBinariesResponse], error) {
-	opts := orchestrator.DownloadOptions{ForceBackend: req.Msg.ForceBackend}
+func (h *Handler) ListBinaries(ctx context.Context, req *pb.ListBinariesRequest) (*pb.ListBinariesResponse, error) {
+	opts := orchestrator.DownloadOptions{ForceBackend: req.ForceBackend}
 	pbStatuses := lo.Map(h.orch.ListAllWithOptions(opts), func(s orchestrator.BinaryStatus, _ int) *pb.BinaryStatusMsg {
 		return statusToProto(s)
 	})
-	return connect.NewResponse(&pb.ListBinariesResponse{
+	return &pb.ListBinariesResponse{
 		Binaries: pbStatuses,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBinaryStatus(ctx context.Context, req *connect.Request[pb.GetBinaryStatusRequest]) (*connect.Response[pb.GetBinaryStatusResponse], error) {
-	s := h.orch.StatusWithOptions(req.Msg.Name, orchestrator.DownloadOptions{ForceBackend: req.Msg.ForceBackend})
-	return connect.NewResponse(&pb.GetBinaryStatusResponse{
+func (h *Handler) GetBinaryStatus(ctx context.Context, req *pb.GetBinaryStatusRequest) (*pb.GetBinaryStatusResponse, error) {
+	s := h.orch.StatusWithOptions(req.Name, orchestrator.DownloadOptions{ForceBackend: req.ForceBackend})
+	return &pb.GetBinaryStatusResponse{
 		Status: statusToProto(s),
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBinaryVersion(ctx context.Context, req *connect.Request[pb.GetBinaryVersionRequest]) (*connect.Response[pb.GetBinaryVersionResponse], error) {
-	version, binPath, isTest, err := h.orch.BinaryVersion(req.Msg.Name, req.Msg.ForceBackend)
+func (h *Handler) GetBinaryVersion(ctx context.Context, req *pb.GetBinaryVersionRequest) (*pb.GetBinaryVersionResponse, error) {
+	version, binPath, isTest, err := h.orch.BinaryVersion(req.Name, req.ForceBackend)
 	if err != nil {
 		// Not-installed-yet is the common case for sidechains the user hasn't
 		// downloaded; surface it as a value, not a transport error, so the
 		// modal can render it plainly.
-		return connect.NewResponse(&pb.GetBinaryVersionResponse{
+		return &pb.GetBinaryVersionResponse{
 			Version:    fmt.Sprintf("Error: %v", err),
 			BinaryPath: binPath,
-		}), nil
+		}, nil
 	}
-	return connect.NewResponse(&pb.GetBinaryVersionResponse{
+	return &pb.GetBinaryVersionResponse{
 		Version:     version,
 		BinaryPath:  binPath,
 		IsTestBuild: isTest,
-	}), nil
+	}, nil
 }
 
 // DownloadBinary dispatches a download in a background goroutine and
 // returns immediately. Mirrors StartWithL1's fire-and-forget shape so a
 // transport blip / client disconnect can't cancel an in-flight download.
 // Progress is polled out of GetSyncStatus (DownloadManager.state-backed).
-func (h *Handler) DownloadBinary(ctx context.Context, req *connect.Request[pb.DownloadBinaryRequest]) (*connect.Response[pb.DownloadBinaryResponse], error) {
-	opts := orchestrator.DownloadOptions{ForceBackend: req.Msg.ForceBackend}
-	ch, err := h.orch.Download(context.Background(), req.Msg.Name, req.Msg.Force, opts)
+func (h *Handler) DownloadBinary(ctx context.Context, req *pb.DownloadBinaryRequest) (*pb.DownloadBinaryResponse, error) {
+	opts := orchestrator.DownloadOptions{ForceBackend: req.ForceBackend}
+	ch, err := h.orch.Download(context.Background(), req.Name, req.Force, opts)
 	if err != nil {
 		return nil, err
 	}
@@ -100,31 +99,31 @@ func (h *Handler) DownloadBinary(ctx context.Context, req *connect.Request[pb.Do
 		}
 	}()
 
-	return connect.NewResponse(&pb.DownloadBinaryResponse{}), nil
+	return &pb.DownloadBinaryResponse{}, nil
 }
 
-func (h *Handler) StartBinary(ctx context.Context, req *connect.Request[pb.StartBinaryRequest]) (*connect.Response[pb.StartBinaryResponse], error) {
-	pid, err := h.orch.Start(ctx, req.Msg.Name, req.Msg.ExtraArgs, req.Msg.Env)
+func (h *Handler) StartBinary(ctx context.Context, req *pb.StartBinaryRequest) (*pb.StartBinaryResponse, error) {
+	pid, err := h.orch.Start(ctx, req.Name, req.ExtraArgs, req.Env)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StartBinaryResponse{
+	return &pb.StartBinaryResponse{
 		Pid: int32(pid),
-	}), nil
+	}, nil
 }
 
-func (h *Handler) StopBinary(ctx context.Context, req *connect.Request[pb.StopBinaryRequest]) (*connect.Response[pb.StopBinaryResponse], error) {
-	opts := orchestrator.StopOptions{ForceBackend: req.Msg.ForceBackend}
-	if err := h.orch.Stop(ctx, req.Msg.Name, req.Msg.Force, opts); err != nil {
+func (h *Handler) StopBinary(ctx context.Context, req *pb.StopBinaryRequest) (*pb.StopBinaryResponse, error) {
+	opts := orchestrator.StopOptions{ForceBackend: req.ForceBackend}
+	if err := h.orch.Stop(ctx, req.Name, req.Force, opts); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopBinaryResponse{}), nil
+	return &pb.StopBinaryResponse{}, nil
 }
 
-func (h *Handler) StreamLogs(ctx context.Context, req *connect.Request[pb.StreamLogsRequest], stream *connect.ServerStream[pb.StreamLogsResponse]) error {
+func (h *Handler) StreamLogs(ctx context.Context, req *pb.StreamLogsRequest, stream rpc.OrchestratorServiceStreamLogsServerStream) error {
 	// Send recent logs first
-	if req.Msg.Tail > 0 {
-		recent, err := h.orch.RecentLogs(req.Msg.Name, int(req.Msg.Tail))
+	if req.Tail > 0 {
+		recent, err := h.orch.RecentLogs(req.Name, int(req.Tail))
 		if err != nil {
 			return err
 		}
@@ -140,7 +139,7 @@ func (h *Handler) StreamLogs(ctx context.Context, req *connect.Request[pb.Stream
 	}
 
 	// Stream live logs
-	ch, cancel, err := h.orch.Logs(req.Msg.Name)
+	ch, cancel, err := h.orch.Logs(req.Name)
 	if err != nil {
 		return err
 	}
@@ -169,8 +168,8 @@ func (h *Handler) StreamLogs(ctx context.Context, req *connect.Request[pb.Stream
 // as StartWithL1: the boot goroutine uses context.Background() so a transport
 // blip can't kill an in-flight restart. Crucially, it does NOT cascade to
 // sibling daemons — restarting "enforcer" never spawns or adopts bitcoind.
-func (h *Handler) RestartDaemon(ctx context.Context, req *connect.Request[pb.RestartDaemonRequest]) (*connect.Response[pb.RestartDaemonResponse], error) {
-	ch, err := h.orch.RestartDaemon(context.Background(), req.Msg.Name, orchestrator.StopOptions{ForceBackend: req.Msg.ForceBackend})
+func (h *Handler) RestartDaemon(ctx context.Context, req *pb.RestartDaemonRequest) (*pb.RestartDaemonResponse, error) {
+	ch, err := h.orch.RestartDaemon(context.Background(), req.Name, orchestrator.StopOptions{ForceBackend: req.ForceBackend})
 	if err != nil {
 		return nil, err
 	}
@@ -181,17 +180,17 @@ func (h *Handler) RestartDaemon(ctx context.Context, req *connect.Request[pb.Res
 		}
 	}()
 
-	return connect.NewResponse(&pb.RestartDaemonResponse{}), nil
+	return &pb.RestartDaemonResponse{}, nil
 }
 
 // RestartL1 stops + reboots the L1 stack (bitcoind + enforcer) on the current
 // config. The orchestrator owns the stop/start sequence so the frontend makes a
 // single call. context.Background() so a transport blip can't abort the reboot.
-func (h *Handler) RestartL1(ctx context.Context, req *connect.Request[pb.RestartL1Request]) (*connect.Response[pb.RestartL1Response], error) {
+func (h *Handler) RestartL1(ctx context.Context, req *pb.RestartL1Request) (*pb.RestartL1Response, error) {
 	if err := h.orch.RestartL1(context.Background()); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RestartL1Response{}), nil
+	return &pb.RestartL1Response{}, nil
 }
 
 // ApplyUTXOSnapshot loads a snapshot into the running Bitcoin Core, streaming
@@ -199,32 +198,32 @@ func (h *Handler) RestartL1(ctx context.Context, req *connect.Request[pb.Restart
 // user sees why a snapshot was refused.
 func (h *Handler) ApplyUTXOSnapshot(
 	ctx context.Context,
-	req *connect.Request[pb.ApplyUTXOSnapshotRequest],
-	stream *connect.ServerStream[pb.ApplyUTXOSnapshotResponse],
+	req *pb.ApplyUTXOSnapshotRequest,
+	stream rpc.OrchestratorServiceApplyUTXOSnapshotServerStream,
 ) error {
-	url := strings.TrimSpace(req.Msg.Url)
-	path := strings.TrimSpace(req.Msg.Path)
+	url := strings.TrimSpace(req.Url)
+	path := strings.TrimSpace(req.Path)
 	if (url == "") == (path == "") {
-		return connect.NewError(
+		return connect.Errorf(
 			connect.CodeInvalidArgument,
-			fmt.Errorf("provide exactly one of url or path"),
+			"provide exactly one of url or path",
 		)
 	}
 
 	ch, err := h.orch.ApplyUserSnapshot(ctx, orchestrator.SnapshotSource{
 		URL:       url,
 		Path:      path,
-		SHA256:    strings.TrimSpace(req.Msg.Sha256),
+		SHA256:    strings.TrimSpace(req.Sha256),
 		Label:     "UTXO snapshot",
 		Requested: true,
 	})
 	if err != nil {
-		return connect.NewError(connect.CodeFailedPrecondition, err)
+		return connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	for p := range ch {
 		if p.Error != nil {
-			return connect.NewError(connect.CodeFailedPrecondition, p.Error)
+			return connect.NewError(connect.CodeFailedPrecondition, p.Error.Error()).WithCause(p.Error)
 		}
 		var pct int32
 		if p.MBTotal > 0 {
@@ -243,9 +242,9 @@ func (h *Handler) ApplyUTXOSnapshot(
 
 // GetSnapshotStatus returns the snapshot the active network publishes and the
 // one Bitcoin Core currently has loaded.
-func (h *Handler) GetSnapshotStatus(ctx context.Context, req *connect.Request[pb.GetSnapshotStatusRequest]) (*connect.Response[pb.GetSnapshotStatusResponse], error) {
+func (h *Handler) GetSnapshotStatus(ctx context.Context, req *pb.GetSnapshotStatusRequest) (*pb.GetSnapshotStatusResponse, error) {
 	s := h.orch.SnapshotStatus(ctx)
-	return connect.NewResponse(&pb.GetSnapshotStatusResponse{
+	return &pb.GetSnapshotStatusResponse{
 		AvailableUrl:               s.Available.URL,
 		AvailableHeight:            s.Available.Height,
 		AvailableSha256:            s.Available.SHA256,
@@ -254,10 +253,10 @@ func (h *Handler) GetSnapshotStatus(ctx context.Context, req *connect.Request[pb
 		ActiveHeight:               s.Active.Height,
 		ActiveValidated:            s.Active.Validated,
 		ActiveVerificationProgress: s.Active.VerificationProgress,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetPendingNetworkGeneration(ctx context.Context, req *connect.Request[pb.GetPendingNetworkGenerationRequest]) (*connect.Response[pb.GetPendingNetworkGenerationResponse], error) {
+func (h *Handler) GetPendingNetworkGeneration(ctx context.Context, req *pb.GetPendingNetworkGenerationRequest) (*pb.GetPendingNetworkGenerationResponse, error) {
 	pending := h.orch.PendingECashUpgrade()
 	resp := &pb.GetPendingNetworkGenerationResponse{
 		CurrentNetworkId: config.ECashNetworkID(),
@@ -269,14 +268,14 @@ func (h *Handler) GetPendingNetworkGeneration(ctx context.Context, req *connect.
 		resp.SnapshotHeight = pending.Snapshot.Height
 		resp.SnapshotSizeBytes = pending.Snapshot.SizeBytes
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
-func (h *Handler) ConfirmPendingNetworkGeneration(ctx context.Context, req *connect.Request[pb.ConfirmPendingNetworkGenerationRequest]) (*connect.Response[pb.ConfirmPendingNetworkGenerationResponse], error) {
+func (h *Handler) ConfirmPendingNetworkGeneration(ctx context.Context, req *pb.ConfirmPendingNetworkGenerationRequest) (*pb.ConfirmPendingNetworkGenerationResponse, error) {
 	if err := h.orch.ConfirmPendingECashNetwork(ctx); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.ConfirmPendingNetworkGenerationResponse{}), nil
+	return &pb.ConfirmPendingNetworkGenerationResponse{}, nil
 }
 
 // StartWithL1 dispatches a boot goroutine and returns immediately. The
@@ -285,16 +284,16 @@ func (h *Handler) ConfirmPendingNetworkGeneration(ctx context.Context, req *conn
 // kill a partway-launched daemon. Callers poll GetSyncStatus for download
 // + sync state and ListBinaries for connection state — neither depends
 // on this RPC's lifetime.
-func (h *Handler) StartWithL1(ctx context.Context, req *connect.Request[pb.StartWithL1Request]) (*connect.Response[pb.StartWithL1Response], error) {
+func (h *Handler) StartWithL1(ctx context.Context, req *pb.StartWithL1Request) (*pb.StartWithL1Response, error) {
 	opts := orchestrator.StartOpts{
-		TargetArgs:   req.Msg.TargetArgs,
-		TargetEnv:    req.Msg.TargetEnv,
-		CoreArgs:     req.Msg.CoreArgs,
-		EnforcerArgs: req.Msg.EnforcerArgs,
-		Immediate:    req.Msg.Immediate,
-		ForceBackend: req.Msg.ForceBackend,
+		TargetArgs:   req.TargetArgs,
+		TargetEnv:    req.TargetEnv,
+		CoreArgs:     req.CoreArgs,
+		EnforcerArgs: req.EnforcerArgs,
+		Immediate:    req.Immediate,
+		ForceBackend: req.ForceBackend,
 	}
-	target := req.Msg.Target
+	target := req.Target
 
 	ch, err := h.orch.StartWithL1(context.Background(), target, opts)
 	if err != nil {
@@ -310,11 +309,11 @@ func (h *Handler) StartWithL1(ctx context.Context, req *connect.Request[pb.Start
 		}
 	}()
 
-	return connect.NewResponse(&pb.StartWithL1Response{}), nil
+	return &pb.StartWithL1Response{}, nil
 }
 
-func (h *Handler) ShutdownAll(ctx context.Context, req *connect.Request[pb.ShutdownAllRequest], stream *connect.ServerStream[pb.ShutdownAllResponse]) error {
-	ch, err := h.orch.ShutdownAll(ctx, req.Msg.Force)
+func (h *Handler) ShutdownAll(ctx context.Context, req *pb.ShutdownAllRequest, stream rpc.OrchestratorServiceShutdownAllServerStream) error {
+	ch, err := h.orch.ShutdownAll(ctx, req.Force)
 	if err != nil {
 		return err
 	}
@@ -343,46 +342,46 @@ func (h *Handler) ShutdownAll(ctx context.Context, req *connect.Request[pb.Shutd
 // exposed: when a fresh bitwindowd calls StartWithL1 mid-drain,
 // drivechaind adopts the in-flight drain itself (flips will-exit + awaits)
 // before booting the new stack. No caller-side glue.
-func (h *Handler) Shutdown(_ context.Context, req *connect.Request[pb.ShutdownRequest]) (*connect.Response[pb.ShutdownResponse], error) {
-	if req.Msg.GetOnlyIfLast() {
+func (h *Handler) Shutdown(_ context.Context, req *pb.ShutdownRequest) (*pb.ShutdownResponse, error) {
+	if req.GetOnlyIfLast() {
 		h.orch.ClientLeaving()
-		return connect.NewResponse(&pb.ShutdownResponse{}), nil
+		return &pb.ShutdownResponse{}, nil
 	}
-	h.orch.BeginShutdown(req.Msg.GetKeepL1())
-	return connect.NewResponse(&pb.ShutdownResponse{}), nil
+	h.orch.BeginShutdown(req.GetKeepL1())
+	return &pb.ShutdownResponse{}, nil
 }
 
-func (h *Handler) AdoptOwner(_ context.Context, req *connect.Request[pb.AdoptOwnerRequest]) (*connect.Response[pb.AdoptOwnerResponse], error) {
-	pid := int(req.Msg.GetOwnerPid())
+func (h *Handler) AdoptOwner(_ context.Context, req *pb.AdoptOwnerRequest) (*pb.AdoptOwnerResponse, error) {
+	pid := int(req.GetOwnerPid())
 	if pid <= 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("owner_pid must name a live process"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "owner_pid must name a live process")
 	}
 	canceled, err := h.orch.AdoptOwner(pid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.AdoptOwnerResponse{
+	return &pb.AdoptOwnerResponse{
 		CanceledExit: canceled,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBTCPrice(ctx context.Context, req *connect.Request[pb.GetBTCPriceRequest]) (*connect.Response[pb.GetBTCPriceResponse], error) {
+func (h *Handler) GetBTCPrice(ctx context.Context, req *pb.GetBTCPriceRequest) (*pb.GetBTCPriceResponse, error) {
 	price, updatedAt, err := h.orch.GetBTCPrice()
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBTCPriceResponse{
+	return &pb.GetBTCPriceResponse{
 		Btcusd:          price,
 		LastUpdatedUnix: updatedAt.Unix(),
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetMainchainBlockchainInfo(ctx context.Context, req *connect.Request[pb.GetMainchainBlockchainInfoRequest]) (*connect.Response[pb.GetMainchainBlockchainInfoResponse], error) {
+func (h *Handler) GetMainchainBlockchainInfo(ctx context.Context, req *pb.GetMainchainBlockchainInfoRequest) (*pb.GetMainchainBlockchainInfoResponse, error) {
 	info, err := h.orch.GetMainchainBlockchainInfo(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetMainchainBlockchainInfoResponse{
+	return &pb.GetMainchainBlockchainInfoResponse{
 		Chain:                info.Chain,
 		Blocks:               int32(info.Blocks),
 		Headers:              int32(info.Headers),
@@ -395,10 +394,10 @@ func (h *Handler) GetMainchainBlockchainInfo(ctx context.Context, req *connect.R
 		ChainWork:            info.ChainWork,
 		SizeOnDisk:           info.SizeOnDisk,
 		Pruned:               info.Pruned,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetForkStatus(ctx context.Context, req *connect.Request[pb.GetForkStatusRequest]) (*connect.Response[pb.GetForkStatusResponse], error) {
+func (h *Handler) GetForkStatus(ctx context.Context, req *pb.GetForkStatusRequest) (*pb.GetForkStatusResponse, error) {
 	s, err := h.orch.ForkState(ctx)
 	if err != nil {
 		return nil, err
@@ -438,7 +437,7 @@ func (h *Handler) GetForkStatus(ctx context.Context, req *connect.Request[pb.Get
 	if err != nil {
 		replayLockTime = 0
 	}
-	return connect.NewResponse(&pb.GetForkStatusResponse{
+	return &pb.GetForkStatusResponse{
 		ForkHeight:      int32(s.ForkHeight),
 		CurrentHeight:   int32(s.CurrentHeight),
 		CurrentHeaders:  int32(s.CurrentHeaders),
@@ -449,28 +448,28 @@ func (h *Handler) GetForkStatus(ctx context.Context, req *connect.Request[pb.Get
 		NetworkName:     s.NetworkName,
 		Claims:          claims,
 		ReplayLockTime:  replayLockTime,
-	}), nil
+	}, nil
 }
 
 // GetEnforcerBlockchainInfo is a thin compatibility shim over the new
 // GetSyncStatus path. Frontends should migrate to GetSyncStatus directly.
-func (h *Handler) GetEnforcerBlockchainInfo(ctx context.Context, req *connect.Request[pb.GetEnforcerBlockchainInfoRequest]) (*connect.Response[pb.GetEnforcerBlockchainInfoResponse], error) {
+func (h *Handler) GetEnforcerBlockchainInfo(ctx context.Context, req *pb.GetEnforcerBlockchainInfoRequest) (*pb.GetEnforcerBlockchainInfoResponse, error) {
 	s, err := h.orch.GetSyncStatus(ctx)
 	if err != nil {
 		return nil, err
 	}
 	enf := s.Enforcer
 	if enf == nil || enf.Error != "" {
-		return connect.NewResponse(&pb.GetEnforcerBlockchainInfoResponse{}), nil
+		return &pb.GetEnforcerBlockchainInfoResponse{}, nil
 	}
-	return connect.NewResponse(&pb.GetEnforcerBlockchainInfoResponse{
+	return &pb.GetEnforcerBlockchainInfoResponse{
 		Blocks:  int32(enf.Blocks),
 		Headers: int32(enf.Headers),
 		Time:    enf.Time,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetSyncStatus(ctx context.Context, req *connect.Request[pb.GetSyncStatusRequest]) (*connect.Response[pb.GetSyncStatusResponse], error) {
+func (h *Handler) GetSyncStatus(ctx context.Context, req *pb.GetSyncStatusRequest) (*pb.GetSyncStatusResponse, error) {
 	s, err := h.orch.GetSyncStatus(ctx)
 	if err != nil {
 		return nil, err
@@ -497,13 +496,13 @@ func (h *Handler) GetSyncStatus(ctx context.Context, req *connect.Request[pb.Get
 		}
 	}
 
-	return connect.NewResponse(&pb.GetSyncStatusResponse{
+	return &pb.GetSyncStatusResponse{
 		Mainchain:        chainSyncToProto(s.Mainchain),
 		Enforcer:         chainSyncToProto(s.Enforcer),
 		ChainSource:      chainSyncToProto(s.ChainSource),
 		Sidechains:       sidechains,
 		WalletSyncStatus: walletSyncStatus,
-	}), nil
+	}, nil
 }
 
 // sidechainTypeFromName maps the orch's logical binary name to the proto
@@ -568,7 +567,7 @@ func mainchainSyncPhaseToProto(phase sidechain.MainchainSyncPhase) pb.MainchainS
 // when nothing is in flight — frontends rely on that as the steady state.
 // Binaries the proto enum doesn't know about (e.g. grpcurl) are dropped so
 // the wire format stays strongly typed.
-func (h *Handler) GetDownloadStatus(ctx context.Context, req *connect.Request[pb.GetDownloadStatusRequest]) (*connect.Response[pb.GetDownloadStatusResponse], error) {
+func (h *Handler) GetDownloadStatus(ctx context.Context, req *pb.GetDownloadStatusRequest) (*pb.GetDownloadStatusResponse, error) {
 	states := h.orch.DownloadStates()
 	downloads := make([]*pb.DownloadStatus, 0, len(states))
 	for name, s := range states {
@@ -583,9 +582,9 @@ func (h *Handler) GetDownloadStatus(ctx context.Context, req *connect.Request[pb
 			Message:      s.Message,
 		})
 	}
-	return connect.NewResponse(&pb.GetDownloadStatusResponse{
+	return &pb.GetDownloadStatusResponse{
 		Downloads: downloads,
-	}), nil
+	}, nil
 }
 
 // binaryTypeFromName maps the orchestrator's logical binary name to the
@@ -632,36 +631,36 @@ func binaryTypeFromName(name string) pb.BinaryType {
 	}
 }
 
-func (h *Handler) GetMainchainBalance(ctx context.Context, req *connect.Request[pb.GetMainchainBalanceRequest]) (*connect.Response[pb.GetMainchainBalanceResponse], error) {
+func (h *Handler) GetMainchainBalance(ctx context.Context, req *pb.GetMainchainBalanceRequest) (*pb.GetMainchainBalanceResponse, error) {
 	bal, err := h.orch.GetMainchainBalance(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetMainchainBalanceResponse{
+	return &pb.GetMainchainBalanceResponse{
 		Confirmed:   bal.Confirmed,
 		Unconfirmed: bal.Unconfirmed,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetSidechainBalance(ctx context.Context, req *connect.Request[pb.GetSidechainBalanceRequest]) (*connect.Response[pb.GetSidechainBalanceResponse], error) {
-	name, displayName, err := sidechainNames(req.Msg.Sidechain)
+func (h *Handler) GetSidechainBalance(ctx context.Context, req *pb.GetSidechainBalanceRequest) (*pb.GetSidechainBalanceResponse, error) {
+	name, displayName, err := sidechainNames(req.Sidechain)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	cfg, ok := h.orch.Configs()[name]
 	if !ok {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("sidechain %s is not configured", name))
+		return nil, connect.Errorf(connect.CodeNotFound, "sidechain %s is not configured", name)
 	}
 
 	confirmedSats, pendingSats, err := h.fetchSidechainBalance(ctx, cfg)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	// A node counts a coin once a block carries it, so a payment on its way
 	// reads as nothing at all until the next block.
 	delta, err := h.mempoolDelta(ctx, cfg)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	confirmedSats, pendingSats = applyMempoolDelta(confirmedSats, pendingSats, delta)
 	// Read the deposits last. The sidechain credits a deposit into the balance
@@ -669,26 +668,26 @@ func (h *Handler) GetSidechainBalance(ctx context.Context, req *connect.Request[
 	// for one poll, and never in both.
 	depositSats, err := h.depositPendingSats(ctx, cfg)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 	pendingSats += depositSats
 
 	if h.orch.WalletSvc != nil {
 		if err := h.orch.WalletSvc.SyncBalance(
-			req.Msg.Sidechain,
+			req.Sidechain,
 			h.orch.WalletSvc.ActiveWalletID(),
 			uint64(confirmedSats),
 			uint64(pendingSats),
 			displayName,
 		); err != nil {
-			return nil, connect.NewError(connect.CodeInternal, err)
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 	}
 
-	return connect.NewResponse(&pb.GetSidechainBalanceResponse{
+	return &pb.GetSidechainBalanceResponse{
 		ConfirmedSats: uint64(confirmedSats),
 		PendingSats:   uint64(pendingSats),
-	}), nil
+	}, nil
 }
 
 // sidechainNames maps a sidechain binary to its config key and the name shown
@@ -928,8 +927,8 @@ func specsFromItems(items []*pb.SingleDeletion) []orchestrator.GatherSpec {
 	})
 }
 
-func (h *Handler) GatherFilesToDelete(ctx context.Context, req *connect.Request[pb.GatherFilesToDeleteRequest]) (*connect.Response[pb.GatherFilesToDeleteResponse], error) {
-	files, err := h.orch.GatherFilesToDelete(specsFromItems(req.Msg.Items))
+func (h *Handler) GatherFilesToDelete(ctx context.Context, req *pb.GatherFilesToDeleteRequest) (*pb.GatherFilesToDeleteResponse, error) {
+	files, err := h.orch.GatherFilesToDelete(specsFromItems(req.Items))
 	if err != nil {
 		return nil, err
 	}
@@ -945,7 +944,7 @@ func (h *Handler) GatherFilesToDelete(ctx context.Context, req *connect.Request[
 			}
 		}),
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 // deletablePaths drops user-deselected paths from the gathered set. Subtractive
@@ -958,16 +957,16 @@ func deletablePaths(files []orchestrator.ResetFileInfo, except []string) []strin
 	})
 }
 
-func (h *Handler) DeleteFiles(ctx context.Context, req *connect.Request[pb.DeleteFilesRequest], stream *connect.ServerStream[pb.DeleteFilesResponse]) error {
+func (h *Handler) DeleteFiles(ctx context.Context, req *pb.DeleteFilesRequest, stream rpc.OrchestratorServiceDeleteFilesServerStream) error {
 	// Resolve paths from the request's specs instead of trusting client paths,
 	// so a caller can't drive deletion outside the gather set.
-	specs := specsFromItems(req.Msg.Items)
+	specs := specsFromItems(req.Items)
 	files, err := h.orch.GatherFilesToDelete(specs)
 	if err != nil {
 		return err
 	}
 
-	ch, err := h.orch.DeleteFiles(ctx, deletablePaths(files, req.Msg.Except), specs)
+	ch, err := h.orch.DeleteFiles(ctx, deletablePaths(files, req.Except), specs)
 	if err != nil {
 		return err
 	}
@@ -980,16 +979,16 @@ func (h *Handler) DeleteFiles(ctx context.Context, req *connect.Request[pb.Delet
 	return nil
 }
 
-func (h *Handler) RejectBlock(ctx context.Context, req *connect.Request[pb.RejectBlockRequest]) (*connect.Response[pb.RejectBlockResponse], error) {
+func (h *Handler) RejectBlock(ctx context.Context, req *pb.RejectBlockRequest) (*pb.RejectBlockResponse, error) {
 	res, err := h.orch.RejectBlock(
 		ctx,
-		req.Msg.BlockHash,
-		time.Duration(req.Msg.EnforcerWaitSeconds)*time.Second,
+		req.BlockHash,
+		time.Duration(req.EnforcerWaitSeconds)*time.Second,
 	)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.RejectBlockResponse{
+	return &pb.RejectBlockResponse{
 		CoreHeight:      res.CoreHeight,
 		CoreTipHash:     res.CoreTipHash,
 		Outcome:         rejectOutcomeToProto(res.Outcome),
@@ -997,7 +996,7 @@ func (h *Handler) RejectBlock(ctx context.Context, req *connect.Request[pb.Rejec
 		EnforcerRebuilt: res.EnforcerRebuilt,
 		EnforcerError:   res.EnforcerError,
 		EnforcerChecked: res.EnforcerChecked,
-	}), nil
+	}, nil
 }
 
 func rejectOutcomeToProto(o orchestrator.RejectOutcome) pb.RejectOutcome {
@@ -1012,23 +1011,23 @@ func rejectOutcomeToProto(o orchestrator.RejectOutcome) pb.RejectOutcome {
 	return pb.RejectOutcome_REJECT_OUTCOME_UNSPECIFIED
 }
 
-func (h *Handler) AcceptBlock(ctx context.Context, req *connect.Request[pb.AcceptBlockRequest]) (*connect.Response[pb.AcceptBlockResponse], error) {
+func (h *Handler) AcceptBlock(ctx context.Context, req *pb.AcceptBlockRequest) (*pb.AcceptBlockResponse, error) {
 	res, err := h.orch.AcceptBlock(
 		ctx,
-		req.Msg.BlockHash,
-		time.Duration(req.Msg.EnforcerWaitSeconds)*time.Second,
+		req.BlockHash,
+		time.Duration(req.EnforcerWaitSeconds)*time.Second,
 	)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.AcceptBlockResponse{
+	return &pb.AcceptBlockResponse{
 		CoreHeight:      res.CoreHeight,
 		CoreTipHash:     res.CoreTipHash,
 		EnforcerHeight:  res.EnforcerHeight,
 		EnforcerRebuilt: res.EnforcerRebuilt,
 		EnforcerError:   res.EnforcerError,
 		EnforcerChecked: res.EnforcerChecked,
-	}), nil
+	}, nil
 }
 
 // ResetToBlock moves the chain back to a block, then syncs forward to the tip
@@ -1036,13 +1035,13 @@ func (h *Handler) AcceptBlock(ctx context.Context, req *connect.Request[pb.Accep
 // opens, so the caller sees it as an RPC error.
 func (h *Handler) ResetToBlock(
 	ctx context.Context,
-	req *connect.Request[pb.ResetToBlockRequest],
-	stream *connect.ServerStream[pb.ResetToBlockResponse],
+	req *pb.ResetToBlockRequest,
+	stream rpc.OrchestratorServiceResetToBlockServerStream,
 ) error {
 	ch, err := h.orch.ResetToBlock(
 		ctx,
-		req.Msg.Target,
-		time.Duration(req.Msg.EnforcerWaitSeconds)*time.Second,
+		req.Target,
+		time.Duration(req.EnforcerWaitSeconds)*time.Second,
 	)
 	if err != nil {
 		return rpcError(err)
@@ -1050,7 +1049,7 @@ func (h *Handler) ResetToBlock(
 
 	for p := range ch {
 		if p.Error != nil {
-			return connect.NewError(connect.CodeFailedPrecondition, p.Error)
+			return connect.NewError(connect.CodeFailedPrecondition, p.Error.Error()).WithCause(p.Error)
 		}
 		if err := stream.Send(&pb.ResetToBlockResponse{
 			Phase:           resetPhaseToProto(p.Phase),
@@ -1154,13 +1153,13 @@ type coreRPCResult struct {
 
 func (h *Handler) callCoreRPC(ctx context.Context, method, paramsJSON, wallet string) (json.RawMessage, error) {
 	if h.orch.BitcoinConf == nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("bitcoin conf not loaded"))
+		return nil, connect.Errorf(connect.CodeUnavailable, "bitcoin conf not loaded")
 	}
 
 	port := h.orch.BitcoinConf.GetRPCPort()
 	user, password, err := h.orch.BitcoinConf.GetRPCCredentials()
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("core rpc credentials: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("core rpc credentials: %w", err).Error())
 	}
 
 	if paramsJSON == "" {
@@ -1204,10 +1203,10 @@ func (h *Handler) callCoreRPC(ctx context.Context, method, paramsJSON, wallet st
 	return out.Result, nil
 }
 
-func (h *Handler) GetCoreMempoolInfo(ctx context.Context, _ *connect.Request[pb.GetCoreMempoolInfoRequest]) (*connect.Response[pb.GetCoreMempoolInfoResponse], error) {
+func (h *Handler) GetCoreMempoolInfo(ctx context.Context, _ *pb.GetCoreMempoolInfoRequest) (*pb.GetCoreMempoolInfoResponse, error) {
 	raw, err := h.callCoreRPC(ctx, "getmempoolinfo", "[]", "")
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	var info struct {
 		Loaded              bool    `json:"loaded"`
@@ -1223,9 +1222,9 @@ func (h *Handler) GetCoreMempoolInfo(ctx context.Context, _ *connect.Request[pb.
 		FullRBF             bool    `json:"fullrbf"`
 	}
 	if err := json.Unmarshal(raw, &info); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode getmempoolinfo: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode getmempoolinfo: %w", err).Error())
 	}
-	return connect.NewResponse(&pb.GetCoreMempoolInfoResponse{
+	return &pb.GetCoreMempoolInfoResponse{
 		Loaded:              info.Loaded,
 		Size:                info.Size,
 		Bytes:               info.Bytes,
@@ -1237,13 +1236,13 @@ func (h *Handler) GetCoreMempoolInfo(ctx context.Context, _ *connect.Request[pb.
 		IncrementalRelayFee: info.IncrementalRelayFee,
 		UnbroadcastCount:    info.UnbroadcastCount,
 		FullRbf:             info.FullRBF,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBmmContext(ctx context.Context, _ *connect.Request[pb.GetBmmContextRequest]) (*connect.Response[pb.GetBmmContextResponse], error) {
+func (h *Handler) GetBmmContext(ctx context.Context, _ *pb.GetBmmContextRequest) (*pb.GetBmmContextResponse, error) {
 	rawChain, err := h.callCoreRPC(ctx, "getblockchaininfo", "[]", "")
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	var chain struct {
 		Blocks        int32  `json:"blocks"`
@@ -1251,27 +1250,27 @@ func (h *Handler) GetBmmContext(ctx context.Context, _ *connect.Request[pb.GetBm
 		Warnings      any    `json:"warnings"`
 	}
 	if err := json.Unmarshal(rawChain, &chain); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode getblockchaininfo: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode getblockchaininfo: %w", err).Error())
 	}
 
 	rawMempool, err := h.callCoreRPC(ctx, "getmempoolinfo", "[]", "")
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	var mempool struct {
 		Size int64 `json:"size"`
 	}
 	if err := json.Unmarshal(rawMempool, &mempool); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode getmempoolinfo: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("decode getmempoolinfo: %w", err).Error())
 	}
 
-	return connect.NewResponse(&pb.GetBmmContextResponse{
+	return &pb.GetBmmContextResponse{
 		MainchainHeight: chain.Blocks,
 		MainchainTip:    chain.BestBlockHash,
 		FeeRateSatVb:    h.nextBlockFeeRate(ctx),
 		MempoolTxns:     mempool.Size,
 		Warnings:        coreWarnings(chain.Warnings),
-	}), nil
+	}, nil
 }
 
 // nextBlockFeeRate converts estimatesmartfee's BTC/kvB into sat/vB. A node
@@ -1315,10 +1314,10 @@ func (h *Handler) RawCoreCall(ctx context.Context, method, paramsJSON, wallet st
 	return h.callCoreRPC(ctx, method, paramsJSON, wallet)
 }
 
-func (h *Handler) CoreRawCall(ctx context.Context, req *connect.Request[pb.CoreRawCallRequest]) (*connect.Response[pb.CoreRawCallResponse], error) {
-	raw, err := h.callCoreRPC(ctx, req.Msg.Method, req.Msg.ParamsJson, req.Msg.Wallet)
+func (h *Handler) CoreRawCall(ctx context.Context, req *pb.CoreRawCallRequest) (*pb.CoreRawCallResponse, error) {
+	raw, err := h.callCoreRPC(ctx, req.Method, req.ParamsJson, req.Wallet)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.CoreRawCallResponse{ResultJson: string(raw)}), nil
+	return &pb.CoreRawCallResponse{ResultJson: string(raw)}, nil
 }
diff --git a/sidechain-orchestrator/api/remote_enforcer_test.go b/sidechain-orchestrator/api/remote_enforcer_test.go
index a7bb88e29e..f90617e8ca 100644
--- a/sidechain-orchestrator/api/remote_enforcer_test.go
+++ b/sidechain-orchestrator/api/remote_enforcer_test.go
@@ -1,13 +1,13 @@
 package api
 
 import (
+	"connectrpc.com/connect/v2/connecthttp"
 	"context"
-	"fmt"
 	"io"
 	"net/http"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/require"
@@ -28,28 +28,28 @@ type ctipValidator struct {
 	err    error
 }
 
-func (v ctipValidator) GetChainTip(context.Context, *connect.Request[enforcerpb.GetChainTipRequest]) (*connect.Response[enforcerpb.GetChainTipResponse], error) {
-	return connect.NewResponse(&enforcerpb.GetChainTipResponse{
+func (v ctipValidator) GetChainTip(context.Context, *enforcerpb.GetChainTipRequest) (*enforcerpb.GetChainTipResponse, error) {
+	return &enforcerpb.GetChainTipResponse{
 		BlockHeaderInfo: &enforcerpb.BlockHeaderInfo{Height: v.height},
-	}), nil
+	}, nil
 }
 
-func (v ctipValidator) GetSidechains(context.Context, *connect.Request[enforcerpb.GetSidechainsRequest]) (*connect.Response[enforcerpb.GetSidechainsResponse], error) {
-	return connect.NewResponse(&enforcerpb.GetSidechainsResponse{
+func (v ctipValidator) GetSidechains(context.Context, *enforcerpb.GetSidechainsRequest) (*enforcerpb.GetSidechainsResponse, error) {
+	return &enforcerpb.GetSidechainsResponse{
 		Sidechains: lo.Map(v.slots, func(slot uint32, _ int) *enforcerpb.GetSidechainsResponse_SidechainInfo {
 			return &enforcerpb.GetSidechainsResponse_SidechainInfo{SidechainNumber: wrapperspb.UInt32(slot)}
 		}),
-	}), nil
+	}, nil
 }
 
-func (v ctipValidator) GetCtip(_ context.Context, req *connect.Request[enforcerpb.GetCtipRequest]) (*connect.Response[enforcerpb.GetCtipResponse], error) {
-	if req.Msg.GetSidechainNumber().GetValue() != 9 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("wrong sidechain slot"))
+func (v ctipValidator) GetCtip(_ context.Context, req *enforcerpb.GetCtipRequest) (*enforcerpb.GetCtipResponse, error) {
+	if req.GetSidechainNumber().GetValue() != 9 {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "wrong sidechain slot")
 	}
 	if v.err != nil {
 		return nil, v.err
 	}
-	return connect.NewResponse(&enforcerpb.GetCtipResponse{Ctip: v.ctip}), nil
+	return &enforcerpb.GetCtipResponse{Ctip: v.ctip}, nil
 }
 
 func TestDepositReadsTheEnforcerInBothModes(t *testing.T) {
@@ -69,12 +69,13 @@ func TestDepositReadsTheEnforcerInBothModes(t *testing.T) {
 					Vout:  2,
 					Value: 12000,
 				}},
-				{name: "unavailable", err: connect.NewError(connect.CodeUnavailable, fmt.Errorf("validator is unavailable"))},
+				{name: "unavailable", err: connect.Errorf(connect.CodeUnavailable, "validator is unavailable")},
 			} {
 				t.Run(state.name, func(t *testing.T) {
 					mux := http.NewServeMux()
-					path, handler := enforcerrpc.NewValidatorServiceHandler(ctipValidator{height: 100, slots: state.slots, ctip: state.ctip, err: state.err})
-					mux.Handle(path, handler)
+					rpcServer := connect.NewServer()
+					enforcerrpc.RegisterValidatorServiceHandler(rpcServer, ctipValidator{height: 100, slots: state.slots, ctip: state.ctip, err: state.err})
+					connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 					server := h2cServer(mux)
 					t.Cleanup(server.Close)
 					host, port := hostPort(t, server)
diff --git a/sidechain-orchestrator/api/sidechain_conf_handler.go b/sidechain-orchestrator/api/sidechain_conf_handler.go
index aa5c21578b..4f89331e3c 100644
--- a/sidechain-orchestrator/api/sidechain_conf_handler.go
+++ b/sidechain-orchestrator/api/sidechain_conf_handler.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
@@ -28,19 +28,19 @@ func (h *SidechainConfHandler) getManager(name string) (*config.SidechainConfMan
 	key := strings.ToLower(name)
 	m, ok := h.managers[key]
 	if !ok {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("unknown sidechain: %s", name))
+		return nil, connect.Errorf(connect.CodeNotFound, "unknown sidechain: %s", name)
 	}
 	return m, nil
 }
 
-func (h *SidechainConfHandler) GetSidechainConfig(ctx context.Context, req *connect.Request[pb.GetSidechainConfigRequest]) (*connect.Response[pb.GetSidechainConfigResponse], error) {
-	m, err := h.getManager(req.Msg.SidechainName)
+func (h *SidechainConfHandler) GetSidechainConfig(ctx context.Context, req *pb.GetSidechainConfigRequest) (*pb.GetSidechainConfigResponse, error) {
+	m, err := h.getManager(req.SidechainName)
 	if err != nil {
 		return nil, err
 	}
 
 	if loadErr := m.LoadConfig(); loadErr != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("reload config: %w", loadErr))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("reload config: %w", loadErr).Error())
 	}
 
 	var configContent string
@@ -48,37 +48,37 @@ func (h *SidechainConfHandler) GetSidechainConfig(ctx context.Context, req *conn
 		configContent = m.Config.Serialize()
 	}
 
-	return connect.NewResponse(&pb.GetSidechainConfigResponse{
+	return &pb.GetSidechainConfigResponse{
 		ConfigContent: configContent,
 		ConfigPath:    m.ConfigPath,
 		DefaultConfig: m.GetDefaultConfig(),
 		CliArgs:       m.GetCliArgs(),
 		Network:       m.GetNetwork(),
-	}), nil
+	}, nil
 }
 
-func (h *SidechainConfHandler) WriteSidechainConfig(ctx context.Context, req *connect.Request[pb.WriteSidechainConfigRequest]) (*connect.Response[pb.WriteSidechainConfigResponse], error) {
-	m, err := h.getManager(req.Msg.SidechainName)
+func (h *SidechainConfHandler) WriteSidechainConfig(ctx context.Context, req *pb.WriteSidechainConfigRequest) (*pb.WriteSidechainConfigResponse, error) {
+	m, err := h.getManager(req.SidechainName)
 	if err != nil {
 		return nil, err
 	}
 
-	if writeErr := m.WriteConfig(req.Msg.ConfigContent); writeErr != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("write config: %w", writeErr))
+	if writeErr := m.WriteConfig(req.ConfigContent); writeErr != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("write config: %w", writeErr).Error())
 	}
 
-	return connect.NewResponse(&pb.WriteSidechainConfigResponse{}), nil
+	return &pb.WriteSidechainConfigResponse{}, nil
 }
 
-func (h *SidechainConfHandler) SyncSidechainNetworkFromBitcoinConf(ctx context.Context, req *connect.Request[pb.SyncSidechainNetworkFromBitcoinConfRequest]) (*connect.Response[pb.SyncSidechainNetworkFromBitcoinConfResponse], error) {
-	m, err := h.getManager(req.Msg.SidechainName)
+func (h *SidechainConfHandler) SyncSidechainNetworkFromBitcoinConf(ctx context.Context, req *pb.SyncSidechainNetworkFromBitcoinConfRequest) (*pb.SyncSidechainNetworkFromBitcoinConfResponse, error) {
+	m, err := h.getManager(req.SidechainName)
 	if err != nil {
 		return nil, err
 	}
 
 	if syncErr := m.SyncNetworkFromBitcoinConf(); syncErr != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("sync network: %w", syncErr))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("sync network: %w", syncErr).Error())
 	}
 
-	return connect.NewResponse(&pb.SyncSidechainNetworkFromBitcoinConfResponse{}), nil
+	return &pb.SyncSidechainNetworkFromBitcoinConfResponse{}, nil
 }
diff --git a/sidechain-orchestrator/api/solana_bmm_test.go b/sidechain-orchestrator/api/solana_bmm_test.go
index d96bdaf6a9..399bed51bb 100644
--- a/sidechain-orchestrator/api/solana_bmm_test.go
+++ b/sidechain-orchestrator/api/solana_bmm_test.go
@@ -10,7 +10,7 @@ import (
 	"slices"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -88,18 +88,18 @@ func TestSolanaBidCommitsToTheTemplate(t *testing.T) {
 	}
 	h := solanaHandler(t, host, port, wallet)
 
-	resp, err := h.CreateBid(context.Background(), connect.NewRequest(&bmmpb.CreateBidRequest{
+	resp, err := h.CreateBid(context.Background(), &bmmpb.CreateBidRequest{
 		Sidechain:  pb.BinaryType_BINARY_TYPE_SOLANA,
 		WalletId:   "bidder",
 		BidSats:    1_000,
 		MaxBidSats: 30_000,
-	}))
+	})
 	require.NoError(t, err)
 
-	assert.Equal(t, solanaCritical, resp.Msg.CriticalHash)
-	assert.Equal(t, solanaPrevMain, resp.Msg.PrevMainHash)
-	assert.Equal(t, int64(7000), resp.Msg.FeesSats)
-	assert.JSONEq(t, solanaBlock, resp.Msg.BlockJson)
+	assert.Equal(t, solanaCritical, resp.CriticalHash)
+	assert.Equal(t, solanaPrevMain, resp.PrevMainHash)
+	assert.Equal(t, int64(7000), resp.FeesSats)
+	assert.JSONEq(t, solanaBlock, resp.BlockJson)
 
 	require.Len(t, wallet.sends, 1)
 	send := wallet.sends[0]
@@ -127,15 +127,15 @@ func TestSolanaConnectBidSendsTheBlockAndTheMainBlock(t *testing.T) {
 	host, port, seen := solanaNode(t)
 	h := solanaHandler(t, host, port, &fakeBidWallet{})
 
-	resp, err := h.ConnectBid(context.Background(), connect.NewRequest(&bmmpb.ConnectBidRequest{
+	resp, err := h.ConnectBid(context.Background(), &bmmpb.ConnectBidRequest{
 		Sidechain:    pb.BinaryType_BINARY_TYPE_SOLANA,
 		CriticalHash: solanaCritical,
 		BlockJson:    solanaBlock,
-	}))
+	})
 	require.NoError(t, err)
 
-	assert.True(t, resp.Msg.Connected)
-	assert.Equal(t, solanaMainBlock, resp.Msg.MainBlockHash)
+	assert.True(t, resp.Connected)
+	assert.Equal(t, solanaMainBlock, resp.MainBlockHash)
 	assert.JSONEq(t, `["`+solanaCritical+`"]`, string(seen["get_bmm_inclusions"]))
 	assert.JSONEq(t, `[`+solanaBlock+`,"`+solanaMainBlock+`"]`, string(seen["connect_block"]))
 }
@@ -150,11 +150,11 @@ func TestConnectBidNamesAnUndecodableBlock(t *testing.T) {
 	host, port := hostPort(t, srv)
 	h := solanaHandler(t, host, port, &fakeBidWallet{})
 
-	_, err := h.ConnectBid(context.Background(), connect.NewRequest(&bmmpb.ConnectBidRequest{
+	_, err := h.ConnectBid(context.Background(), &bmmpb.ConnectBidRequest{
 		Sidechain:     pb.BinaryType_BINARY_TYPE_SOLANA,
 		CriticalHash:  solanaCritical,
 		BlockJson:     solanaBlock,
 		MainBlockHash: solanaMainBlock,
-	}))
+	})
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
diff --git a/sidechain-orchestrator/api/stratum_handler.go b/sidechain-orchestrator/api/stratum_handler.go
index 6778c35330..603c53e217 100644
--- a/sidechain-orchestrator/api/stratum_handler.go
+++ b/sidechain-orchestrator/api/stratum_handler.go
@@ -16,7 +16,7 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
@@ -164,21 +164,21 @@ func NewStratumHandler(ctx context.Context, deps StratumDeps) *StratumHandler {
 func (h *StratumHandler) mineable() error {
 	current := h.network.CurrentNetwork()
 	if network, ok := config.LookupNetwork(current); !ok || network != config.NetworkECash {
-		return connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("mining is only available on eCash, not %s", cmp.Or(current, "an unknown network")))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"mining is only available on eCash, not %s", cmp.Or(current, "an unknown network"))
 	}
 	return nil
 }
 
 func (h *StratumHandler) StartStratum(
-	ctx context.Context, req *connect.Request[pb.StartStratumRequest],
-) (*connect.Response[pb.StartStratumResponse], error) {
+	ctx context.Context, req *pb.StartStratumRequest,
+) (*pb.StartStratumResponse, error) {
 	if err := h.mineable(); err != nil {
 		return nil, err
 	}
-	port := cmp.Or(req.Msg.Port, h.settings.StratumSettings().Port, defaultStratumPort)
+	port := cmp.Or(req.Port, h.settings.StratumSettings().Port, defaultStratumPort)
 	if port > 65535 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("port %d is out of range", port))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "port %d is out of range", port)
 	}
 
 	h.opMu.Lock()
@@ -186,7 +186,7 @@ func (h *StratumHandler) StartStratum(
 	if err := h.start(ctx, port, h.settings.StratumSettings()); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StartStratumResponse{}), nil
+	return &pb.StartStratumResponse{}, nil
 }
 
 // start listens and serves miners under settings. The caller holds opMu.
@@ -198,8 +198,8 @@ func (h *StratumHandler) start(ctx context.Context, port uint32, settings orches
 		if running.port == port {
 			return nil
 		}
-		return connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("the stratum server already runs on port %d", running.port))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"the stratum server already runs on port %d", running.port)
 	}
 
 	ready, err := h.prepare(ctx, port, settings)
@@ -228,7 +228,7 @@ func (h *StratumHandler) prepare(
 	}
 	ln, err := h.listen(port)
 	if err != nil {
-		return readyRun{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("listen on port %d: %w", port, err))
+		return readyRun{}, connect.NewError(connect.CodeUnavailable, fmt.Errorf("listen on port %d: %w", port, err).Error())
 	}
 	return readyRun{listener: ln, port: port, source: source, pool: pool}, nil
 }
@@ -270,10 +270,10 @@ func (h *StratumHandler) serve(ready readyRun, settings orchestrator.StratumSett
 }
 
 func (h *StratumHandler) StopStratum(
-	context.Context, *connect.Request[pb.StopStratumRequest],
-) (*connect.Response[pb.StopStratumResponse], error) {
+	context.Context, *pb.StopStratumRequest,
+) (*pb.StopStratumResponse, error) {
 	h.Stop()
-	return connect.NewResponse(&pb.StopStratumResponse{}), nil
+	return &pb.StopStratumResponse{}, nil
 }
 
 // Reset stops the server and forgets its blocks and its hashrate history,
@@ -323,18 +323,18 @@ func (h *StratumHandler) sourceFor(ctx context.Context, s orchestrator.StratumSe
 	case "", targetSolo:
 		node, err := h.newNode()
 		if err != nil {
-			return nil, nil, connect.NewError(connect.CodeInternal, err)
+			return nil, nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 		source, err := stratum.NewSoloSource(ctx, node, h.log)
 		if err != nil {
-			return nil, nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read a block template: %w", err))
+			return nil, nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("read a block template: %w", err).Error())
 		}
 		return source, nil, nil
 	case targetPool:
 		pool, ok := h.catalogPool(s.PoolID)
 		if !ok {
-			return nil, nil, connect.NewError(connect.CodeFailedPrecondition,
-				fmt.Errorf("the running network lists no pool %q", s.PoolID))
+			return nil, nil, connect.Errorf(connect.CodeFailedPrecondition,
+				"the running network lists no pool %q", s.PoolID)
 		}
 		address, err := h.payoutAddress(ctx)
 		if err != nil {
@@ -342,17 +342,17 @@ func (h *StratumHandler) sourceFor(ctx context.Context, s orchestrator.StratumSe
 		}
 		source, err := stratum.NewPoolSource(pool.url, address, catalogPoolWorkerPassword, h.log)
 		if err != nil {
-			return nil, nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 		return source, source, nil
 	case targetCustom:
 		source, err := stratum.NewPoolSource(s.URL, s.Worker, s.Password, h.log)
 		if err != nil {
-			return nil, nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 		return source, source, nil
 	}
-	return nil, nil, connect.NewError(connect.CodeInternal, fmt.Errorf("unknown stratum target %q", s.Target))
+	return nil, nil, connect.Errorf(connect.CodeInternal, "unknown stratum target %q", s.Target)
 }
 
 type catalogPool struct {
@@ -411,8 +411,8 @@ func (h *StratumHandler) catalogPool(id string) (catalogPool, bool) {
 }
 
 func (h *StratumHandler) ListTargets(
-	ctx context.Context, _ *connect.Request[pb.ListTargetsRequest],
-) (*connect.Response[pb.ListTargetsResponse], error) {
+	ctx context.Context, _ *pb.ListTargetsRequest,
+) (*pb.ListTargetsResponse, error) {
 	resp := &pb.ListTargetsResponse{}
 	for _, pool := range h.catalogPools() {
 		entry := &pb.CatalogPool{Id: pool.id, Name: pool.name, Url: pool.url, Fee: pool.fee}
@@ -421,7 +421,7 @@ func (h *StratumHandler) ListTargets(
 		}
 		resp.Pools = append(resp.Pools, entry)
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 type poolStatsEntry struct {
@@ -485,9 +485,9 @@ func (h *StratumHandler) fetchPoolStats(ctx context.Context, statsURL string) ([
 }
 
 func (h *StratumHandler) SetTarget(
-	ctx context.Context, req *connect.Request[pb.SetTargetRequest],
-) (*connect.Response[pb.SetTargetResponse], error) {
-	target := req.Msg.GetTarget()
+	ctx context.Context, req *pb.SetTargetRequest,
+) (*pb.SetTargetResponse, error) {
+	target := req.GetTarget()
 	h.opMu.Lock()
 	defer h.opMu.Unlock()
 
@@ -497,8 +497,8 @@ func (h *StratumHandler) SetTarget(
 		next.Target = targetSolo
 	case pb.TargetKind_TARGET_KIND_POOL:
 		if _, ok := h.catalogPool(target.GetPoolId()); !ok {
-			return nil, connect.NewError(connect.CodeInvalidArgument,
-				fmt.Errorf("the running network lists no pool %q", target.GetPoolId()))
+			return nil, connect.Errorf(connect.CodeInvalidArgument,
+				"the running network lists no pool %q", target.GetPoolId())
 		}
 		if _, err := h.payoutAddress(ctx); err != nil {
 			return nil, err
@@ -506,18 +506,18 @@ func (h *StratumHandler) SetTarget(
 		next.Target, next.PoolID = targetPool, target.GetPoolId()
 	case pb.TargetKind_TARGET_KIND_CUSTOM:
 		if _, err := stratum.ParsePoolURL(target.GetUrl()); err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 		if target.GetWorker() == "" {
-			return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("a custom pool needs a worker name"))
+			return nil, connect.NewError(connect.CodeInvalidArgument, "a custom pool needs a worker name")
 		}
 		next.Target, next.URL, next.Worker, next.Password = targetCustom, target.GetUrl(), target.GetWorker(), target.GetPassword()
 	default:
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("unknown target kind %s", target.GetKind()))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "unknown target kind %s", target.GetKind())
 	}
 
 	if next == h.settings.StratumSettings() {
-		return connect.NewResponse(&pb.SetTargetResponse{}), nil
+		return &pb.SetTargetResponse{}, nil
 	}
 	h.mu.Lock()
 	run := h.run
@@ -532,7 +532,7 @@ func (h *StratumHandler) SetTarget(
 		}
 	}
 	if err := h.settings.SetStratumSettings(next); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the stratum target: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the stratum target: %w", err).Error())
 	}
 	h.forgetPoolBlocks()
 	if run != nil {
@@ -541,7 +541,7 @@ func (h *StratumHandler) SetTarget(
 		run.pool = pool
 		h.mu.Unlock()
 	}
-	return connect.NewResponse(&pb.SetTargetResponse{}), nil
+	return &pb.SetTargetResponse{}, nil
 }
 
 func targetToProto(s orchestrator.StratumSettings) *pb.Target {
@@ -555,8 +555,8 @@ func targetToProto(s orchestrator.StratumSettings) *pb.Target {
 }
 
 func (h *StratumHandler) GetStratumStatus(
-	ctx context.Context, _ *connect.Request[pb.GetStratumStatusRequest],
-) (*connect.Response[pb.GetStratumStatusResponse], error) {
+	ctx context.Context, _ *pb.GetStratumStatusRequest,
+) (*pb.GetStratumStatusResponse, error) {
 	h.mu.Lock()
 	run, lastErr, blocks := h.run, h.lastErr, h.blocks
 	var pool *stratum.PoolSource
@@ -596,7 +596,7 @@ func (h *StratumHandler) GetStratumStatus(
 		resp.Running, resp.Port = true, run.port
 		ip, ok, err := stratum.LANIPv4()
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInternal, err)
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 		if ok {
 			resp.PoolUrl = fmt.Sprintf("stratum+tcp://%s", net.JoinHostPort(ip.String(), strconv.FormatUint(uint64(run.port), 10)))
@@ -631,7 +631,7 @@ func (h *StratumHandler) GetStratumStatus(
 		}
 		resp.BlocksFound = append(resp.BlocksFound, block)
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 func (h *StratumHandler) confirmations(ctx context.Context, hash string) (int32, error) {
@@ -697,30 +697,30 @@ func workModeFromProto(m pb.WorkMode) (cgminer.WorkMode, bool) {
 }
 
 func (h *StratumHandler) SetWorkMode(
-	ctx context.Context, req *connect.Request[pb.SetWorkModeRequest],
-) (*connect.Response[pb.SetWorkModeResponse], error) {
-	mode, ok := workModeFromProto(req.Msg.Mode)
+	ctx context.Context, req *pb.SetWorkModeRequest,
+) (*pb.SetWorkModeResponse, error) {
+	mode, ok := workModeFromProto(req.Mode)
 	if !ok {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("unknown work mode %s", req.Msg.Mode))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "unknown work mode %s", req.Mode)
 	}
 	h.mu.Lock()
 	run := h.run
 	h.mu.Unlock()
-	if run == nil || !hasMiner(run.server.Status().Miners, req.Msg.Address) {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("no miner connects from %q", req.Msg.Address))
+	if run == nil || !hasMiner(run.server.Status().Miners, req.Address) {
+		return nil, connect.Errorf(connect.CodeNotFound, "no miner connects from %q", req.Address)
 	}
 	ctx, cancel := context.WithTimeout(ctx, deviceTimeout)
 	defer cancel()
-	if err := h.setMode(ctx, req.Msg.Address, mode); err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("set the work mode of %s: %w", req.Msg.Address, err))
+	if err := h.setMode(ctx, req.Address, mode); err != nil {
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("set the work mode of %s: %w", req.Address, err).Error())
 	}
 	run.devicesMu.Lock()
-	if d, ok := run.devices[req.Msg.Address]; ok {
+	if d, ok := run.devices[req.Address]; ok {
 		d.WorkMode = &mode
-		run.devices[req.Msg.Address] = d
+		run.devices[req.Address] = d
 	}
 	run.devicesMu.Unlock()
-	return connect.NewResponse(&pb.SetWorkModeResponse{}), nil
+	return &pb.SetWorkModeResponse{}, nil
 }
 
 func hasMiner(miners []stratum.MinerStatus, address string) bool {
@@ -787,45 +787,45 @@ func (h *StratumHandler) pollDevices(ctx context.Context, run *stratumRun) {
 // hands the enforcer the same address, and it builds every coinbase.
 func (h *StratumHandler) payoutAddress(ctx context.Context) (string, error) {
 	if h.payout == nil {
-		return "", connect.NewError(connect.CodeFailedPrecondition, errors.New("no wallet to pay a block to"))
+		return "", connect.NewError(connect.CodeFailedPrecondition, "no wallet to pay a block to")
 	}
 	address, err := h.payout(ctx)
 	if err != nil {
-		return "", connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("get a payout address: %w", err))
+		return "", connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("get a payout address: %w", err).Error())
 	}
 	return address, nil
 }
 
 func (h *StratumHandler) SetMiningSettings(
-	ctx context.Context, req *connect.Request[pb.SetMiningSettingsRequest],
-) (*connect.Response[pb.SetMiningSettingsResponse], error) {
-	if req.Msg.Port != nil && (req.Msg.GetPort() < 1 || req.Msg.GetPort() > 65535) {
-		return nil, connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("port %d is out of range", req.Msg.GetPort()))
+	ctx context.Context, req *pb.SetMiningSettingsRequest,
+) (*pb.SetMiningSettingsResponse, error) {
+	if req.Port != nil && (req.GetPort() < 1 || req.GetPort() > 65535) {
+		return nil, connect.Errorf(connect.CodeInvalidArgument,
+			"port %d is out of range", req.GetPort())
 	}
-	if req.Msg.CpuThreads != nil && req.Msg.GetCpuThreads() > maxCPUThreads {
-		return nil, connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("a thread count of %d is over the limit of %d", req.Msg.GetCpuThreads(), maxCPUThreads))
+	if req.CpuThreads != nil && req.GetCpuThreads() > maxCPUThreads {
+		return nil, connect.Errorf(connect.CodeInvalidArgument,
+			"a thread count of %d is over the limit of %d", req.GetCpuThreads(), maxCPUThreads)
 	}
 
 	h.opMu.Lock()
 	defer h.opMu.Unlock()
 	current := h.settings.StratumSettings()
 	next := current
-	if req.Msg.Port != nil {
-		next.Port = req.Msg.GetPort()
+	if req.Port != nil {
+		next.Port = req.GetPort()
 	}
-	if req.Msg.CpuMining != nil {
-		next.CPUMining = req.Msg.GetCpuMining()
+	if req.CpuMining != nil {
+		next.CPUMining = req.GetCpuMining()
 	}
-	if req.Msg.CpuThreads != nil {
-		next.CPUThreads = req.Msg.GetCpuThreads()
+	if req.CpuThreads != nil {
+		next.CPUThreads = req.GetCpuThreads()
 	}
-	if req.Msg.KeepMiningOnClose != nil {
-		next.KeepMiningOnClose = req.Msg.GetKeepMiningOnClose()
+	if req.KeepMiningOnClose != nil {
+		next.KeepMiningOnClose = req.GetKeepMiningOnClose()
 	}
 	if next == current {
-		return connect.NewResponse(&pb.SetMiningSettingsResponse{}), nil
+		return &pb.SetMiningSettingsResponse{}, nil
 	}
 	if next.CPUMining {
 		if err := h.mineable(); err != nil {
@@ -844,9 +844,9 @@ func (h *StratumHandler) SetMiningSettings(
 		}
 		if err := h.settings.SetStratumSettings(next); err != nil {
 			h.stop()
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the mining settings: %w", err))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the mining settings: %w", err).Error())
 		}
-		return connect.NewResponse(&pb.SetMiningSettingsResponse{}), nil
+		return &pb.SetMiningSettingsResponse{}, nil
 	}
 
 	// A running server listens on the port it started on, so a new port needs
@@ -868,18 +868,18 @@ func (h *StratumHandler) SetMiningSettings(
 		if rebind {
 			_ = ready.listener.Close()
 		}
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the mining settings: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the mining settings: %w", err).Error())
 	}
 	if rebind {
 		h.stop()
 		h.serve(ready, next)
-		return connect.NewResponse(&pb.SetMiningSettingsResponse{}), nil
+		return &pb.SetMiningSettingsResponse{}, nil
 	}
 	if run != nil {
 		run.server.SetCPU(next.CPUMining, int(next.CPUThreads))
 	}
 	h.applyHold()
-	return connect.NewResponse(&pb.SetMiningSettingsResponse{}), nil
+	return &pb.SetMiningSettingsResponse{}, nil
 }
 
 func settingsToProto(s orchestrator.StratumSettings) *pb.MiningSettings {
@@ -937,9 +937,9 @@ func rangeOf(r pb.HashrateRange) stratum.Range {
 }
 
 func (h *StratumHandler) GetHashrateHistory(
-	_ context.Context, req *connect.Request[pb.GetHashrateHistoryRequest],
-) (*connect.Response[pb.GetHashrateHistoryResponse], error) {
-	points, peak := h.history.Read(rangeOf(req.Msg.GetRange()), time.Now())
+	_ context.Context, req *pb.GetHashrateHistoryRequest,
+) (*pb.GetHashrateHistoryResponse, error) {
+	points, peak := h.history.Read(rangeOf(req.GetRange()), time.Now())
 	resp := &pb.GetHashrateHistoryResponse{Peak: peak}
 	for _, p := range points {
 		resp.Points = append(resp.Points, &pb.HashratePoint{Time: timestamppb.New(p.At), Hashrate: p.Hashrate})
@@ -950,22 +950,22 @@ func (h *StratumHandler) GetHashrateHistory(
 	if run != nil {
 		resp.Current = run.server.Status().Hashrate
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 func (h *StratumHandler) ListPoolBlocks(
-	ctx context.Context, req *connect.Request[pb.ListPoolBlocksRequest],
-) (*connect.Response[pb.ListPoolBlocksResponse], error) {
-	limit := cmp.Or(req.Msg.GetLimit(), defaultPoolBlocks)
+	ctx context.Context, req *pb.ListPoolBlocksRequest,
+) (*pb.ListPoolBlocksResponse, error) {
+	limit := cmp.Or(req.GetLimit(), defaultPoolBlocks)
 	if cached := h.cachedPoolBlocks(limit); cached != nil {
-		return connect.NewResponse(cached), nil
+		return cached, nil
 	}
 	resp, err := h.readPoolBlocks(ctx, limit)
 	if err != nil {
 		return nil, err
 	}
 	h.keepPoolBlocks(limit, resp)
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 // cachedPoolBlocks returns the last list while it still stands.
@@ -1009,7 +1009,7 @@ func (h *StratumHandler) readPoolBlocks(ctx context.Context, limit uint32) (*pb.
 	}
 	blocksURL, err := stratum.PoolBlocksURL(pool.statsURL, int(limit))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 	blocks, err := stratum.FetchPoolBlocks(ctx, h.httpClient, blocksURL)
 	if err != nil {
diff --git a/sidechain-orchestrator/api/stratum_handler_test.go b/sidechain-orchestrator/api/stratum_handler_test.go
index 5fcd56185d..62878b76c9 100644
--- a/sidechain-orchestrator/api/stratum_handler_test.go
+++ b/sidechain-orchestrator/api/stratum_handler_test.go
@@ -15,7 +15,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/rs/zerolog"
@@ -126,24 +126,24 @@ func newTestStratumHandler(t *testing.T, network fakeStratumNetwork, settings *f
 func TestStratumHandlerStart(t *testing.T) {
 	t.Run("only on eCash", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "signet"}, &fakeStratumSettings{})
-		_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{}))
+		_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{})
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
 
 	t.Run("a node with no template fails the start", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, &fakeStratumSettings{})
-		_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{}))
+		_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{})
 		assert.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 		assert.ErrorContains(t, err, "the enforcer is not running")
 
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		assert.False(t, status.Msg.Running)
+		assert.False(t, status.Running)
 	})
 
 	t.Run("a port out of range", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, &fakeStratumSettings{})
-		_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{Port: 70000}))
+		_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{Port: 70000})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 
@@ -159,7 +159,7 @@ func TestStratumHandlerStart(t *testing.T) {
 			return net.Listen("tcp", "127.0.0.1:0")
 		}
 
-		_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{}))
+		_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{})
 		require.NoError(t, err)
 		assert.Equal(t, []uint32{3401}, ports)
 	})
@@ -170,33 +170,33 @@ func TestStratumHandlerTargets(t *testing.T) {
 
 	t.Run("the catalog pool of the running network", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, &fakeStratumSettings{})
-		resp, err := h.ListTargets(context.Background(), connect.NewRequest(&pb.ListTargetsRequest{}))
+		resp, err := h.ListTargets(context.Background(), &pb.ListTargetsRequest{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Pools, 1)
-		assert.Equal(t, "bip300", resp.Msg.Pools[0].Id)
-		assert.Equal(t, "bip300 pool", resp.Msg.Pools[0].Name)
-		assert.Equal(t, "stratum+tcp://pool.beta.bip300.xyz:3334", resp.Msg.Pools[0].Url)
+		require.Len(t, resp.Pools, 1)
+		assert.Equal(t, "bip300", resp.Pools[0].Id)
+		assert.Equal(t, "bip300 pool", resp.Pools[0].Name)
+		assert.Equal(t, "stratum+tcp://pool.beta.bip300.xyz:3334", resp.Pools[0].Url)
 	})
 
 	t.Run("a catalog pool pays the wallet of this install", func(t *testing.T) {
 		settings := &fakeStratumSettings{}
 		h, _ := newTestStratumHandler(t, network, settings)
 		pool := &pb.Target{Kind: pb.TargetKind_TARGET_KIND_POOL, PoolId: "bip300"}
-		_, err := h.SetTarget(context.Background(), connect.NewRequest(&pb.SetTargetRequest{Target: pool}))
+		_, err := h.SetTarget(context.Background(), &pb.SetTargetRequest{Target: pool})
 		require.NoError(t, err)
-		_, err = h.SetTarget(context.Background(), connect.NewRequest(&pb.SetTargetRequest{
+		_, err = h.SetTarget(context.Background(), &pb.SetTargetRequest{
 			Target: &pb.Target{Kind: pb.TargetKind_TARGET_KIND_SOLO},
-		}))
+		})
 		require.NoError(t, err)
-		_, err = h.SetTarget(context.Background(), connect.NewRequest(&pb.SetTargetRequest{Target: pool}))
+		_, err = h.SetTarget(context.Background(), &pb.SetTargetRequest{Target: pool})
 		require.NoError(t, err)
 
 		assert.Equal(t, orchestrator.StratumSettings{Target: "pool", PoolID: "bip300"}, settings.current)
 
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		assert.Equal(t, pb.TargetKind_TARGET_KIND_POOL, status.Msg.Target.Kind)
-		assert.Equal(t, "bc1qpayout", status.Msg.PayoutAddress)
+		assert.Equal(t, pb.TargetKind_TARGET_KIND_POOL, status.Target.Kind)
+		assert.Equal(t, "bc1qpayout", status.PayoutAddress)
 	})
 
 	t.Run("the same target again changes nothing", func(t *testing.T) {
@@ -204,7 +204,7 @@ func TestStratumHandlerTargets(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, settings)
 		pool := &pb.Target{Kind: pb.TargetKind_TARGET_KIND_POOL, PoolId: "bip300"}
 		for range 2 {
-			_, err := h.SetTarget(context.Background(), connect.NewRequest(&pb.SetTargetRequest{Target: pool}))
+			_, err := h.SetTarget(context.Background(), &pb.SetTargetRequest{Target: pool})
 			require.NoError(t, err)
 		}
 		assert.Equal(t, 1, settings.saves)
@@ -212,9 +212,9 @@ func TestStratumHandlerTargets(t *testing.T) {
 
 	t.Run("an unknown pool", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, &fakeStratumSettings{})
-		_, err := h.SetTarget(context.Background(), connect.NewRequest(&pb.SetTargetRequest{
+		_, err := h.SetTarget(context.Background(), &pb.SetTargetRequest{
 			Target: &pb.Target{Kind: pb.TargetKind_TARGET_KIND_POOL, PoolId: "nopool"},
-		}))
+		})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 
@@ -222,7 +222,7 @@ func TestStratumHandlerTargets(t *testing.T) {
 		settings := &fakeStratumSettings{}
 		h, _ := newTestStratumHandler(t, network, settings)
 		custom := &pb.Target{Kind: pb.TargetKind_TARGET_KIND_CUSTOM, Url: "stratum+tcp://pool.example.com:3333", Worker: "bc1qme.rig", Password: "x"}
-		_, err := h.SetTarget(context.Background(), connect.NewRequest(&pb.SetTargetRequest{Target: custom}))
+		_, err := h.SetTarget(context.Background(), &pb.SetTargetRequest{Target: custom})
 		require.NoError(t, err)
 		assert.Equal(t, "custom", settings.current.Target)
 		assert.Equal(t, "bc1qme.rig", settings.current.Worker)
@@ -232,7 +232,7 @@ func TestStratumHandlerTargets(t *testing.T) {
 			{Kind: pb.TargetKind_TARGET_KIND_CUSTOM, Url: "stratum+tcp://pool.example.com", Worker: "w"},
 			{Kind: pb.TargetKind_TARGET_KIND_CUSTOM, Url: "stratum+tcp://pool.example.com:3333"},
 		} {
-			_, err := h.SetTarget(context.Background(), connect.NewRequest(&pb.SetTargetRequest{Target: bad}))
+			_, err := h.SetTarget(context.Background(), &pb.SetTargetRequest{Target: bad})
 			assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 		}
 		assert.Equal(t, 1, settings.saves)
@@ -268,10 +268,10 @@ func TestListTargetsPoolHashrate(t *testing.T) {
 	h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash", entry: entry}, &fakeStratumSettings{})
 
 	for range 2 {
-		resp, err := h.ListTargets(context.Background(), connect.NewRequest(&pb.ListTargetsRequest{}))
+		resp, err := h.ListTargets(context.Background(), &pb.ListTargetsRequest{})
 		require.NoError(t, err)
-		require.NotNil(t, resp.Msg.Pools[0].Hashrate)
-		assert.InDelta(t, 16531755363981.977, *resp.Msg.Pools[0].Hashrate, 1e-3)
+		require.NotNil(t, resp.Pools[0].Hashrate)
+		assert.InDelta(t, 16531755363981.977, *resp.Pools[0].Hashrate, 1e-3)
 	}
 	assert.Equal(t, 1, requests)
 
@@ -282,16 +282,16 @@ func TestListTargetsPoolHashrate(t *testing.T) {
 		t.Cleanup(down.Close)
 		entry.Services.MiningPool.StatsURL = down.URL
 		h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash", entry: entry}, &fakeStratumSettings{})
-		resp, err := h.ListTargets(context.Background(), connect.NewRequest(&pb.ListTargetsRequest{}))
+		resp, err := h.ListTargets(context.Background(), &pb.ListTargetsRequest{})
 		require.NoError(t, err)
-		assert.Nil(t, resp.Msg.Pools[0].Hashrate)
+		assert.Nil(t, resp.Pools[0].Hashrate)
 	})
 
 	t.Run("a pool with no stats URL has no hashrate", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash", entry: betanetEntry()}, &fakeStratumSettings{})
-		resp, err := h.ListTargets(context.Background(), connect.NewRequest(&pb.ListTargetsRequest{}))
+		resp, err := h.ListTargets(context.Background(), &pb.ListTargetsRequest{})
 		require.NoError(t, err)
-		assert.Nil(t, resp.Msg.Pools[0].Hashrate)
+		assert.Nil(t, resp.Pools[0].Hashrate)
 	})
 }
 
@@ -315,12 +315,12 @@ func TestCatalogPoolIdentity(t *testing.T) {
 
 func TestStratumHandlerSetWorkMode(t *testing.T) {
 	h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, &fakeStratumSettings{})
-	_, err := h.SetWorkMode(context.Background(), connect.NewRequest(&pb.SetWorkModeRequest{
+	_, err := h.SetWorkMode(context.Background(), &pb.SetWorkModeRequest{
 		Address: "192.168.1.9", Mode: pb.WorkMode_WORK_MODE_LOW,
-	}))
+	})
 	assert.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 
-	_, err = h.SetWorkMode(context.Background(), connect.NewRequest(&pb.SetWorkModeRequest{Address: "192.168.1.9"}))
+	_, err = h.SetWorkMode(context.Background(), &pb.SetWorkModeRequest{Address: "192.168.1.9"})
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
 
@@ -330,10 +330,10 @@ func TestStratumHandlerFoundBlocks(t *testing.T) {
 	t.Run("confirmations from the node", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, &fakeStratumSettings{})
 		h.blocks = []stratum.Block{block}
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		require.Len(t, status.Msg.BlocksFound, 1)
-		assert.Equal(t, int32(3), status.Msg.BlocksFound[0].GetConfirmations())
+		require.Len(t, status.BlocksFound, 1)
+		assert.Equal(t, int32(3), status.BlocksFound[0].GetConfirmations())
 	})
 
 	t.Run("a node that does not answer leaves them unset", func(t *testing.T) {
@@ -342,20 +342,20 @@ func TestStratumHandlerFoundBlocks(t *testing.T) {
 			return nil, errors.New("rpc error -5: Block not found")
 		}
 		h.blocks = []stratum.Block{block}
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		require.Len(t, status.Msg.BlocksFound, 1)
-		assert.Nil(t, status.Msg.BlocksFound[0].Confirmations)
+		require.Len(t, status.BlocksFound, 1)
+		assert.Nil(t, status.BlocksFound[0].Confirmations)
 	})
 
 	t.Run("a network reset forgets them", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, &fakeStratumSettings{})
 		h.blocks, h.lastErr = []stratum.Block{block}, "no block template"
 		h.Reset(t.TempDir())
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		assert.Empty(t, status.Msg.BlocksFound)
-		assert.Empty(t, status.Msg.Error)
+		assert.Empty(t, status.BlocksFound)
+		assert.Empty(t, status.Error)
 	})
 }
 
@@ -378,34 +378,34 @@ func TestStratumHandlerRun(t *testing.T) {
 	h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, &fakeStratumSettings{})
 	h.newNode = func() (stratum.Node, error) { return templateNode{}, nil }
 
-	_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{Port: 3333}))
+	_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{Port: 3333})
 	require.NoError(t, err)
 
 	t.Run("a second start on the same port changes nothing", func(t *testing.T) {
-		_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{Port: 3333}))
+		_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{Port: 3333})
 		require.NoError(t, err)
 	})
 
 	t.Run("a start on another port", func(t *testing.T) {
-		_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{Port: 4444}))
+		_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{Port: 4444})
 		assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	})
 
-	var status *connect.Response[pb.GetStratumStatusResponse]
+	var status *pb.GetStratumStatusResponse
 	require.Eventually(t, func() bool {
-		status, err = h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
-		return err == nil && status.Msg.NetworkDifficulty > 0
+		status, err = h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
+		return err == nil && status.NetworkDifficulty > 0
 	}, 5*time.Second, 10*time.Millisecond)
-	assert.True(t, status.Msg.Running)
-	assert.Equal(t, uint32(3333), status.Msg.Port)
-	assert.Equal(t, pb.TargetKind_TARGET_KIND_SOLO, status.Msg.Target.Kind)
+	assert.True(t, status.Running)
+	assert.Equal(t, uint32(3333), status.Port)
+	assert.Equal(t, pb.TargetKind_TARGET_KIND_SOLO, status.Target.Kind)
 
-	_, err = h.StopStratum(context.Background(), connect.NewRequest(&pb.StopStratumRequest{}))
+	_, err = h.StopStratum(context.Background(), &pb.StopStratumRequest{})
 	require.NoError(t, err)
-	status, err = h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+	status, err = h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 	require.NoError(t, err)
-	assert.False(t, status.Msg.Running)
-	assert.Empty(t, status.Msg.Error)
+	assert.False(t, status.Running)
+	assert.Empty(t, status.Error)
 }
 
 // The daemon pays a mined block to a bitwindow wallet address. The page shows
@@ -416,18 +416,18 @@ func TestStratumHandlerPayout(t *testing.T) {
 	t.Run("the status reads the address the daemon pays", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, &fakeStratumSettings{})
 
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		assert.Equal(t, "bc1qpayout", status.Msg.PayoutAddress)
+		assert.Equal(t, "bc1qpayout", status.PayoutAddress)
 	})
 
 	t.Run("a wallet that derives none leaves the address empty", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, &fakeStratumSettings{})
 		h.payout = func(context.Context) (string, error) { return "", errors.New("no wallet") }
 
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		assert.Empty(t, status.Msg.PayoutAddress)
+		assert.Empty(t, status.PayoutAddress)
 	})
 }
 
@@ -441,34 +441,34 @@ func TestStratumHandlerMiningSettings(t *testing.T) {
 		t.Cleanup(h.Stop)
 
 		on := true
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 			CpuMining: &on,
-		}))
+		})
 		require.NoError(t, err)
 
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		assert.True(t, status.Msg.Running)
-		assert.True(t, status.Msg.Settings.CpuMining)
-		assert.Equal(t, uint32(3333), status.Msg.Settings.Port)
+		assert.True(t, status.Running)
+		assert.True(t, status.Settings.CpuMining)
+		assert.Equal(t, uint32(3333), status.Settings.Port)
 
 		t.Run("and the row leaves when the switch goes off", func(t *testing.T) {
 			require.Eventually(t, func() bool {
-				status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
-				return err == nil && len(status.Msg.Miners) == 1 &&
-					status.Msg.Miners[0].Worker == stratum.CPUWorker &&
-					status.Msg.Miners[0].Address == stratum.CPUAddress
+				status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
+				return err == nil && len(status.Miners) == 1 &&
+					status.Miners[0].Worker == stratum.CPUWorker &&
+					status.Miners[0].Address == stratum.CPUAddress
 			}, 30*time.Second, 50*time.Millisecond)
 
 			off := false
-			_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+			_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 				CpuMining: &off,
-			}))
+			})
 			require.NoError(t, err)
 
 			require.Eventually(t, func() bool {
-				status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
-				return err == nil && len(status.Msg.Miners) == 0 && !status.Msg.Settings.CpuMining
+				status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
+				return err == nil && len(status.Miners) == 0 && !status.Settings.CpuMining
 			}, 10*time.Second, 50*time.Millisecond)
 		})
 	})
@@ -478,27 +478,27 @@ func TestStratumHandlerMiningSettings(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, settings)
 
 		port, threads, keep := uint32(3401), uint32(2), true
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 			Port:              &port,
 			CpuThreads:        &threads,
 			KeepMiningOnClose: &keep,
-		}))
+		})
 		require.NoError(t, err)
 
 		assert.Equal(t, uint32(3401), settings.current.Port)
 		assert.Equal(t, uint32(2), settings.current.CPUThreads)
 		assert.True(t, settings.current.KeepMiningOnClose)
 
-		status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 		require.NoError(t, err)
-		assert.False(t, status.Msg.Running)
-		assert.True(t, status.Msg.Settings.KeepMiningOnClose)
+		assert.False(t, status.Running)
+		assert.True(t, status.Settings.KeepMiningOnClose)
 	})
 
 	t.Run("a port out of range", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, &fakeStratumSettings{})
 		port := uint32(70000)
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{Port: &port}))
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{Port: &port})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	})
 }
@@ -539,18 +539,18 @@ func TestStratumHandlerPoolBlocks(t *testing.T) {
 
 	t.Run("a solo target lists none", func(t *testing.T) {
 		h, _ := newTestStratumHandler(t, network, &fakeStratumSettings{})
-		resp, err := h.ListPoolBlocks(context.Background(), connect.NewRequest(&pb.ListPoolBlocksRequest{}))
+		resp, err := h.ListPoolBlocks(context.Background(), &pb.ListPoolBlocksRequest{})
 		require.NoError(t, err)
-		assert.Empty(t, resp.Msg.Blocks)
-		assert.Contains(t, resp.Msg.Unavailable, "a pool from the catalog only")
+		assert.Empty(t, resp.Blocks)
+		assert.Contains(t, resp.Unavailable, "a pool from the catalog only")
 	})
 
 	t.Run("a pool with no stats URL", func(t *testing.T) {
 		settings := &fakeStratumSettings{current: orchestrator.StratumSettings{Target: "pool", PoolID: "bip300"}}
 		h, _ := newTestStratumHandler(t, network, settings)
-		resp, err := h.ListPoolBlocks(context.Background(), connect.NewRequest(&pb.ListPoolBlocksRequest{}))
+		resp, err := h.ListPoolBlocks(context.Background(), &pb.ListPoolBlocksRequest{})
 		require.NoError(t, err)
-		assert.Contains(t, resp.Msg.Unavailable, "publishes no block list")
+		assert.Contains(t, resp.Unavailable, "publishes no block list")
 	})
 }
 
@@ -558,13 +558,13 @@ func TestStratumHandlerHashrateHistory(t *testing.T) {
 	h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, &fakeStratumSettings{})
 	h.history.Record(4.2e6, time.Now())
 
-	resp, err := h.GetHashrateHistory(context.Background(), connect.NewRequest(&pb.GetHashrateHistoryRequest{
+	resp, err := h.GetHashrateHistory(context.Background(), &pb.GetHashrateHistoryRequest{
 		Range: pb.HashrateRange_HASHRATE_RANGE_HOUR,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Len(t, resp.Msg.Points, 60)
-	assert.Equal(t, 4.2e6, resp.Msg.Peak)
-	assert.Zero(t, resp.Msg.Current)
+	assert.Len(t, resp.Points, 60)
+	assert.Equal(t, 4.2e6, resp.Peak)
+	assert.Zero(t, resp.Current)
 }
 
 // A pool credits a block to the one worker name this installation uses
@@ -593,31 +593,31 @@ func TestStratumHandlerHoldsTheDaemon(t *testing.T) {
 		return func() { holds.Add(-1) }
 	}
 
-	_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{}))
+	_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{})
 	require.NoError(t, err)
 	assert.Zero(t, holds.Load(), "a server alone holds nothing")
 
 	keep := true
-	_, err = h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+	_, err = h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 		KeepMiningOnClose: &keep,
-	}))
+	})
 	require.NoError(t, err)
 	assert.Equal(t, int64(1), holds.Load())
 
 	t.Run("the setting off gives the daemon back", func(t *testing.T) {
 		keep := false
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 			KeepMiningOnClose: &keep,
-		}))
+		})
 		require.NoError(t, err)
 		assert.Zero(t, holds.Load())
 	})
 
 	t.Run("a stop gives the daemon back", func(t *testing.T) {
 		keep := true
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 			KeepMiningOnClose: &keep,
-		}))
+		})
 		require.NoError(t, err)
 		require.Equal(t, int64(1), holds.Load())
 
@@ -632,24 +632,24 @@ func TestStratumHandlerKeepsTheSwitchOffOnAFailedStart(t *testing.T) {
 	h, _ := newTestStratumHandler(t, fakeStratumNetwork{network: "ecash"}, settings)
 
 	on := true
-	_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+	_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 		CpuMining: &on,
-	}))
+	})
 	require.Error(t, err)
 	assert.False(t, settings.current.CPUMining)
 
-	status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+	status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 	require.NoError(t, err)
-	assert.False(t, status.Msg.Settings.CpuMining)
+	assert.False(t, status.Settings.CpuMining)
 
 	t.Run("and a second try still reaches the start", func(t *testing.T) {
 		h.newNode = func() (stratum.Node, error) { return servedNode{}, nil }
 		t.Cleanup(func() { h.Stop() })
 
 		on := true
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 			CpuMining: &on,
-		}))
+		})
 		require.NoError(t, err)
 		assert.True(t, settings.current.CPUMining)
 	})
@@ -668,26 +668,26 @@ func TestStratumHandlerPortChangeRebinds(t *testing.T) {
 		return net.Listen("tcp", "127.0.0.1:0")
 	}
 
-	_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{Port: 3333}))
+	_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{Port: 3333})
 	require.NoError(t, err)
 
 	port := uint32(3401)
-	_, err = h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+	_, err = h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 		Port: &port,
-	}))
+	})
 	require.NoError(t, err)
 
 	assert.Equal(t, []uint32{3333, 3401}, ports)
-	status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+	status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 	require.NoError(t, err)
-	assert.True(t, status.Msg.Running)
-	assert.Equal(t, uint32(3401), status.Msg.Port)
+	assert.True(t, status.Running)
+	assert.Equal(t, uint32(3401), status.Port)
 
 	t.Run("a setting that is no port leaves the listener alone", func(t *testing.T) {
 		threads := uint32(3)
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 			CpuThreads: &threads,
-		}))
+		})
 		require.NoError(t, err)
 		assert.Equal(t, []uint32{3333, 3401}, ports)
 	})
@@ -695,10 +695,10 @@ func TestStratumHandlerPortChangeRebinds(t *testing.T) {
 	t.Run("the port the server already listens on leaves it alone", func(t *testing.T) {
 		same := uint32(3401)
 		keep := true
-		_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+		_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 			Port:              &same,
 			KeepMiningOnClose: &keep,
-		}))
+		})
 		require.NoError(t, err)
 		assert.Equal(t, []uint32{3333, 3401}, ports)
 	})
@@ -710,21 +710,21 @@ func TestStratumHandlerKeepsTheListenerOnAFailedRebind(t *testing.T) {
 	h.newNode = func() (stratum.Node, error) { return servedNode{}, nil }
 	t.Cleanup(h.Stop)
 
-	_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{Port: 3333}))
+	_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{Port: 3333})
 	require.NoError(t, err)
 	h.listen = func(uint32) (net.Listener, error) { return nil, errors.New("address already in use") }
 
 	port := uint32(3401)
-	_, err = h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+	_, err = h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 		Port: &port,
-	}))
+	})
 	require.Error(t, err)
 
-	status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+	status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 	require.NoError(t, err)
-	assert.True(t, status.Msg.Running)
-	assert.Equal(t, uint32(3333), status.Msg.Port)
-	assert.Equal(t, uint32(3333), status.Msg.Settings.Port)
+	assert.True(t, status.Running)
+	assert.Equal(t, uint32(3333), status.Port)
+	assert.Equal(t, uint32(3333), status.Settings.Port)
 }
 
 // A save that fails after a start must leave no hasher behind.
@@ -735,15 +735,15 @@ func TestStratumHandlerStopsTheHasherWhenTheSaveFails(t *testing.T) {
 	t.Cleanup(h.Stop)
 
 	on := true
-	_, err := h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+	_, err := h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 		CpuMining: &on,
-	}))
+	})
 	require.ErrorContains(t, err, "the disk is full")
 
-	status, err := h.GetStratumStatus(context.Background(), connect.NewRequest(&pb.GetStratumStatusRequest{}))
+	status, err := h.GetStratumStatus(context.Background(), &pb.GetStratumStatusRequest{})
 	require.NoError(t, err)
-	assert.False(t, status.Msg.Running)
-	assert.False(t, status.Msg.Settings.CpuMining)
+	assert.False(t, status.Running)
+	assert.False(t, status.Settings.CpuMining)
 }
 
 // Every row of the pool block list costs a block read from the node, and the
@@ -763,14 +763,14 @@ func TestStratumHandlerCachesThePoolBlocks(t *testing.T) {
 	h, _ := newTestStratumHandler(t, network, settings)
 
 	for range 5 {
-		_, err := h.ListPoolBlocks(context.Background(), connect.NewRequest(&pb.ListPoolBlocksRequest{}))
+		_, err := h.ListPoolBlocks(context.Background(), &pb.ListPoolBlocksRequest{})
 		require.NoError(t, err)
 	}
 	assert.Equal(t, 1, reads)
 
 	t.Run("a target change asks the pool again", func(t *testing.T) {
 		h.forgetPoolBlocks()
-		_, err := h.ListPoolBlocks(context.Background(), connect.NewRequest(&pb.ListPoolBlocksRequest{}))
+		_, err := h.ListPoolBlocks(context.Background(), &pb.ListPoolBlocksRequest{})
 		require.NoError(t, err)
 		assert.Equal(t, 2, reads)
 	})
@@ -790,11 +790,11 @@ func TestStratumHandlerCachesThePoolBlocks(t *testing.T) {
 		entry.Services.MiningPool.StatsURL = pool.URL + "/api/overview"
 		h.network = fakeStratumNetwork{network: "ecash", entry: entry}
 
-		resp, err := h.ListPoolBlocks(context.Background(), connect.NewRequest(&pb.ListPoolBlocksRequest{}))
+		resp, err := h.ListPoolBlocks(context.Background(), &pb.ListPoolBlocksRequest{})
 		require.NoError(t, err)
-		require.Len(t, resp.Msg.Blocks, 1)
-		assert.Nil(t, resp.Msg.Blocks[0].MyPayoutSats)
-		assert.Nil(t, resp.Msg.Blocks[0].Confirmations)
+		require.Len(t, resp.Blocks, 1)
+		assert.Nil(t, resp.Blocks[0].MyPayoutSats)
+		assert.Nil(t, resp.Blocks[0].Confirmations)
 	})
 
 }
@@ -813,15 +813,15 @@ func TestStratumHandlerDefaultPortNeedsNoRebind(t *testing.T) {
 		return net.Listen("tcp", "127.0.0.1:0")
 	}
 
-	_, err := h.StartStratum(context.Background(), connect.NewRequest(&pb.StartStratumRequest{}))
+	_, err := h.StartStratum(context.Background(), &pb.StartStratumRequest{})
 	require.NoError(t, err)
 	require.Zero(t, settings.current.Port)
 
 	port, threads := uint32(defaultStratumPort), uint32(2)
-	_, err = h.SetMiningSettings(context.Background(), connect.NewRequest(&pb.SetMiningSettingsRequest{
+	_, err = h.SetMiningSettings(context.Background(), &pb.SetMiningSettingsRequest{
 		Port:       &port,
 		CpuThreads: &threads,
-	}))
+	})
 	require.NoError(t, err)
 
 	assert.Equal(t, []uint32{defaultStratumPort}, ports)
diff --git a/sidechain-orchestrator/api/thunder_mempool_balance_test.go b/sidechain-orchestrator/api/thunder_mempool_balance_test.go
index 14346646a0..5650b94fb7 100644
--- a/sidechain-orchestrator/api/thunder_mempool_balance_test.go
+++ b/sidechain-orchestrator/api/thunder_mempool_balance_test.go
@@ -8,7 +8,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -108,12 +108,12 @@ func TestThunderBalanceTracksMempoolSpendAndReceipt(t *testing.T) {
 							handler := NewHandler(orch)
 							handler.SetSidechainBalance("thunder", sidechain.NewJSONRPCProxy(host, port).GetBalance)
 
-							response, err := handler.GetSidechainBalance(context.Background(), connect.NewRequest(&pb.GetSidechainBalanceRequest{
+							response, err := handler.GetSidechainBalance(context.Background(), &pb.GetSidechainBalanceRequest{
 								Sidechain: pb.BinaryType_BINARY_TYPE_THUNDER,
-							}))
+							})
 							require.NoError(t, err)
-							assert.Equal(t, state.wantConfirmed, response.Msg.ConfirmedSats)
-							assert.Equal(t, state.wantPending, response.Msg.PendingSats)
+							assert.Equal(t, state.wantConfirmed, response.ConfirmedSats)
+							assert.Equal(t, state.wantPending, response.PendingSats)
 						})
 					}
 				})
@@ -158,9 +158,9 @@ func TestThunderBalanceReportsAMempoolFault(t *testing.T) {
 	handler := NewHandler(orch)
 	handler.SetSidechainBalance("thunder", sidechain.NewJSONRPCProxy(host, port).GetBalance)
 
-	response, err := handler.GetSidechainBalance(t.Context(), connect.NewRequest(&pb.GetSidechainBalanceRequest{
+	response, err := handler.GetSidechainBalance(t.Context(), &pb.GetSidechainBalanceRequest{
 		Sidechain: pb.BinaryType_BINARY_TYPE_THUNDER,
-	}))
+	})
 	require.ErrorContains(t, err, "request timed out")
 	assert.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	assert.Nil(t, response)
diff --git a/sidechain-orchestrator/api/transaction_warning_test.go b/sidechain-orchestrator/api/transaction_warning_test.go
index 95b31de08d..1a9ebda4e4 100644
--- a/sidechain-orchestrator/api/transaction_warning_test.go
+++ b/sidechain-orchestrator/api/transaction_warning_test.go
@@ -9,7 +9,7 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/psbt"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -212,11 +212,11 @@ func TestDecodeTransactionReturnsTheBurnWarning(t *testing.T) {
 			if !explicitWallet {
 				walletID = ""
 			}
-			response, err := h.DecodeTransaction(context.Background(), connect.NewRequest(&pb.DecodeTransactionRequest{
+			response, err := h.DecodeTransaction(context.Background(), &pb.DecodeTransactionRequest{
 				Input: input, WalletId: walletID,
-			}))
+			})
 			require.NoError(t, err)
-			require.Equal(t, warningTestMessage, response.Msg.WarningMessage)
+			require.Equal(t, warningTestMessage, response.WarningMessage)
 		}
 	}
 }
@@ -225,11 +225,11 @@ func TestGetTransactionDetailsReturnsTheBurnWarning(t *testing.T) {
 	raw, _, tx := warningTransaction(t, warningOutputs(t))
 	backend := &warningBackend{detailsProvider: detailsProvider{rawTx: tx}, hexByID: map[string]string{tx.TxID: raw}}
 	h, walletID := newWarningHandler(t, backend)
-	response, err := h.GetTransactionDetails(context.Background(), connect.NewRequest(&pb.GetTransactionDetailsRequest{
+	response, err := h.GetTransactionDetails(context.Background(), &pb.GetTransactionDetailsRequest{
 		WalletId: walletID, Txid: tx.TxID,
-	}))
+	})
 	require.NoError(t, err)
-	require.Equal(t, warningTestMessage, response.Msg.Transaction.WarningMessage)
+	require.Equal(t, warningTestMessage, response.Transaction.WarningMessage)
 	require.Equal(t, []string{tx.TxID}, backend.readIDs)
 }
 
@@ -249,20 +249,20 @@ func TestListTransactionsWarnsAllRowsAndReadsEachTransactionOnce(t *testing.T) {
 		},
 	}
 	h, walletID := newWarningHandler(t, backend)
-	response, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{WalletId: walletID}))
+	response, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{WalletId: walletID})
 	require.NoError(t, err)
 	require.Equal(t, []string{tx.TxID, ordinaryTx.TxID, paymentTx.TxID}, backend.readIDs)
 	require.Equal(t, walletID, backend.walletID)
-	for _, entry := range response.Msg.Transactions {
+	for _, entry := range response.Transactions {
 		if entry.Txid == tx.TxID {
 			require.Equal(t, warningTestMessage, entry.WarningMessage)
 		} else {
 			require.Empty(t, entry.WarningMessage)
 		}
 	}
-	repeated, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{WalletId: walletID}))
+	repeated, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{WalletId: walletID})
 	require.NoError(t, err)
-	require.Equal(t, response.Msg, repeated.Msg)
+	require.Equal(t, response, repeated)
 	require.Equal(t, []string{tx.TxID, ordinaryTx.TxID, paymentTx.TxID}, backend.readIDs)
 }
 
@@ -278,13 +278,13 @@ func TestListTransactionsWarnsWithoutTheBurnAddressRow(t *testing.T) {
 		},
 	}
 	h, walletID := newWarningHandler(t, backend)
-	response, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{
+	response, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{
 		WalletId: walletID, Count: 1,
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, response.Msg.Transactions, 1)
-	require.Empty(t, response.Msg.Transactions[0].Address)
-	require.Equal(t, warningTestMessage, response.Msg.Transactions[0].WarningMessage)
+	require.Len(t, response.Transactions, 1)
+	require.Empty(t, response.Transactions[0].Address)
+	require.Equal(t, warningTestMessage, response.Transactions[0].WarningMessage)
 	require.Equal(t, []string{tx.TxID}, backend.readIDs)
 }
 
@@ -298,12 +298,12 @@ func TestListTransactionsKeepsTheCacheAcrossNetworkChanges(t *testing.T) {
 		afterRead: func() { config.SetECashNetworkID("betanet") },
 	}
 	h, walletID := newWarningHandler(t, backend)
-	_, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{WalletId: walletID}))
+	_, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{WalletId: walletID})
 	require.NoError(t, err)
 	config.SetECashNetworkID("alphanet")
-	response, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{WalletId: walletID}))
+	response, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{WalletId: walletID})
 	require.NoError(t, err)
-	require.Equal(t, warningTestMessage, response.Msg.Transactions[0].WarningMessage)
+	require.Equal(t, warningTestMessage, response.Transactions[0].WarningMessage)
 	require.Equal(t, []string{tx.TxID}, backend.readIDs)
 }
 
@@ -325,9 +325,9 @@ func TestListTransactionsNamesTheNetworkOfEachRead(t *testing.T) {
 		{"alphanet", warningTestMessage},
 	} {
 		config.SetECashNetworkID(tc.id)
-		response, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{WalletId: walletID}))
+		response, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{WalletId: walletID})
 		require.NoError(t, err)
-		require.Equal(t, tc.message, response.Msg.Transactions[0].WarningMessage)
+		require.Equal(t, tc.message, response.Transactions[0].WarningMessage)
 	}
 	require.Equal(t, []string{tx.TxID, tx.TxID}, backend.readIDs)
 }
@@ -348,7 +348,7 @@ func TestListTransactionsReturnsWarningReadErrors(t *testing.T) {
 				hexByID:      map[string]string{"burn": tc.raw}, readError: tc.err,
 			}
 			h, walletID := newWarningHandler(t, backend)
-			response, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{WalletId: walletID}))
+			response, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{WalletId: walletID})
 			require.Nil(t, response)
 			require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 		})
@@ -374,9 +374,9 @@ func TestListTransactionsSkipsWarningsOutsideBurnNetworks(t *testing.T) {
 			h, walletID := newWarningHandler(t, backend)
 			require.NoError(t, h.svc.RebindNetwork(string(tc.network)))
 			config.SetECashNetworkID(tc.id)
-			response, err := h.ListTransactions(context.Background(), connect.NewRequest(&pb.ListTransactionsRequest{WalletId: walletID}))
+			response, err := h.ListTransactions(context.Background(), &pb.ListTransactionsRequest{WalletId: walletID})
 			require.NoError(t, err)
-			require.Empty(t, response.Msg.Transactions[0].WarningMessage)
+			require.Empty(t, response.Transactions[0].WarningMessage)
 			require.Empty(t, backend.readIDs)
 		})
 	}
diff --git a/sidechain-orchestrator/api/wallet_handler.go b/sidechain-orchestrator/api/wallet_handler.go
index e887702a48..fa5a75fe62 100644
--- a/sidechain-orchestrator/api/wallet_handler.go
+++ b/sidechain-orchestrator/api/wallet_handler.go
@@ -14,7 +14,7 @@ import (
 	"time"
 
 	"buf.build/go/protovalidate"
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/samber/lo"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -129,70 +129,70 @@ func (h *WalletHandler) bip47NetParams() *chaincfg.Params {
 // Wallet lifecycle RPCs
 // ============================================================================
 
-func (h *WalletHandler) GetWalletStatus(ctx context.Context, req *connect.Request[pb.GetWalletStatusRequest]) (*connect.Response[pb.GetWalletStatusResponse], error) {
+func (h *WalletHandler) GetWalletStatus(ctx context.Context, req *pb.GetWalletStatusRequest) (*pb.GetWalletStatusResponse, error) {
 	state := h.svc.State()
-	return connect.NewResponse(&pb.GetWalletStatusResponse{
+	return &pb.GetWalletStatusResponse{
 		HasWallet:        state != wallet.StateNoWallet, //nolint:staticcheck // old apps read it
 		Encrypted:        h.svc.IsEncrypted(),
 		Unlocked:         state == wallet.StateUnlocked, //nolint:staticcheck // old apps read it
 		ActiveWalletId:   h.svc.ActiveWalletID(),
 		ActiveWalletName: h.svc.ActiveWalletName(),
 		State:            walletStateToProto(state),
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) GenerateWallet(ctx context.Context, req *connect.Request[pb.GenerateWalletRequest]) (*connect.Response[pb.GenerateWalletResponse], error) {
-	account, path, err := wallet.ResolveCreateDerivationPath(req.Msg.Account, req.Msg.DerivationPath)
+func (h *WalletHandler) GenerateWallet(ctx context.Context, req *pb.GenerateWalletRequest) (*pb.GenerateWalletResponse, error) {
+	account, path, err := wallet.ResolveCreateDerivationPath(req.Account, req.DerivationPath)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	if _, err := wallet.ResolveScriptType(req.Msg.ScriptType, path); err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	if _, err := wallet.ResolveScriptType(req.ScriptType, path); err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	w, err := h.svc.GenerateWalletWithPath(req.Msg.Name, req.Msg.CustomMnemonic, req.Msg.Passphrase, account, path, req.Msg.ScriptType, allSidechainSlots())
+	w, err := h.svc.GenerateWalletWithPath(req.Name, req.CustomMnemonic, req.Passphrase, account, path, req.ScriptType, allSidechainSlots())
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.GenerateWalletResponse{
+	return &pb.GenerateWalletResponse{
 		WalletId: w.ID,
 		Mnemonic: w.Master.Mnemonic,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) UnlockWallet(ctx context.Context, req *connect.Request[pb.UnlockWalletRequest]) (*connect.Response[pb.UnlockWalletResponse], error) {
-	if err := h.svc.UnlockWallet(req.Msg.Password); err != nil {
+func (h *WalletHandler) UnlockWallet(ctx context.Context, req *pb.UnlockWalletRequest) (*pb.UnlockWalletResponse, error) {
+	if err := h.svc.UnlockWallet(req.Password); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.UnlockWalletResponse{}), nil
+	return &pb.UnlockWalletResponse{}, nil
 }
 
-func (h *WalletHandler) LockWallet(ctx context.Context, req *connect.Request[pb.LockWalletRequest]) (*connect.Response[pb.LockWalletResponse], error) {
+func (h *WalletHandler) LockWallet(ctx context.Context, req *pb.LockWalletRequest) (*pb.LockWalletResponse, error) {
 	h.svc.LockWallet()
-	return connect.NewResponse(&pb.LockWalletResponse{}), nil
+	return &pb.LockWalletResponse{}, nil
 }
 
-func (h *WalletHandler) EncryptWallet(ctx context.Context, req *connect.Request[pb.EncryptWalletRequest]) (*connect.Response[pb.EncryptWalletResponse], error) {
-	if err := h.svc.EncryptWallet(req.Msg.Password); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+func (h *WalletHandler) EncryptWallet(ctx context.Context, req *pb.EncryptWalletRequest) (*pb.EncryptWalletResponse, error) {
+	if err := h.svc.EncryptWallet(req.Password); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.EncryptWalletResponse{}), nil
+	return &pb.EncryptWalletResponse{}, nil
 }
 
-func (h *WalletHandler) ChangePassword(ctx context.Context, req *connect.Request[pb.ChangePasswordRequest]) (*connect.Response[pb.ChangePasswordResponse], error) {
-	if err := h.svc.ChangePassword(req.Msg.OldPassword, req.Msg.NewPassword); err != nil {
+func (h *WalletHandler) ChangePassword(ctx context.Context, req *pb.ChangePasswordRequest) (*pb.ChangePasswordResponse, error) {
+	if err := h.svc.ChangePassword(req.OldPassword, req.NewPassword); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.ChangePasswordResponse{}), nil
+	return &pb.ChangePasswordResponse{}, nil
 }
 
-func (h *WalletHandler) RemoveEncryption(ctx context.Context, req *connect.Request[pb.RemoveEncryptionRequest]) (*connect.Response[pb.RemoveEncryptionResponse], error) {
-	if err := h.svc.RemoveEncryption(req.Msg.Password); err != nil {
+func (h *WalletHandler) RemoveEncryption(ctx context.Context, req *pb.RemoveEncryptionRequest) (*pb.RemoveEncryptionResponse, error) {
+	if err := h.svc.RemoveEncryption(req.Password); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.RemoveEncryptionResponse{}), nil
+	return &pb.RemoveEncryptionResponse{}, nil
 }
 
-func (h *WalletHandler) ListWallets(ctx context.Context, req *connect.Request[pb.ListWalletsRequest]) (*connect.Response[pb.ListWalletsResponse], error) {
+func (h *WalletHandler) ListWallets(ctx context.Context, req *pb.ListWalletsRequest) (*pb.ListWalletsResponse, error) {
 	// Use GetAllWallets so we can access the seed for BIP47 derivation —
 	// parity with sendWalletData. ListWallets (metadata-only) can't see it.
 	wallets := h.svc.GetAllWallets()
@@ -234,10 +234,10 @@ func (h *WalletHandler) ListWallets(ctx context.Context, req *connect.Request[pb
 			DerivationPath:      w.DerivationPath,
 		}
 	}
-	return connect.NewResponse(&pb.ListWalletsResponse{
+	return &pb.ListWalletsResponse{
 		Wallets:        pbWallets,
 		ActiveWalletId: h.svc.ActiveWalletID(),
-	}), nil
+	}, nil
 }
 
 // receiveAddressTypesProto lists the address types a wallet derives, its own
@@ -255,35 +255,35 @@ func receiveAddressTypesProto(w *wallet.WalletData) []pb.AddressType {
 	})
 }
 
-func (h *WalletHandler) SwitchWallet(ctx context.Context, req *connect.Request[pb.SwitchWalletRequest]) (*connect.Response[pb.SwitchWalletResponse], error) {
+func (h *WalletHandler) SwitchWallet(ctx context.Context, req *pb.SwitchWalletRequest) (*pb.SwitchWalletResponse, error) {
 	// Switching onto a Core/enforcer wallet is what makes the local chain
 	// necessary, so it goes through the same planner a network swap does.
 	if h.orch != nil {
-		if dataDir := strings.TrimSpace(req.Msg.DataDir); dataDir != "" {
+		if dataDir := strings.TrimSpace(req.DataDir); dataDir != "" {
 			// Persisting an unusable directory would satisfy the planner and
 			// then stop prompting, with no chain to run from.
 			if err := validateDirWritable(dataDir); err != nil {
-				return nil, connect.NewError(connect.CodeInvalidArgument, err)
+				return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 			}
 			if err := h.orch.SetDatadirForCurrentNetwork(dataDir); err != nil {
-				return nil, connect.NewError(connect.CodeInvalidArgument, err)
+				return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 			}
 		}
-		plan := h.orch.PlanNetworkChange(orchestrator.NetworkChangeRequest{WalletID: req.Msg.WalletId})
+		plan := h.orch.PlanNetworkChange(orchestrator.NetworkChangeRequest{WalletID: req.WalletId})
 		if plan.MustSelectDatadir {
 			return nil, requirementsUnmet(plan)
 		}
 		if plan.NoChainSource {
-			return nil, connect.NewError(connect.CodeFailedPrecondition,
-				fmt.Errorf("%s has no chain source for an electrum wallet", plan.Network))
+			return nil, connect.Errorf(connect.CodeFailedPrecondition,
+				"%s has no chain source for an electrum wallet", plan.Network)
 		}
 	}
 
-	if err := h.svc.SwitchWallet(req.Msg.WalletId); err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, err)
+	if err := h.svc.SwitchWallet(req.WalletId); err != nil {
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	}
-	h.ensureL1ForWallet(req.Msg.WalletId)
-	return connect.NewResponse(&pb.SwitchWalletResponse{}), nil
+	h.ensureL1ForWallet(req.WalletId)
+	return &pb.SwitchWalletResponse{}, nil
 }
 
 // ensureL1ForWallet starts the local L1 stack when switching to a wallet that
@@ -317,41 +317,41 @@ func (h *WalletHandler) walletNeedsL1(walletID string) bool {
 	return w != nil && w.WalletType != wallet.WalletTypeElectrum
 }
 
-func (h *WalletHandler) UpdateWalletMetadata(ctx context.Context, req *connect.Request[pb.UpdateWalletMetadataRequest]) (*connect.Response[pb.UpdateWalletMetadataResponse], error) {
+func (h *WalletHandler) UpdateWalletMetadata(ctx context.Context, req *pb.UpdateWalletMetadataRequest) (*pb.UpdateWalletMetadataResponse, error) {
 	var gradient json.RawMessage
-	if req.Msg.GradientJson != "" {
-		gradient = json.RawMessage(req.Msg.GradientJson)
+	if req.GradientJson != "" {
+		gradient = json.RawMessage(req.GradientJson)
 	}
-	if err := h.svc.UpdateWalletMetadata(req.Msg.WalletId, req.Msg.Name, gradient); err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, err)
+	if err := h.svc.UpdateWalletMetadata(req.WalletId, req.Name, gradient); err != nil {
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.UpdateWalletMetadataResponse{}), nil
+	return &pb.UpdateWalletMetadataResponse{}, nil
 }
 
-func (h *WalletHandler) DeleteWallet(ctx context.Context, req *connect.Request[pb.DeleteWalletRequest]) (*connect.Response[pb.DeleteWalletResponse], error) {
+func (h *WalletHandler) DeleteWallet(ctx context.Context, req *pb.DeleteWalletRequest) (*pb.DeleteWalletResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
-	if err := h.svc.CheckDeletable(req.Msg.WalletId); err != nil {
+	if err := h.svc.CheckDeletable(req.WalletId); err != nil {
 		return nil, rpcError(err)
 	}
-	if err := h.engine.DeleteWallet(ctx, req.Msg.WalletId); err != nil {
+	if err := h.engine.DeleteWallet(ctx, req.WalletId); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.DeleteWalletResponse{}), nil
+	return &pb.DeleteWalletResponse{}, nil
 }
 
-func (h *WalletHandler) DeleteAllWallets(ctx context.Context, req *connect.Request[pb.DeleteAllWalletsRequest]) (*connect.Response[pb.DeleteAllWalletsResponse], error) {
+func (h *WalletHandler) DeleteAllWallets(ctx context.Context, req *pb.DeleteAllWalletsRequest) (*pb.DeleteAllWalletsResponse, error) {
 	if err := h.svc.DeleteAllWallets(nil, nil); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.DeleteAllWalletsResponse{}), nil
+	return &pb.DeleteAllWalletsResponse{}, nil
 }
 
-func (h *WalletHandler) ListWalletBackups(ctx context.Context, req *connect.Request[pb.ListWalletBackupsRequest]) (*connect.Response[pb.ListWalletBackupsResponse], error) {
+func (h *WalletHandler) ListWalletBackups(ctx context.Context, req *pb.ListWalletBackupsRequest) (*pb.ListWalletBackupsResponse, error) {
 	backups, err := h.svc.ListWalletBackups()
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	resp := &pb.ListWalletBackupsResponse{
@@ -359,20 +359,20 @@ func (h *WalletHandler) ListWalletBackups(ctx context.Context, req *connect.Requ
 			return walletBackupToProto(backup)
 		}),
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
-func (h *WalletHandler) RestoreWalletBackup(ctx context.Context, req *connect.Request[pb.RestoreWalletBackupRequest]) (*connect.Response[pb.RestoreWalletBackupResponse], error) {
-	if err := h.svc.RestoreWalletBackup(req.Msg.BackupId, req.Msg.Password); err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+func (h *WalletHandler) RestoreWalletBackup(ctx context.Context, req *pb.RestoreWalletBackupRequest) (*pb.RestoreWalletBackupResponse, error) {
+	if err := h.svc.RestoreWalletBackup(req.BackupId, req.Password); err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.RestoreWalletBackupResponse{}), nil
+	return &pb.RestoreWalletBackupResponse{}, nil
 }
 
-func (h *WalletHandler) RestoreWalletBackupStream(ctx context.Context, req *connect.Request[pb.RestoreWalletBackupRequest], stream *connect.ServerStream[pb.RestoreWalletBackupProgressResponse]) error {
-	steps, err := h.svc.RestoreWalletBackupPlan(req.Msg.BackupId)
+func (h *WalletHandler) RestoreWalletBackupStream(ctx context.Context, req *pb.RestoreWalletBackupRequest, stream rpc.WalletManagerServiceRestoreWalletBackupStreamServerStream) error {
+	steps, err := h.svc.RestoreWalletBackupPlan(req.BackupId)
 	if err != nil {
-		return connect.NewError(connect.CodeInvalidArgument, err)
+		return connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	planned := lo.Map(steps, func(step wallet.RestoreWalletBackupStep, _ int) *pb.RestoreWalletBackupStep {
@@ -404,11 +404,11 @@ func (h *WalletHandler) RestoreWalletBackupStream(ctx context.Context, req *conn
 		}
 	}
 
-	if err := h.svc.RestoreWalletBackupWithProgress(req.Msg.BackupId, req.Msg.Password, sendProgress); err != nil {
+	if err := h.svc.RestoreWalletBackupWithProgress(req.BackupId, req.Password, sendProgress); err != nil {
 		if sendErr != nil {
 			return sendErr
 		}
-		return connect.NewError(connect.CodeInvalidArgument, err)
+		return connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	if sendErr != nil {
 		return sendErr
@@ -422,59 +422,59 @@ func (h *WalletHandler) RestoreWalletBackupStream(ctx context.Context, req *conn
 	})
 }
 
-func (h *WalletHandler) CreateWatchOnlyWallet(ctx context.Context, req *connect.Request[pb.CreateWatchOnlyWalletRequest]) (*connect.Response[pb.CreateWatchOnlyWalletResponse], error) {
-	if err := h.svc.CreateWatchOnlyWallet(req.Msg.Name, req.Msg.XpubOrDescriptor, req.Msg.GradientJson); err != nil {
+func (h *WalletHandler) CreateWatchOnlyWallet(ctx context.Context, req *pb.CreateWatchOnlyWalletRequest) (*pb.CreateWatchOnlyWalletResponse, error) {
+	if err := h.svc.CreateWatchOnlyWallet(req.Name, req.XpubOrDescriptor, req.GradientJson); err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.CreateWatchOnlyWalletResponse{
+	return &pb.CreateWatchOnlyWalletResponse{
 		WalletId: h.svc.ActiveWalletID(),
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) CreateElectrumWallet(ctx context.Context, req *connect.Request[pb.CreateElectrumWalletRequest]) (*connect.Response[pb.CreateElectrumWalletResponse], error) {
+func (h *WalletHandler) CreateElectrumWallet(ctx context.Context, req *pb.CreateElectrumWalletRequest) (*pb.CreateElectrumWalletResponse, error) {
 	if h.engine == nil || !h.engine.ElectrumConfigured() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			errors.New("electrum wallets are not supported on this network"))
+			"electrum wallets are not supported on this network")
 	}
-	account, path, err := wallet.ResolveCreateDerivationPath(req.Msg.Account, req.Msg.DerivationPath)
+	account, path, err := wallet.ResolveCreateDerivationPath(req.Account, req.DerivationPath)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	if req.Msg.XpubOrDescriptor == "" {
-		if _, err := wallet.ResolveScriptType(req.Msg.ScriptType, path); err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	if req.XpubOrDescriptor == "" {
+		if _, err := wallet.ResolveScriptType(req.ScriptType, path); err != nil {
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 	}
 	// A bare extended key states no kind, so its own history places it. With
 	// no history the chosen type stands.
-	scriptType := req.Msg.ScriptType
-	if req.Msg.XpubOrDescriptor != "" && wallet.BareKeyWithoutKind(req.Msg.XpubOrDescriptor) {
-		if detected, ok := h.engine.DetectScriptKind(ctx, req.Msg.XpubOrDescriptor); ok {
+	scriptType := req.ScriptType
+	if req.XpubOrDescriptor != "" && wallet.BareKeyWithoutKind(req.XpubOrDescriptor) {
+		if detected, ok := h.engine.DetectScriptKind(ctx, req.XpubOrDescriptor); ok {
 			scriptType = detected.String()
 		}
 	}
-	w, err := h.svc.CreateElectrumWallet(req.Msg.Name, json.RawMessage(req.Msg.GradientJson), req.Msg.Slots, req.Msg.CustomMnemonic, req.Msg.Passphrase, req.Msg.XpubOrDescriptor, scriptType, account, path)
+	w, err := h.svc.CreateElectrumWallet(req.Name, json.RawMessage(req.GradientJson), req.Slots, req.CustomMnemonic, req.Passphrase, req.XpubOrDescriptor, scriptType, account, path)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	if req.Msg.HardwareDeviceType != "" {
-		if err := h.svc.SetWalletHardwareDevice(w.ID, req.Msg.HardwareDeviceType, req.Msg.HardwareFingerprint); err != nil {
-			return nil, connect.NewError(connect.CodeInternal, err)
+	if req.HardwareDeviceType != "" {
+		if err := h.svc.SetWalletHardwareDevice(w.ID, req.HardwareDeviceType, req.HardwareFingerprint); err != nil {
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 	}
-	return connect.NewResponse(&pb.CreateElectrumWalletResponse{
+	return &pb.CreateElectrumWalletResponse{
 		WalletId: w.ID,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) CreateMultisigWallet(ctx context.Context, req *connect.Request[pb.CreateMultisigWalletRequest]) (*connect.Response[pb.CreateMultisigWalletResponse], error) {
+func (h *WalletHandler) CreateMultisigWallet(ctx context.Context, req *pb.CreateMultisigWalletRequest) (*pb.CreateMultisigWalletResponse, error) {
 	if h.engine == nil || !h.engine.ElectrumConfigured() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			errors.New("multisig wallets are not supported on this network"))
+			"multisig wallets are not supported on this network")
 	}
 	net := h.engine.Network()
-	cosigners := make([]wallet.MultisigCosigner, 0, len(req.Msg.Cosigners))
-	for _, c := range req.Msg.Cosigners {
+	cosigners := make([]wallet.MultisigCosigner, 0, len(req.Cosigners))
+	for _, c := range req.Cosigners {
 		xpub := c.Xpub
 		mnemonic := c.Mnemonic
 		// For a held cosigner, derive the authoritative xpub from its seed +
@@ -484,17 +484,17 @@ func (h *WalletHandler) CreateMultisigWallet(ctx context.Context, req *connect.R
 			var err error
 			mnemonic, err = wallet.ParseMnemonic(mnemonic)
 			if err != nil {
-				return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("cosigner mnemonic: %w", err))
+				return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("cosigner mnemonic: %w", err).Error())
 			}
 			seedHex := hex.EncodeToString(wallet.MnemonicToSeed(mnemonic, c.Passphrase))
 			_, derived, err := wallet.DeriveAccountXprv(seedHex, "m/"+c.OriginPath, net)
 			if err != nil {
-				return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("derive cosigner xpub: %w", err))
+				return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("derive cosigner xpub: %w", err).Error())
 			}
 			xpub = derived
 		}
 		if err := wallet.CheckCosignerKeyMatchesOrigin(xpub, c.OriginPath); err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 		cosigners = append(cosigners, wallet.MultisigCosigner{
 			Xpub:               xpub,
@@ -507,17 +507,17 @@ func (h *WalletHandler) CreateMultisigWallet(ctx context.Context, req *connect.R
 		})
 	}
 	w, err := h.svc.CreateElectrumMultisig(
-		req.Msg.Name,
-		json.RawMessage(req.Msg.GradientJson),
-		int(req.Msg.M),
-		int(req.Msg.N),
-		req.Msg.ScriptType,
+		req.Name,
+		json.RawMessage(req.GradientJson),
+		int(req.M),
+		int(req.N),
+		req.ScriptType,
 		cosigners,
 	)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.CreateMultisigWalletResponse{WalletId: w.ID}), nil
+	return &pb.CreateMultisigWalletResponse{WalletId: w.ID}, nil
 }
 
 // multisigInfoProto exposes a wallet's multisig policy to the frontend. Private
@@ -545,10 +545,10 @@ func multisigInfoProto(w *wallet.WalletData) *pb.MultisigInfo {
 	}
 }
 
-func (h *WalletHandler) ParseMultisigConfig(ctx context.Context, req *connect.Request[pb.ParseMultisigConfigRequest]) (*connect.Response[pb.ParseMultisigConfigResponse], error) {
-	m, n, scriptType, cosigners, err := wallet.ParseMultisigConfig(req.Msg.Content)
+func (h *WalletHandler) ParseMultisigConfig(ctx context.Context, req *pb.ParseMultisigConfigRequest) (*pb.ParseMultisigConfigResponse, error) {
+	m, n, scriptType, cosigners, err := wallet.ParseMultisigConfig(req.Content)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	pbCosigners := make([]*pb.ParsedCosigner, 0, len(cosigners))
 	for _, c := range cosigners {
@@ -558,18 +558,18 @@ func (h *WalletHandler) ParseMultisigConfig(ctx context.Context, req *connect.Re
 			OriginPath:  c.OriginPath,
 		})
 	}
-	return connect.NewResponse(&pb.ParseMultisigConfigResponse{
+	return &pb.ParseMultisigConfigResponse{
 		M:          uint32(m),
 		N:          uint32(n),
 		ScriptType: scriptType,
 		Cosigners:  pbCosigners,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) ValidateDescriptor(ctx context.Context, req *connect.Request[pb.ValidateDescriptorRequest]) (*connect.Response[pb.ValidateDescriptorResponse], error) {
-	policy, err := wallet.ValidateDescriptor(req.Msg.Descriptor_)
+func (h *WalletHandler) ValidateDescriptor(ctx context.Context, req *pb.ValidateDescriptorRequest) (*pb.ValidateDescriptorResponse, error) {
+	policy, err := wallet.ValidateDescriptor(req.Descriptor_)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	keys := make([]*pb.ParsedCosigner, 0, len(policy.Cosigners))
 	for _, c := range policy.Cosigners {
@@ -579,123 +579,123 @@ func (h *WalletHandler) ValidateDescriptor(ctx context.Context, req *connect.Req
 			OriginPath:  c.OriginPath,
 		})
 	}
-	return connect.NewResponse(&pb.ValidateDescriptorResponse{
+	return &pb.ValidateDescriptorResponse{
 		Multisig:   policy.Multisig,
 		ScriptType: policy.ScriptType,
 		M:          uint32(policy.M),
 		N:          uint32(policy.N),
 		Keys:       keys,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) ValidateDerivationPath(ctx context.Context, req *connect.Request[pb.ValidateDerivationPathRequest]) (*connect.Response[pb.ValidateDerivationPathResponse], error) {
-	normalized, err := wallet.ParseKeystorePath(req.Msg.Path)
+func (h *WalletHandler) ValidateDerivationPath(ctx context.Context, req *pb.ValidateDerivationPathRequest) (*pb.ValidateDerivationPathResponse, error) {
+	normalized, err := wallet.ParseKeystorePath(req.Path)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.ValidateDerivationPathResponse{
+	return &pb.ValidateDerivationPathResponse{
 		Normalized: normalized,
-		ScriptType: wallet.KeystorePathScriptType(normalized, req.Msg.Multisig),
-	}), nil
+		ScriptType: wallet.KeystorePathScriptType(normalized, req.Multisig),
+	}, nil
 }
 
-func (h *WalletHandler) ListDerivationPaths(ctx context.Context, req *connect.Request[pb.ListDerivationPathsRequest]) (*connect.Response[pb.ListDerivationPathsResponse], error) {
+func (h *WalletHandler) ListDerivationPaths(ctx context.Context, req *pb.ListDerivationPathsRequest) (*pb.ListDerivationPathsResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	options, defaultPath, err := wallet.StandardDerivationPaths(req.Msg.ScriptType, req.Msg.Multisig, req.Msg.Account, h.engine.Network())
+	options, defaultPath, err := wallet.StandardDerivationPaths(req.ScriptType, req.Multisig, req.Account, h.engine.Network())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	pbOptions := make([]*pb.DerivationPathOption, 0, len(options))
 	for _, o := range options {
 		pbOptions = append(pbOptions, &pb.DerivationPathOption{Label: o.Label, Path: o.Path})
 	}
-	return connect.NewResponse(&pb.ListDerivationPathsResponse{Options: pbOptions, DefaultPath: defaultPath}), nil
+	return &pb.ListDerivationPathsResponse{Options: pbOptions, DefaultPath: defaultPath}, nil
 }
 
-func (h *WalletHandler) SignPsbtWithCosigner(ctx context.Context, req *connect.Request[pb.SignPsbtWithCosignerRequest]) (*connect.Response[pb.SignPsbtWithCosignerResponse], error) {
+func (h *WalletHandler) SignPsbtWithCosigner(ctx context.Context, req *pb.SignPsbtWithCosignerRequest) (*pb.SignPsbtWithCosignerResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	out, err := h.engine.SignPSBTWithCosigner(ctx, walletID, req.Msg.PsbtBase64, req.Msg.CosignerXpub)
+	out, err := h.engine.SignPSBTWithCosigner(ctx, walletID, req.PsbtBase64, req.CosignerXpub)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.SignPsbtWithCosignerResponse{PsbtBase64: out}), nil
+	return &pb.SignPsbtWithCosignerResponse{PsbtBase64: out}, nil
 }
 
-func (h *WalletHandler) MultisigPsbtStatus(ctx context.Context, req *connect.Request[pb.MultisigPsbtStatusRequest]) (*connect.Response[pb.MultisigPsbtStatusResponse], error) {
-	w := h.svc.GetWalletByID(req.Msg.WalletId)
+func (h *WalletHandler) MultisigPsbtStatus(ctx context.Context, req *pb.MultisigPsbtStatusRequest) (*pb.MultisigPsbtStatusResponse, error) {
+	w := h.svc.GetWalletByID(req.WalletId)
 	if w == nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("wallet %s not found", req.Msg.WalletId))
+		return nil, connect.Errorf(connect.CodeNotFound, "wallet %s not found", req.WalletId)
 	}
 	if w.Multisig == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("wallet is not a multisig wallet"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "wallet is not a multisig wallet")
 	}
-	status, err := wallet.MultisigPsbtSigningStatus(req.Msg.PsbtBase64, w.Multisig.Cosigners)
+	status, err := wallet.MultisigPsbtSigningStatus(req.PsbtBase64, w.Multisig.Cosigners)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.MultisigPsbtStatusResponse{
+	return &pb.MultisigPsbtStatusResponse{
 		Threshold:      uint32(w.Multisig.M),
 		Signatures:     uint32(status.Signatures),
 		Finalizable:    status.Finalizable,
 		CosignerSigned: status.CosignerSigned,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) BroadcastTransaction(ctx context.Context, req *connect.Request[pb.BroadcastTransactionRequest]) (*connect.Response[pb.BroadcastTransactionResponse], error) {
+func (h *WalletHandler) BroadcastTransaction(ctx context.Context, req *pb.BroadcastTransactionRequest) (*pb.BroadcastTransactionResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	// A saved draft spends the coins it named when the user built it. The user
 	// can freeze one of them before this call, so read the inputs again.
-	if err := h.refuseFrozenRawInputs(req.Msg.TxHex); err != nil {
+	if err := h.refuseFrozenRawInputs(req.TxHex); err != nil {
 		return nil, err
 	}
 
-	txid, err := h.engine.ChainForWallet(walletID).Broadcast(ctx, req.Msg.TxHex)
+	txid, err := h.engine.ChainForWallet(walletID).Broadcast(ctx, req.TxHex)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("broadcast: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("broadcast: %w", err).Error())
 	}
 	if rerr := h.engine.RefreshElectrumScan(ctx, walletID); rerr != nil {
 		h.svc.Log().Warn().Err(rerr).Str("wallet_id", walletID).Msg("refresh scan after broadcast failed")
 	}
-	return connect.NewResponse(&pb.BroadcastTransactionResponse{Txid: txid}), nil
+	return &pb.BroadcastTransactionResponse{Txid: txid}, nil
 }
 
-func (h *WalletHandler) RescanWallet(ctx context.Context, req *connect.Request[pb.RescanWalletRequest]) (*connect.Response[pb.RescanWalletResponse], error) {
+func (h *WalletHandler) RescanWallet(ctx context.Context, req *pb.RescanWalletRequest) (*pb.RescanWalletResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	if err := h.engine.RefreshElectrumScan(ctx, walletID); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("rescan: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("rescan: %w", err).Error())
 	}
-	return connect.NewResponse(&pb.RescanWalletResponse{}), nil
+	return &pb.RescanWalletResponse{}, nil
 }
 
-func (h *WalletHandler) EstimateFee(ctx context.Context, req *connect.Request[pb.EstimateFeeRequest]) (*connect.Response[pb.EstimateFeeResponse], error) {
+func (h *WalletHandler) EstimateFee(ctx context.Context, req *pb.EstimateFeeRequest) (*pb.EstimateFeeResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	rate, err := h.engine.EstimateFeeRate(ctx, int(req.Msg.ConfTarget))
+	rate, err := h.engine.EstimateFeeRate(ctx, int(req.ConfTarget))
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.EstimateFeeResponse{SatPerVbyte: rate}), nil
+	return &pb.EstimateFeeResponse{SatPerVbyte: rate}, nil
 }
 
 // ============================================================================
@@ -733,17 +733,17 @@ func rpcError(err error) error {
 	}
 	switch {
 	case errors.Is(err, wallet.ErrIncorrectPassword):
-		return connect.NewError(connect.CodeUnauthenticated, err)
+		return connect.NewError(connect.CodeUnauthenticated, err.Error()).WithCause(err)
 	case errors.Is(err, wallet.ErrNotEncrypted):
-		return connect.NewError(connect.CodeFailedPrecondition, err)
+		return connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	default:
-		return connect.NewError(connect.CodeInternal, err)
+		return connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 }
 
-func (h *WalletHandler) CreateBitcoinCoreWallet(ctx context.Context, req *connect.Request[pb.CreateBitcoinCoreWalletRequest]) (*connect.Response[pb.CreateBitcoinCoreWalletResponse], error) {
+func (h *WalletHandler) CreateBitcoinCoreWallet(ctx context.Context, req *pb.CreateBitcoinCoreWalletRequest) (*pb.CreateBitcoinCoreWalletResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	if h.orch != nil {
@@ -753,48 +753,48 @@ func (h *WalletHandler) CreateBitcoinCoreWallet(ctx context.Context, req *connec
 		}
 	}
 
-	name, err := h.engine.Backend().Ensure(ctx, req.Msg.WalletId)
+	name, err := h.engine.Backend().Ensure(ctx, req.WalletId)
 	if err != nil {
 		// Bitcoin Core mid-startup (-28) or already loading the wallet (-4) is
 		// not an internal failure — it's "try again in a few seconds". Return
 		// Unavailable so the Dart logging filter quiets it and the UI doesn't
 		// flash an error toast every poll cycle.
 		if wallet.IsTransientWalletErr(err) {
-			return nil, connect.NewError(connect.CodeUnavailable, err)
+			return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 		}
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.CreateBitcoinCoreWalletResponse{
+	return &pb.CreateBitcoinCoreWalletResponse{
 		CoreWalletName: name,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) EnsureCoreWallets(ctx context.Context, req *connect.Request[pb.EnsureCoreWalletsRequest]) (*connect.Response[pb.EnsureCoreWalletsResponse], error) {
+func (h *WalletHandler) EnsureCoreWallets(ctx context.Context, req *pb.EnsureCoreWalletsRequest) (*pb.EnsureCoreWalletsResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	count, err := h.engine.Backend().EnsureAll(ctx)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.EnsureCoreWalletsResponse{
+	return &pb.EnsureCoreWalletsResponse{
 		SyncedCount: int32(count),
-	}), nil
+	}, nil
 }
 
 // ============================================================================
 // Bitcoin operation RPCs (proxied through Core RPC)
 // ============================================================================
 
-func (h *WalletHandler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *WalletHandler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	confirmed, unconfirmed, immature, err := h.engine.Backend().Balance(ctx, walletID)
@@ -805,28 +805,28 @@ func (h *WalletHandler) GetBalance(ctx context.Context, req *connect.Request[pb.
 	confirmedSats := btcToSats(confirmed)
 	unconfirmedSats := btcToSats(unconfirmed)
 	if err := h.svc.SyncBalance(orchestratorpb.BinaryType_BINARY_TYPE_BITCOIND, walletID, uint64(math.Round(confirmedSats)), uint64(math.Round(unconfirmedSats)), "Bitcoin"); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the balance snapshot: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("save the balance snapshot: %w", err).Error())
 	}
 
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		ConfirmedSats:   confirmedSats,
 		UnconfirmedSats: unconfirmedSats,
 		ImmatureSats:    btcToSats(immature),
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) GetNewAddress(ctx context.Context, req *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *WalletHandler) GetNewAddress(ctx context.Context, req *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	var kind wallet.ScriptKind
-	switch req.Msg.AddressType {
+	switch req.AddressType {
 	case pb.AddressType_ADDRESS_TYPE_SEGWIT:
 		kind = wallet.ScriptNativeSegwit
 	case pb.AddressType_ADDRESS_TYPE_TAPROOT:
@@ -840,11 +840,11 @@ func (h *WalletHandler) GetNewAddress(ctx context.Context, req *connect.Request[
 		return nil, rpcError(err)
 	}
 
-	return connect.NewResponse(&pb.GetNewAddressResponse{
+	return &pb.GetNewAddressResponse{
 		Address:        addr.Address,
 		Index:          addr.Index,
 		DerivationPath: addr.HDPath,
-	}), nil
+	}, nil
 }
 
 // mapRawOutputs converts proto raw outputs to the wallet's TxOutSpec shape.
@@ -881,8 +881,8 @@ func (h *WalletHandler) refuseFrozenRawInputs(txHex string) error {
 	for _, in := range decoded.Inputs {
 		outpoint := wallet.Outpoint{TxID: in.PrevTxID, Vout: in.PrevVout}
 		if held[outpoint.Key()] {
-			return connect.NewError(connect.CodeFailedPrecondition,
-				fmt.Errorf("the output %s is frozen; unfreeze it to spend it", outpoint.Key()))
+			return connect.Errorf(connect.CodeFailedPrecondition,
+				"the output %s is frozen; unfreeze it to spend it", outpoint.Key())
 		}
 	}
 	return nil
@@ -900,8 +900,8 @@ func (h *WalletHandler) refuseFrozenInputs(inputs []*pb.UnspentOutput) error {
 	for _, in := range inputs {
 		outpoint := wallet.Outpoint{TxID: in.Txid, Vout: int(in.Vout)}
 		if held[outpoint.Key()] {
-			return connect.NewError(connect.CodeFailedPrecondition,
-				fmt.Errorf("the output %s is frozen; unfreeze it to spend it", outpoint.Key()))
+			return connect.Errorf(connect.CodeFailedPrecondition,
+				"the output %s is frozen; unfreeze it to spend it", outpoint.Key())
 		}
 	}
 	return nil
@@ -914,84 +914,84 @@ func (h *WalletHandler) HeldCoins() map[string]bool {
 
 // SetFrozenCoins records the coins the frontend froze, so every later send
 // leaves them alone.
-func (h *WalletHandler) SetFrozenCoins(ctx context.Context, req *connect.Request[pb.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error) {
-	coins := make([]wallet.Outpoint, 0, len(req.Msg.Outpoints))
-	for _, out := range req.Msg.Outpoints {
+func (h *WalletHandler) SetFrozenCoins(ctx context.Context, req *pb.SetFrozenCoinsRequest) (*emptypb.Empty, error) {
+	coins := make([]wallet.Outpoint, 0, len(req.Outpoints))
+	for _, out := range req.Outpoints {
 		if out.Txid == "" {
-			return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("a frozen coin needs a txid"))
+			return nil, connect.NewError(connect.CodeInvalidArgument, "a frozen coin needs a txid")
 		}
 		coins = append(coins, wallet.Outpoint{TxID: out.Txid, Vout: int(out.Vout)})
 	}
 	h.svc.SetHeldCoins(coins)
 
-	return connect.NewResponse(&emptypb.Empty{}), nil
+	return &emptypb.Empty{}, nil
 }
 
-func (h *WalletHandler) SendTransaction(ctx context.Context, req *connect.Request[pb.SendTransactionRequest]) (*connect.Response[pb.SendTransactionResponse], error) {
-	if err := protovalidate.Validate(req.Msg); err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+func (h *WalletHandler) SendTransaction(ctx context.Context, req *pb.SendTransactionRequest) (*pb.SendTransactionResponse, error) {
+	if err := protovalidate.Validate(req); err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// A BIP47 send reserves an index and can broadcast a notification below.
-	if req.Msg.FixedFeeSats > 0 && req.Msg.SubtractFeeFromAmount && h.walletNeedsL1(walletID) {
-		return nil, connect.NewError(connect.CodeInvalidArgument, wallet.ErrCoreMixedFee)
+	if req.FixedFeeSats > 0 && req.SubtractFeeFromAmount && h.walletNeedsL1(walletID) {
+		return nil, connect.NewError(connect.CodeInvalidArgument, wallet.ErrCoreMixedFee.Error()).WithCause(wallet.ErrCoreMixedFee)
 	}
 
 	// A required input is spent as it is given, so no lock reaches it. The
 	// set here is the user's alone: a bid raise pins the coin its own bid
 	// holds, and that coin has to stay spendable.
-	if err := h.refuseFrozenInputs(req.Msg.RequiredInputs); err != nil {
+	if err := h.refuseFrozenInputs(req.RequiredInputs); err != nil {
 		return nil, err
 	}
 
 	// Resolve any BIP47 payment-code destinations into per-payment addresses
 	// before the dust check so we validate against the substituted address.
 	var pinnedNotification *wallet.RequiredInput
-	if req.Msg.NotificationInput != nil {
-		pinnedNotification = &mapRequiredInputs([]*pb.UnspentOutput{req.Msg.NotificationInput})[0]
+	if req.NotificationInput != nil {
+		pinnedNotification = &mapRequiredInputs([]*pb.UnspentOutput{req.NotificationInput})[0]
 	}
 	expansion, err := h.expandBip47Destinations(
-		ctx, walletID, req.Msg.Destinations,
-		req.Msg.FeeRateSatPerVbyte, pinnedNotification, mapRequiredInputs(req.Msg.RequiredInputs),
+		ctx, walletID, req.Destinations,
+		req.FeeRateSatPerVbyte, pinnedNotification, mapRequiredInputs(req.RequiredInputs),
 	)
 	if err != nil {
 		return nil, err
 	}
-	if expansion.notificationTxHex != "" || !destinationsEqual(expansion.destinations, req.Msg.Destinations) {
-		req = connect.NewRequest(applyDestinationsToRequest(req.Msg, expansion.destinations))
+	if expansion.notificationTxHex != "" || !destinationsEqual(expansion.destinations, req.Destinations) {
+		req = applyDestinationsToRequest(req, expansion.destinations)
 	}
 	// The reserved per-payment index is only released for a failure that
 	// happens before the payment goes out. A broadcast that times out may
 	// still have published the payment, and reusing that address would defeat
 	// the address isolation BIP47 exists for.
 	const dustLimitSats int64 = 546
-	for address, sats := range req.Msg.Destinations {
+	for address, sats := range req.Destinations {
 		if sats < dustLimitSats {
 			h.releaseBip47Index(walletID, expansion)
-			return nil, connect.NewError(
+			return nil, connect.Errorf(
 				connect.CodeInvalidArgument,
-				fmt.Errorf("amount to %s is below dust limit (%d sats)", address, dustLimitSats),
+				"amount to %s is below dust limit (%d sats)", address, dustLimitSats,
 			)
 		}
 	}
 
 	sendReq := wallet.SendRequest{
-		DestinationsSats:      req.Msg.Destinations,
-		FeeRateSatPerVB:       req.Msg.FeeRateSatPerVbyte,
-		FixedFeeSats:          req.Msg.FixedFeeSats,
-		OpReturnHex:           req.Msg.OpReturnHex,
-		SubtractFeeFromAmount: req.Msg.SubtractFeeFromAmount,
-		AllowReplay:           req.Msg.AllowReplay,
-		Replaceable:           req.Msg.Replaceable,
+		DestinationsSats:      req.Destinations,
+		FeeRateSatPerVB:       req.FeeRateSatPerVbyte,
+		FixedFeeSats:          req.FixedFeeSats,
+		OpReturnHex:           req.OpReturnHex,
+		SubtractFeeFromAmount: req.SubtractFeeFromAmount,
+		AllowReplay:           req.AllowReplay,
+		Replaceable:           req.Replaceable,
 	}
 
 	// A BIP47 payment holds a reserved index, and its first send also publishes
@@ -1006,26 +1006,26 @@ func (h *WalletHandler) SendTransaction(ctx context.Context, req *connect.Reques
 	}
 
 	if expansion.notificationTxHex != "" {
-		notifTxID, err := h.broadcastBip47Notification(ctx, walletID, expansion.recipientCode, expansion.notificationTxHex, req.Msg.AllowReplay)
+		notifTxID, err := h.broadcastBip47Notification(ctx, walletID, expansion.recipientCode, expansion.notificationTxHex, req.AllowReplay)
 		if err != nil {
 			// The payment never went out, so its index is still free.
 			h.releaseBip47Index(walletID, expansion)
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("broadcast bip47 notification: %w", err))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("broadcast bip47 notification: %w", err).Error())
 		}
 		_ = notifTxID
 	}
-	sendReq.RequiredInputs = mapRequiredInputs(req.Msg.RequiredInputs)
-	sendReq.RawOutputs = mapRawOutputs(req.Msg.RawOutputs)
-	sendReq.ExternalInputs = mapExternalInputs(req.Msg.ExternalInputs)
+	sendReq.RequiredInputs = mapRequiredInputs(req.RequiredInputs)
+	sendReq.RawOutputs = mapRawOutputs(req.RawOutputs)
+	sendReq.ExternalInputs = mapExternalInputs(req.ExternalInputs)
 
 	txid, err := h.engine.Backend().Send(ctx, walletID, sendReq)
 	if err != nil {
 		return nil, rpcError(err)
 	}
 
-	return connect.NewResponse(&pb.SendTransactionResponse{
+	return &pb.SendTransactionResponse{
 		Txid: txid,
-	}), nil
+	}, nil
 }
 
 func mapRequiredInputs(inputs []*pb.UnspentOutput) []wallet.RequiredInput {
@@ -1034,25 +1034,25 @@ func mapRequiredInputs(inputs []*pb.UnspentOutput) []wallet.RequiredInput {
 	})
 }
 
-func (h *WalletHandler) PreviewSend(ctx context.Context, req *connect.Request[pb.PreviewSendRequest]) (*connect.Response[pb.PreviewSendResponse], error) {
-	if len(req.Msg.Destinations) == 0 {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("must provide at least one destination"))
+func (h *WalletHandler) PreviewSend(ctx context.Context, req *pb.PreviewSendRequest) (*pb.PreviewSendResponse, error) {
+	if len(req.Destinations) == 0 {
+		return nil, connect.NewError(connect.CodeInvalidArgument, "must provide at least one destination")
 	}
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	if err := h.refuseFrozenInputs(req.Msg.RequiredInputs); err != nil {
+	if err := h.refuseFrozenInputs(req.RequiredInputs); err != nil {
 		return nil, err
 	}
-	destinations, notifies, err := h.sizeBip47Destinations(walletID, req.Msg.Destinations)
+	destinations, notifies, err := h.sizeBip47Destinations(walletID, req.Destinations)
 	if err != nil {
 		return nil, err
 	}
-	requiredInputs := mapRequiredInputs(req.Msg.RequiredInputs)
+	requiredInputs := mapRequiredInputs(req.RequiredInputs)
 
 	resp := &pb.PreviewSendResponse{}
 	var excluded []wallet.RequiredInput
@@ -1065,7 +1065,7 @@ func (h *WalletHandler) PreviewSend(ctx context.Context, req *connect.Request[pb
 		if err != nil {
 			return nil, err
 		}
-		coin, feeSats, err := h.bip47NotificationCoin(ctx, walletID, req.Msg.FeeRateSatPerVbyte, nil, requiredInputs)
+		coin, feeSats, err := h.bip47NotificationCoin(ctx, walletID, req.FeeRateSatPerVbyte, nil, requiredInputs)
 		if err != nil {
 			return nil, err
 		}
@@ -1080,9 +1080,9 @@ func (h *WalletHandler) PreviewSend(ctx context.Context, req *connect.Request[pb
 
 	preview, err := h.engine.Backend().PreviewSend(ctx, walletID, wallet.SendRequest{
 		DestinationsSats:      destinations,
-		FeeRateSatPerVB:       req.Msg.FeeRateSatPerVbyte,
-		SubtractFeeFromAmount: req.Msg.SubtractFeeFromAmount,
-		AllowReplay:           req.Msg.AllowReplay,
+		FeeRateSatPerVB:       req.FeeRateSatPerVbyte,
+		SubtractFeeFromAmount: req.SubtractFeeFromAmount,
+		AllowReplay:           req.AllowReplay,
 		RequiredInputs:        requiredInputs,
 		ExcludedInputs:        excluded,
 	})
@@ -1096,12 +1096,12 @@ func (h *WalletHandler) PreviewSend(ctx context.Context, req *connect.Request[pb
 	if resp.FeeIsEstimate {
 		changeSats := notificationCoinSats - resp.NotificationFeeSats - bip47NotificationDustSats
 		needSats := lo.Sum(lo.Values(destinations))
-		if !req.Msg.SubtractFeeFromAmount {
+		if !req.SubtractFeeFromAmount {
 			needSats += preview.FeeSats
 		}
 		if needSats > changeSats {
-			return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-				"the payment needs %d sats, but the only coin keeps %d sats after the BIP47 notification", needSats, changeSats))
+			return nil, connect.Errorf(connect.CodeFailedPrecondition,
+				"the payment needs %d sats, but the only coin keeps %d sats after the BIP47 notification", needSats, changeSats)
 		}
 	}
 	if !resp.FeeIsEstimate {
@@ -1109,27 +1109,27 @@ func (h *WalletHandler) PreviewSend(ctx context.Context, req *connect.Request[pb
 			return &pb.UnspentOutput{Txid: in.TxID, Vout: int32(in.Vout), AmountSats: in.AmountSats}
 		})
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
-func (h *WalletHandler) ListTransactions(ctx context.Context, req *connect.Request[pb.ListTransactionsRequest]) (*connect.Response[pb.ListTransactionsResponse], error) {
+func (h *WalletHandler) ListTransactions(ctx context.Context, req *pb.ListTransactionsRequest) (*pb.ListTransactionsResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	count := int(req.Msg.Count)
+	count := int(req.Count)
 	if count <= 0 {
 		count = 100
 	}
 
 	txs, err := h.engine.Backend().ListTransactions(ctx, walletID, count)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	pbTxs := lo.Map(txs, func(tx wallet.WalletTransaction, _ int) *pb.TransactionEntry {
@@ -1154,12 +1154,12 @@ func (h *WalletHandler) ListTransactions(ctx context.Context, req *connect.Reque
 		entry.BmmBid = bids[entry.Txid]
 	}
 	if err := h.setTransactionWarnings(ctx, walletID, pbTxs); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.ListTransactionsResponse{
+	return &pb.ListTransactionsResponse{
 		Transactions: pbTxs,
-	}), nil
+	}, nil
 }
 
 // bidLabels names the BMM request each unconfirmed transaction carries. A
@@ -1206,19 +1206,19 @@ func (h *WalletHandler) walletBidLabels(ctx context.Context, walletID string, tx
 	}, func(string) bool { return true })
 }
 
-func (h *WalletHandler) ListUnspent(ctx context.Context, req *connect.Request[pb.ListUnspentRequest]) (*connect.Response[pb.ListUnspentResponse], error) {
+func (h *WalletHandler) ListUnspent(ctx context.Context, req *pb.ListUnspentRequest) (*pb.ListUnspentResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	utxos, err := h.engine.Backend().ListUnspent(ctx, walletID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	txTimes := h.fetchCoreTxTimes(ctx, walletID, utxos)
@@ -1226,7 +1226,7 @@ func (h *WalletHandler) ListUnspent(ctx context.Context, req *connect.Request[pb
 	if config.IsEcashFork(config.NetworkFromString(h.svc.Network())) {
 		splitStatuses, err = h.svc.SplitStatuses(ctx)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInternal, err)
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 	}
 
@@ -1261,9 +1261,9 @@ func (h *WalletHandler) ListUnspent(ctx context.Context, req *connect.Request[pb
 		return out
 	})
 
-	return connect.NewResponse(&pb.ListUnspentResponse{
+	return &pb.ListUnspentResponse{
 		Utxos: pbUTXOs,
-	}), nil
+	}, nil
 }
 
 // receivedAt prefers the provider-supplied per-UTXO time, falling back to
@@ -1306,19 +1306,19 @@ func (h *WalletHandler) fetchCoreTxTimes(ctx context.Context, walletID string, u
 	return out
 }
 
-func (h *WalletHandler) ListReceiveAddresses(ctx context.Context, req *connect.Request[pb.ListReceiveAddressesRequest]) (*connect.Response[pb.ListReceiveAddressesResponse], error) {
+func (h *WalletHandler) ListReceiveAddresses(ctx context.Context, req *pb.ListReceiveAddressesRequest) (*pb.ListReceiveAddressesResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	addrs, err := h.engine.Backend().ListReceivedByAddress(ctx, walletID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
 	pbAddrs := lo.Map(addrs, func(a wallet.ReceivedByAddress, _ int) *pb.ReceiveAddress {
@@ -1340,29 +1340,29 @@ func (h *WalletHandler) ListReceiveAddresses(ctx context.Context, req *connect.R
 		}
 	})
 
-	return connect.NewResponse(&pb.ListReceiveAddressesResponse{
+	return &pb.ListReceiveAddressesResponse{
 		Addresses: pbAddrs,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) GetTransactionDetails(ctx context.Context, req *connect.Request[pb.GetTransactionDetailsRequest]) (*connect.Response[pb.GetTransactionDetailsResponse], error) {
+func (h *WalletHandler) GetTransactionDetails(ctx context.Context, req *pb.GetTransactionDetailsRequest) (*pb.GetTransactionDetailsResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	tx, err := h.engine.Backend().GetWalletTransaction(ctx, walletID, req.Msg.Txid)
+	tx, err := h.engine.Backend().GetWalletTransaction(ctx, walletID, req.Txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	rawTx, err := h.engine.ChainForWallet(walletID).GetRawTransaction(ctx, req.Msg.Txid)
+	rawTx, err := h.engine.ChainForWallet(walletID).GetRawTransaction(ctx, req.Txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("getrawtransaction: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("getrawtransaction: %w", err).Error())
 	}
 
 	inputs := make([]*pb.TransactionInput, 0, len(rawTx.Vin))
@@ -1413,7 +1413,7 @@ func (h *WalletHandler) GetTransactionDetails(ctx context.Context, req *connect.
 
 	owned, err := h.engine.Backend().OwnedAddresses(ctx, walletID, addresses)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("read address ownership: %w", err))
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("read address ownership: %w", err).Error())
 	}
 	for _, out := range outputs {
 		change, mine := owned[out.Address]
@@ -1431,7 +1431,7 @@ func (h *WalletHandler) GetTransactionDetails(ctx context.Context, req *connect.
 		feeRateSatVb = float64(feeSats) / float64(rawTx.Vsize)
 	}
 
-	return connect.NewResponse(&pb.GetTransactionDetailsResponse{
+	return &pb.GetTransactionDetailsResponse{
 		Transaction: &pb.TransactionEntry{
 			Txid:           tx.TxID,
 			WarningMessage: h.transactionWarning(outputs),
@@ -1458,32 +1458,32 @@ func (h *WalletHandler) GetTransactionDetails(ctx context.Context, req *connect.
 		TotalInputSats:  totalInputSats,
 		Outputs:         outputs,
 		TotalOutputSats: totalOutputSats,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) DecodeTransaction(ctx context.Context, req *connect.Request[pb.DecodeTransactionRequest]) (*connect.Response[pb.DecodeTransactionResponse], error) {
+func (h *WalletHandler) DecodeTransaction(ctx context.Context, req *pb.DecodeTransactionRequest) (*pb.DecodeTransactionResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	decoded, err := wallet.DecodeTransaction(req.Msg.Input, h.engine.Network())
+	decoded, err := wallet.DecodeTransaction(req.Input, h.engine.Network())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	response := decodedToResponse(decoded)
 	if decoded.Form == wallet.DecodedFormTxid {
-		result, err := h.decodeTxidResponse(ctx, decoded.TxID, req.Msg.WalletId)
+		result, err := h.decodeTxidResponse(ctx, decoded.TxID, req.WalletId)
 		if err != nil {
 			return nil, err
 		}
-		response = result.Msg
+		response = result
 	}
 
-	if req.Msg.CheckOwnership {
-		walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	if req.CheckOwnership {
+		walletID, err := h.engine.ResolveWalletID(req.WalletId)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 		addresses := make([]string, len(response.Outputs))
 		for i, output := range response.Outputs {
@@ -1491,25 +1491,25 @@ func (h *WalletHandler) DecodeTransaction(ctx context.Context, req *connect.Requ
 		}
 		owned, err := h.engine.Backend().OwnedAddresses(ctx, walletID, addresses)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("read address ownership: %w", err))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("read address ownership: %w", err).Error())
 		}
 		for _, output := range response.Outputs {
 			output.IsChange, output.IsMine = owned[output.Address]
 		}
 	}
 	response.WarningMessage = h.transactionWarning(response.Outputs)
-	return connect.NewResponse(response), nil
+	return response, nil
 }
 
-func (h *WalletHandler) decodeTxidResponse(ctx context.Context, txid, walletID string) (*connect.Response[pb.DecodeTransactionResponse], error) {
+func (h *WalletHandler) decodeTxidResponse(ctx context.Context, txid, walletID string) (*pb.DecodeTransactionResponse, error) {
 	resolved, err := h.engine.ResolveWalletID(walletID)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	rawTx, err := h.engine.ChainForWallet(resolved).GetRawTransaction(ctx, txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("transaction %s not found: %w", txid, err))
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("transaction %s not found: %w", txid, err).Error())
 	}
 
 	inputs, totalInput, allKnown := h.rawTxInputs(ctx, resolved, rawTx)
@@ -1540,7 +1540,7 @@ func (h *WalletHandler) decodeTxidResponse(ctx context.Context, txid, walletID s
 			}
 		}
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
 func (h *WalletHandler) rawTxInputs(ctx context.Context, walletID string, rawTx *wallet.RawTransaction) ([]*pb.TransactionInput, int64, bool) {
@@ -1658,31 +1658,31 @@ func decodedFormToProto(f wallet.DecodedForm) pb.DecodedForm {
 	}
 }
 
-func (h *WalletHandler) BumpFee(ctx context.Context, req *connect.Request[pb.BumpFeeRequest]) (*connect.Response[pb.BumpFeeResponse], error) {
+func (h *WalletHandler) BumpFee(ctx context.Context, req *pb.BumpFeeRequest) (*pb.BumpFeeResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// A bump of a deposit replaces the transaction the slot's treasury chain
 	// builds on. Hold the slot across the broadcast and the record move, or a
 	// deposit that starts between the two sees no treasury at all and builds a
 	// rival one.
-	if slot, isDeposit, slotErr := h.svc.SidechainDepositSlotOf(ctx, req.Msg.Txid); slotErr != nil {
-		return nil, connect.NewError(connect.CodeInternal, slotErr)
+	if slot, isDeposit, slotErr := h.svc.SidechainDepositSlotOf(ctx, req.Txid); slotErr != nil {
+		return nil, connect.NewError(connect.CodeInternal, slotErr.Error()).WithCause(slotErr)
 	} else if isDeposit {
 		unlock := h.lockDepositSlot(uint8(slot)) //nolint:gosec // a slot is 0-255
 		defer unlock()
 	}
 
 	result, err := h.engine.Backend().BumpFee(ctx, walletID, wallet.BumpFeeRequest{
-		TxID:        req.Msg.Txid,
-		NewFeeRate:  req.Msg.NewFeeRate,
-		FeeFromVout: voutPointer(req.Msg.FeeFromVout),
+		TxID:        req.Txid,
+		NewFeeRate:  req.NewFeeRate,
+		FeeFromVout: voutPointer(req.FeeFromVout),
 	})
 	if err != nil {
 		return nil, rpcError(err)
@@ -1690,31 +1690,31 @@ func (h *WalletHandler) BumpFee(ctx context.Context, req *connect.Request[pb.Bum
 
 	// A bumped deposit keeps its money on the way under a new txid. Without
 	// this the old record reads as a deposit the network lost.
-	if err := h.svc.RepointSidechainDeposit(ctx, req.Msg.Txid, result.NewTxID, result.Plan.NewFeeSats); err != nil {
-		h.svc.Log().Error().Err(err).Str("old_txid", req.Msg.Txid).Str("new_txid", result.NewTxID).
+	if err := h.svc.RepointSidechainDeposit(ctx, req.Txid, result.NewTxID, result.Plan.NewFeeSats); err != nil {
+		h.svc.Log().Error().Err(err).Str("old_txid", req.Txid).Str("new_txid", result.NewTxID).
 			Msg("could not move the deposit record onto the replacement")
 	}
 
-	return connect.NewResponse(&pb.BumpFeeResponse{
+	return &pb.BumpFeeResponse{
 		NewTxid: result.NewTxID,
 		Plan:    bumpFeePlanToProto(result.Plan),
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) PreviewBumpFee(ctx context.Context, req *connect.Request[pb.PreviewBumpFeeRequest]) (*connect.Response[pb.PreviewBumpFeeResponse], error) {
+func (h *WalletHandler) PreviewBumpFee(ctx context.Context, req *pb.PreviewBumpFeeRequest) (*pb.PreviewBumpFeeResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	preview, err := h.engine.Backend().PreviewBumpFee(ctx, walletID, wallet.BumpFeeRequest{
-		TxID:        req.Msg.Txid,
-		NewFeeRate:  req.Msg.NewFeeRate,
-		FeeFromVout: voutPointer(req.Msg.FeeFromVout),
+		TxID:        req.Txid,
+		NewFeeRate:  req.NewFeeRate,
+		FeeFromVout: voutPointer(req.FeeFromVout),
 	})
 	if err != nil {
 		return nil, rpcError(err)
@@ -1745,12 +1745,12 @@ func (h *WalletHandler) PreviewBumpFee(ctx context.Context, req *connect.Request
 		resp.Plan = bumpFeePlanToProto(*preview.Plan)
 	}
 
-	cancel, err := h.engine.Backend().PreviewCancel(ctx, walletID, req.Msg.Txid)
+	cancel, err := h.engine.Backend().PreviewCancel(ctx, walletID, req.Txid)
 	if err != nil {
 		// The user asked for a bump, so a cancel this node cannot price says so
 		// on its own button, and the bump preview stands.
 		resp.CancelReason = fmt.Sprintf("this node cannot price a cancel: %v", err)
-		return connect.NewResponse(resp), nil
+		return resp, nil
 	}
 	resp.CancelReason = cancel.Reason
 	if cancel.Plan != nil {
@@ -1759,31 +1759,31 @@ func (h *WalletHandler) PreviewBumpFee(ctx context.Context, req *connect.Request
 			FeeSats:       cancel.Plan.FeeSats,
 		}
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
-func (h *WalletHandler) CancelTransaction(ctx context.Context, req *connect.Request[pb.CancelTransactionRequest]) (*connect.Response[pb.CancelTransactionResponse], error) {
+func (h *WalletHandler) CancelTransaction(ctx context.Context, req *pb.CancelTransactionRequest) (*pb.CancelTransactionResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	if req.Msg.Txid == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("name the transaction to cancel"))
+	if req.Txid == "" {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "name the transaction to cancel")
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
-	result, err := h.engine.Backend().CancelTransaction(ctx, walletID, req.Msg.Txid, req.Msg.MaxFeeSats)
+	result, err := h.engine.Backend().CancelTransaction(ctx, walletID, req.Txid, req.MaxFeeSats)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.CancelTransactionResponse{
+	return &pb.CancelTransactionResponse{
 		ReplacementTxid: result.NewTxID,
 		RecoveredSats:   result.Plan.RecoveredSats,
 		FeeSats:         result.Plan.FeeSats,
-	}), nil
+	}, nil
 }
 
 // voutPointer maps the request's optional output index onto the backend's.
@@ -1809,81 +1809,81 @@ func bumpFeePlanToProto(plan wallet.BumpFeePlan) *pb.BumpFeePlan {
 	}
 }
 
-func (h *WalletHandler) CreateCpfp(ctx context.Context, req *connect.Request[pb.CreateCpfpRequest]) (*connect.Response[pb.CreateCpfpResponse], error) {
+func (h *WalletHandler) CreateCpfp(ctx context.Context, req *pb.CreateCpfpRequest) (*pb.CreateCpfpResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	// The child spends the parent output the caller names, so a freeze has to
 	// stop the call. No lock reaches an outpoint a caller pins by hand.
-	parent := wallet.Outpoint{TxID: req.Msg.ParentTxid, Vout: int(req.Msg.ParentVout)}
+	parent := wallet.Outpoint{TxID: req.ParentTxid, Vout: int(req.ParentVout)}
 	if h.svc.HeldCoins()[parent.Key()] {
-		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("the output %s is frozen; unfreeze it to spend it", parent.Key()))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
+			"the output %s is frozen; unfreeze it to spend it", parent.Key())
 	}
 
 	childTxID, err := h.engine.Backend().CreateCpfp(ctx, walletID, wallet.CpfpRequest{
-		ParentTxID: req.Msg.ParentTxid,
-		ParentVout: int(req.Msg.ParentVout),
-		TargetRate: req.Msg.TargetFeeRate,
+		ParentTxID: req.ParentTxid,
+		ParentVout: int(req.ParentVout),
+		TargetRate: req.TargetFeeRate,
 	})
 	if err != nil {
 		if connect.CodeOf(err) != connect.CodeUnknown {
 			return nil, err
 		}
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.CreateCpfpResponse{
+	return &pb.CreateCpfpResponse{
 		ChildTxid: childTxID,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) DeriveAddresses(ctx context.Context, req *connect.Request[pb.DeriveAddressesRequest]) (*connect.Response[pb.DeriveAddressesResponse], error) {
+func (h *WalletHandler) DeriveAddresses(ctx context.Context, req *pb.DeriveAddressesRequest) (*pb.DeriveAddressesResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
-	count := int(req.Msg.Count)
+	count := int(req.Count)
 	if count <= 0 {
 		count = 20
 	}
 
-	start := int(req.Msg.StartIndex)
+	start := int(req.StartIndex)
 
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	w := h.svc.GetWalletByID(walletID)
 	if w == nil {
-		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("wallet %s not found", walletID))
+		return nil, connect.Errorf(connect.CodeNotFound, "wallet %s not found", walletID)
 	}
 
 	addrs, err := wallet.DeriveWalletReceiveAddresses(w, h.engine.Network(), start, count)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.DeriveAddressesResponse{
+	return &pb.DeriveAddressesResponse{
 		Addresses: addrs,
-	}), nil
+	}, nil
 }
 
 // ============================================================================
 // Seed access
 // ============================================================================
 
-func (h *WalletHandler) GetWalletSeed(ctx context.Context, req *connect.Request[pb.GetWalletSeedRequest]) (*connect.Response[pb.GetWalletSeedResponse], error) {
-	walletID := req.Msg.WalletId
+func (h *WalletHandler) GetWalletSeed(ctx context.Context, req *pb.GetWalletSeedRequest) (*pb.GetWalletSeedResponse, error) {
+	walletID := req.WalletId
 	if walletID == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("wallet_id is required"))
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "wallet_id is required")
 	}
 
 	for _, w := range h.svc.GetAllWallets() {
@@ -1893,61 +1893,61 @@ func (h *WalletHandler) GetWalletSeed(ctx context.Context, req *connect.Request[
 		// Electrum wallets keep no master seed, so say so rather than hand back
 		// a blank one that reads like a successful answer.
 		if w.Master.SeedHex == "" {
-			return nil, connect.NewError(
+			return nil, connect.Errorf(
 				connect.CodeFailedPrecondition,
-				fmt.Errorf("wallet %s holds no master seed", walletID),
+				"wallet %s holds no master seed", walletID,
 			)
 		}
-		return connect.NewResponse(&pb.GetWalletSeedResponse{
+		return &pb.GetWalletSeedResponse{
 			SeedHex:  w.Master.SeedHex,
 			Mnemonic: w.Master.Mnemonic,
-		}), nil
+		}, nil
 	}
 
-	return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("wallet %s not found", walletID))
+	return nil, connect.Errorf(connect.CodeNotFound, "wallet %s not found", walletID)
 }
 
 func (h *WalletHandler) PreviewWalletFromEntropy(
 	ctx context.Context,
-	req *connect.Request[pb.PreviewWalletFromEntropyRequest],
-) (*connect.Response[pb.PreviewWalletFromEntropyResponse], error) {
+	req *pb.PreviewWalletFromEntropyRequest,
+) (*pb.PreviewWalletFromEntropyResponse, error) {
 	strength := wallet.Strength128
-	if req.Msg.WordCount == 24 {
+	if req.WordCount == 24 {
 		strength = wallet.Strength256
 	}
 
-	entropy := req.Msg.Entropy
+	entropy := req.Entropy
 	switch {
 	case len(entropy) > 0:
-	case req.Msg.SourceText != "":
+	case req.SourceText != "":
 		// Exact-length hex is what this handler itself hands back, so take it
 		// as-is; anything else is hashed, and one character is enough.
-		if raw, err := hex.DecodeString(req.Msg.SourceText); err == nil && len(raw) == strength.Bytes() {
+		if raw, err := hex.DecodeString(req.SourceText); err == nil && len(raw) == strength.Bytes() {
 			entropy = raw
 			break
 		}
-		digest := sha256.Sum256([]byte(req.Msg.SourceText))
+		digest := sha256.Sum256([]byte(req.SourceText))
 		entropy = digest[:strength.Bytes()]
 	default:
 		var err error
 		entropy, err = wallet.FreshEntropy(strength)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("generate entropy: %w", err))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("generate entropy: %w", err).Error())
 		}
 		// Client-supplied extra randomness folds into the fresh entropy, so
 		// the result is never weaker than crypto/rand alone.
-		if len(req.Msg.ExtraEntropy) > 0 {
-			digest := sha256.Sum256(append(entropy, req.Msg.ExtraEntropy...))
+		if len(req.ExtraEntropy) > 0 {
+			digest := sha256.Sum256(append(entropy, req.ExtraEntropy...))
 			entropy = digest[:strength.Bytes()]
 		}
 	}
 
-	w, err := h.svc.GenerateWalletFromEntropy(entropy, req.Msg.Passphrase, true, allSidechainSlots())
+	w, err := h.svc.GenerateWalletFromEntropy(entropy, req.Passphrase, true, allSidechainSlots())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("derive wallet from entropy: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("derive wallet from entropy: %w", err).Error())
 	}
 
-	return connect.NewResponse(&pb.PreviewWalletFromEntropyResponse{
+	return &pb.PreviewWalletFromEntropyResponse{
 		EntropyHex:       hex.EncodeToString(entropy),
 		Mnemonic:         w.Master.Mnemonic,
 		SeedHex:          w.Master.SeedHex,
@@ -1956,14 +1956,14 @@ func (h *WalletHandler) PreviewWalletFromEntropy(
 		Bip39Binary:      w.Master.BIP39Binary,
 		Bip39Checksum:    w.Master.BIP39Checksum,
 		Bip39ChecksumHex: w.Master.BIP39ChecksumHex,
-	}), nil
+	}, nil
 }
 
 // ============================================================================
 // Watch Wallet Data (server-streaming)
 // ============================================================================
 
-func (h *WalletHandler) WatchWalletData(ctx context.Context, req *connect.Request[emptypb.Empty], stream *connect.ServerStream[pb.WatchWalletDataResponse]) error {
+func (h *WalletHandler) WatchWalletData(ctx context.Context, req *emptypb.Empty, stream rpc.WalletManagerServiceWatchWalletDataServerStream) error {
 	var seq int64
 
 	// Per-stream subscription. The wallet service fans out notifyChanged to
@@ -2030,7 +2030,7 @@ func (h *WalletHandler) WatchWalletData(ctx context.Context, req *connect.Reques
 	}
 }
 
-func (h *WalletHandler) sendWalletData(stream *connect.ServerStream[pb.WatchWalletDataResponse], seq *int64) error {
+func (h *WalletHandler) sendWalletData(stream rpc.WalletManagerServiceWatchWalletDataServerStream, seq *int64) error {
 	resp := buildWatchWalletDataResponse(
 		h.svc.GetAllWallets(),
 		h.svc.ActiveWalletID(),
@@ -2134,9 +2134,9 @@ func buildWatchWalletDataResponse(wallets []wallet.WalletData, activeID, starter
 // Core variant RPCs
 // ============================================================================
 
-func (h *WalletHandler) ListCoreVariants(ctx context.Context, req *connect.Request[pb.ListCoreVariantsRequest]) (*connect.Response[pb.ListCoreVariantsResponse], error) {
+func (h *WalletHandler) ListCoreVariants(ctx context.Context, req *pb.ListCoreVariantsRequest) (*pb.ListCoreVariantsResponse, error) {
 	if h.orch == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not configured"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not configured")
 	}
 	out := lo.Map(h.orch.ListCoreVariants(), func(v orchestrator.CoreVariantSpec, _ int) *pb.CoreVariant {
 		return &pb.CoreVariant{
@@ -2158,43 +2158,43 @@ func (h *WalletHandler) ListCoreVariants(ctx context.Context, req *connect.Reque
 	if !lo.ContainsBy(out, func(v *pb.CoreVariant) bool { return v.Id == activeID }) {
 		activeID = ""
 	}
-	return connect.NewResponse(&pb.ListCoreVariantsResponse{
+	return &pb.ListCoreVariantsResponse{
 		Variants: out,
 		ActiveId: activeID,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) GetCoreVariant(ctx context.Context, req *connect.Request[pb.GetCoreVariantRequest]) (*connect.Response[pb.GetCoreVariantResponse], error) {
+func (h *WalletHandler) GetCoreVariant(ctx context.Context, req *pb.GetCoreVariantRequest) (*pb.GetCoreVariantResponse, error) {
 	if h.orch == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not configured"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not configured")
 	}
-	return connect.NewResponse(&pb.GetCoreVariantResponse{Id: h.orch.CoreVariant()}), nil
+	return &pb.GetCoreVariantResponse{Id: h.orch.CoreVariant()}, nil
 }
 
-func (h *WalletHandler) SetCoreVariant(ctx context.Context, req *connect.Request[pb.SetCoreVariantRequest]) (*connect.Response[pb.SetCoreVariantResponse], error) {
+func (h *WalletHandler) SetCoreVariant(ctx context.Context, req *pb.SetCoreVariantRequest) (*pb.SetCoreVariantResponse, error) {
 	if h.orch == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not configured"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not configured")
 	}
-	if req.Msg.Id == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("variant id required"))
+	if req.Id == "" {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "variant id required")
 	}
-	if err := h.orch.SetCoreVariant(ctx, req.Msg.Id); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+	if err := h.orch.SetCoreVariant(ctx, req.Id); err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.SetCoreVariantResponse{}), nil
+	return &pb.SetCoreVariantResponse{}, nil
 }
 
 // ============================================================================
 // Electrum server selection
 // ============================================================================
 
-func (h *WalletHandler) GetElectrumServer(ctx context.Context, req *connect.Request[pb.GetElectrumServerRequest]) (*connect.Response[pb.GetElectrumServerResponse], error) {
+func (h *WalletHandler) GetElectrumServer(ctx context.Context, req *pb.GetElectrumServerRequest) (*pb.GetElectrumServerResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("wallet engine not configured"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "wallet engine not configured")
 	}
 	url, err := h.engine.ElectrumServerURL()
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 	defaultURL := ""
 	override := ""
@@ -2202,29 +2202,29 @@ func (h *WalletHandler) GetElectrumServer(ctx context.Context, req *connect.Requ
 		defaultURL = h.orch.DefaultElectrumServerURL()
 		override = h.orch.ElectrumServerOverride()
 	}
-	return connect.NewResponse(&pb.GetElectrumServerResponse{
+	return &pb.GetElectrumServerResponse{
 		Url:        url,
 		IsOverride: override != "",
 		DefaultUrl: defaultURL,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) SetElectrumServer(ctx context.Context, req *connect.Request[pb.SetElectrumServerRequest]) (*connect.Response[pb.SetElectrumServerResponse], error) {
+func (h *WalletHandler) SetElectrumServer(ctx context.Context, req *pb.SetElectrumServerRequest) (*pb.SetElectrumServerResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("wallet engine not configured"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "wallet engine not configured")
 	}
 
 	// Empty URL resets to the network default; resolve it here so the switch is
 	// validated and persisted as a cleared override, not as a literal default.
-	target := req.Msg.Url
+	target := req.Url
 	reset := target == ""
 	if reset {
 		if h.orch == nil {
-			return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("orchestrator not configured"))
+			return nil, connect.Errorf(connect.CodeFailedPrecondition, "orchestrator not configured")
 		}
 		target = h.orch.DefaultElectrumServerURL()
 		if target == "" {
-			return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("no default electrum server for this network"))
+			return nil, connect.Errorf(connect.CodeFailedPrecondition, "no default electrum server for this network")
 		}
 	}
 
@@ -2239,65 +2239,65 @@ func (h *WalletHandler) SetElectrumServer(ctx context.Context, req *connect.Requ
 			persist = ""
 		}
 		if perr := h.orch.PersistElectrumServerURL(persist); perr != nil {
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("server switched but persisting it failed: %w", perr))
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("server switched but persisting it failed: %w", perr).Error())
 		}
 	}
 
-	return connect.NewResponse(&pb.SetElectrumServerResponse{
+	return &pb.SetElectrumServerResponse{
 		Url:       target,
 		TipHeight: int64(tip),
-	}), nil
+	}, nil
 }
 
 // ============================================================================
 // Tor routing
 // ============================================================================
 
-func (h *WalletHandler) GetTorConfig(ctx context.Context, req *connect.Request[pb.GetTorConfigRequest]) (*connect.Response[pb.GetTorConfigResponse], error) {
+func (h *WalletHandler) GetTorConfig(ctx context.Context, req *pb.GetTorConfigRequest) (*pb.GetTorConfigResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("wallet engine not configured"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "wallet engine not configured")
 	}
 	enabled, proxyAddr, err := h.engine.TorConfig()
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	return connect.NewResponse(&pb.GetTorConfigResponse{
+	return &pb.GetTorConfigResponse{
 		Enabled:      enabled,
 		Proxy:        proxyAddr,
 		DefaultProxy: orchestrator.DefaultTorProxy,
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) SetTorConfig(ctx context.Context, req *connect.Request[pb.SetTorConfigRequest]) (*connect.Response[pb.SetTorConfigResponse], error) {
+func (h *WalletHandler) SetTorConfig(ctx context.Context, req *pb.SetTorConfigRequest) (*pb.SetTorConfigResponse, error) {
 	if h.engine == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("wallet engine not configured"))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "wallet engine not configured")
 	}
 
-	proxyAddr := req.Msg.Proxy
-	if req.Msg.Enabled && proxyAddr == "" {
+	proxyAddr := req.Proxy
+	if req.Enabled && proxyAddr == "" {
 		proxyAddr = orchestrator.DefaultTorProxy
 	}
 
-	tip, err := h.engine.SetTorConfig(ctx, req.Msg.Enabled, proxyAddr)
+	tip, err := h.engine.SetTorConfig(ctx, req.Enabled, proxyAddr)
 	if err != nil {
 		return nil, err
 	}
 
 	if h.orch != nil {
 		persistProxy := proxyAddr
-		if !req.Msg.Enabled {
+		if !req.Enabled {
 			persistProxy = ""
 		}
-		if perr := h.orch.PersistTorConfig(req.Msg.Enabled, persistProxy); perr != nil {
-			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("tor routing switched but persisting it failed: %w", perr))
+		if perr := h.orch.PersistTorConfig(req.Enabled, persistProxy); perr != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("tor routing switched but persisting it failed: %w", perr).Error())
 		}
 	}
 
-	return connect.NewResponse(&pb.SetTorConfigResponse{
-		Enabled:   req.Msg.Enabled,
+	return &pb.SetTorConfigResponse{
+		Enabled:   req.Enabled,
 		Proxy:     proxyAddr,
 		TipHeight: int64(tip),
-	}), nil
+	}, nil
 }
 
 func coreVariantDisplayName(id string) string {
@@ -2385,83 +2385,83 @@ func btcToSats(btc float64) float64 {
 	return math.Round(btc * 1e8)
 }
 
-func (h *WalletHandler) CreatePsbt(ctx context.Context, req *connect.Request[pb.CreatePsbtRequest]) (*connect.Response[pb.CreatePsbtResponse], error) {
+func (h *WalletHandler) CreatePsbt(ctx context.Context, req *pb.CreatePsbtRequest) (*pb.CreatePsbtResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 	sendReq := wallet.SendRequest{
-		DestinationsSats:      req.Msg.Destinations,
-		FeeRateSatPerVB:       req.Msg.FeeRateSatPerVbyte,
-		FixedFeeSats:          req.Msg.FixedFeeSats,
-		OpReturnHex:           req.Msg.OpReturnHex,
-		SubtractFeeFromAmount: req.Msg.SubtractFeeFromAmount,
-		AllowReplay:           req.Msg.AllowReplay,
-	}
-	if err := h.refuseFrozenInputs(req.Msg.RequiredInputs); err != nil {
+		DestinationsSats:      req.Destinations,
+		FeeRateSatPerVB:       req.FeeRateSatPerVbyte,
+		FixedFeeSats:          req.FixedFeeSats,
+		OpReturnHex:           req.OpReturnHex,
+		SubtractFeeFromAmount: req.SubtractFeeFromAmount,
+		AllowReplay:           req.AllowReplay,
+	}
+	if err := h.refuseFrozenInputs(req.RequiredInputs); err != nil {
 		return nil, err
 	}
-	sendReq.RequiredInputs = lo.Map(req.Msg.RequiredInputs, func(u *pb.UnspentOutput, _ int) wallet.RequiredInput {
+	sendReq.RequiredInputs = lo.Map(req.RequiredInputs, func(u *pb.UnspentOutput, _ int) wallet.RequiredInput {
 		return wallet.RequiredInput{
 			TxID: u.Txid, Vout: int(u.Vout), AmountSats: u.AmountSats,
 		}
 	})
-	sendReq.RawOutputs = mapRawOutputs(req.Msg.RawOutputs)
-	sendReq.ExternalInputs = mapExternalInputs(req.Msg.ExternalInputs)
+	sendReq.RawOutputs = mapRawOutputs(req.RawOutputs)
+	sendReq.ExternalInputs = mapExternalInputs(req.ExternalInputs)
 	b64, err := h.engine.CreatePSBT(ctx, walletID, sendReq)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.CreatePsbtResponse{PsbtBase64: b64}), nil
+	return &pb.CreatePsbtResponse{PsbtBase64: b64}, nil
 }
 
-func (h *WalletHandler) SignPsbt(ctx context.Context, req *connect.Request[pb.SignPsbtRequest]) (*connect.Response[pb.SignPsbtResponse], error) {
+func (h *WalletHandler) SignPsbt(ctx context.Context, req *pb.SignPsbtRequest) (*pb.SignPsbtResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	walletID, err := h.engine.ResolveWalletID(req.Msg.WalletId)
+	walletID, err := h.engine.ResolveWalletID(req.WalletId)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+		return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
-	out, err := h.engine.SignPSBT(ctx, walletID, req.Msg.PsbtBase64)
+	out, err := h.engine.SignPSBT(ctx, walletID, req.PsbtBase64)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.SignPsbtResponse{PsbtBase64: out}), nil
+	return &pb.SignPsbtResponse{PsbtBase64: out}, nil
 }
 
-func (h *WalletHandler) CombinePsbt(ctx context.Context, req *connect.Request[pb.CombinePsbtRequest]) (*connect.Response[pb.CombinePsbtResponse], error) {
+func (h *WalletHandler) CombinePsbt(ctx context.Context, req *pb.CombinePsbtRequest) (*pb.CombinePsbtResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	out, err := h.engine.CombinePSBT(req.Msg.PsbtBase64)
+	out, err := h.engine.CombinePSBT(req.PsbtBase64)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.CombinePsbtResponse{PsbtBase64: out}), nil
+	return &pb.CombinePsbtResponse{PsbtBase64: out}, nil
 }
 
-func (h *WalletHandler) FinalizePsbt(ctx context.Context, req *connect.Request[pb.FinalizePsbtRequest]) (*connect.Response[pb.FinalizePsbtResponse], error) {
+func (h *WalletHandler) FinalizePsbt(ctx context.Context, req *pb.FinalizePsbtRequest) (*pb.FinalizePsbtResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	rawHex, err := h.engine.FinalizePSBT(req.Msg.PsbtBase64)
+	rawHex, err := h.engine.FinalizePSBT(req.PsbtBase64)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.FinalizePsbtResponse{RawTxHex: rawHex}), nil
+	return &pb.FinalizePsbtResponse{RawTxHex: rawHex}, nil
 }
 
-func (h *WalletHandler) GetAddressUnspent(ctx context.Context, req *connect.Request[pb.GetAddressUnspentRequest]) (*connect.Response[pb.GetAddressUnspentResponse], error) {
+func (h *WalletHandler) GetAddressUnspent(ctx context.Context, req *pb.GetAddressUnspentRequest) (*pb.GetAddressUnspentResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	address := strings.TrimSpace(req.Msg.Address)
+	address := strings.TrimSpace(req.Address)
 	if address == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("address is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "address is required")
 	}
 
 	utxos, tip, err := h.engine.AddressUnspent(ctx, address)
@@ -2469,7 +2469,7 @@ func (h *WalletHandler) GetAddressUnspent(ctx context.Context, req *connect.Requ
 		return nil, rpcError(err)
 	}
 
-	return connect.NewResponse(&pb.GetAddressUnspentResponse{
+	return &pb.GetAddressUnspentResponse{
 		Utxos: lo.Map(utxos, func(u wallet.UTXO, _ int) *pb.AddressUnspentOutput {
 			return &pb.AddressUnspentOutput{
 				Txid:          u.TxID,
@@ -2480,21 +2480,21 @@ func (h *WalletHandler) GetAddressUnspent(ctx context.Context, req *connect.Requ
 			}
 		}),
 		TipHeight: int32(tip),
-	}), nil
+	}, nil
 }
 
-func (h *WalletHandler) BroadcastElectrumTransaction(ctx context.Context, req *connect.Request[pb.BroadcastElectrumTransactionRequest]) (*connect.Response[pb.BroadcastElectrumTransactionResponse], error) {
+func (h *WalletHandler) BroadcastElectrumTransaction(ctx context.Context, req *pb.BroadcastElectrumTransactionRequest) (*pb.BroadcastElectrumTransactionResponse, error) {
 	if err := h.requireEngine(); err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
-	txHex := strings.TrimSpace(req.Msg.TxHex)
+	txHex := strings.TrimSpace(req.TxHex)
 	if txHex == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("tx_hex is required"))
+		return nil, connect.NewError(connect.CodeInvalidArgument, "tx_hex is required")
 	}
 
 	txid, err := h.engine.BroadcastRaw(ctx, txHex)
 	if err != nil {
 		return nil, rpcError(err)
 	}
-	return connect.NewResponse(&pb.BroadcastElectrumTransactionResponse{Txid: txid}), nil
+	return &pb.BroadcastElectrumTransactionResponse{Txid: txid}, nil
 }
diff --git a/sidechain-orchestrator/api/wallet_handler_decode_test.go b/sidechain-orchestrator/api/wallet_handler_decode_test.go
index 59e7b6fb38..d8b9d0c219 100644
--- a/sidechain-orchestrator/api/wallet_handler_decode_test.go
+++ b/sidechain-orchestrator/api/wallet_handler_decode_test.go
@@ -8,7 +8,7 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/psbt"
@@ -122,21 +122,21 @@ func TestDecodeTransactionChecksWalletOwnership(t *testing.T) {
 				fake.rawTx.Vout = append(fake.rawTx.Vout, wallet.RawTxOut{ScriptPubKey: wallet.ScriptPubKey{Address: address}})
 			}
 			h, walletID := newDecodeHandler(t, fake)
-			response, err := h.DecodeTransaction(context.Background(), connect.NewRequest(&pb.DecodeTransactionRequest{
+			response, err := h.DecodeTransaction(context.Background(), &pb.DecodeTransactionRequest{
 				Input: tc.input, WalletId: walletID, CheckOwnership: true,
-			}))
+			})
 			require.NoError(t, err)
 			require.Equal(t, walletID, fake.walletID)
 			require.Equal(t, addresses, fake.askedOwned)
-			require.Len(t, response.Msg.Outputs, 4)
-			require.False(t, response.Msg.Outputs[0].IsMine)
-			require.False(t, response.Msg.Outputs[0].IsChange)
-			require.True(t, response.Msg.Outputs[1].IsMine)
-			require.False(t, response.Msg.Outputs[1].IsChange)
-			require.True(t, response.Msg.Outputs[2].IsMine)
-			require.True(t, response.Msg.Outputs[2].IsChange)
-			require.False(t, response.Msg.Outputs[3].IsMine)
-			require.False(t, response.Msg.Outputs[3].IsChange)
+			require.Len(t, response.Outputs, 4)
+			require.False(t, response.Outputs[0].IsMine)
+			require.False(t, response.Outputs[0].IsChange)
+			require.True(t, response.Outputs[1].IsMine)
+			require.False(t, response.Outputs[1].IsChange)
+			require.True(t, response.Outputs[2].IsMine)
+			require.True(t, response.Outputs[2].IsChange)
+			require.False(t, response.Outputs[3].IsMine)
+			require.False(t, response.Outputs[3].IsChange)
 		})
 	}
 }
@@ -147,13 +147,13 @@ func TestDecodeTransactionKeepsStaticMetadata(t *testing.T) {
 	require.NoError(t, err)
 	fake := &decodeBackend{detailsProvider: detailsProvider{ownedErr: errors.New("unexpected wallet read")}}
 	h, _ := newDecodeHandler(t, fake)
-	response, err := h.DecodeTransaction(context.Background(), connect.NewRequest(&pb.DecodeTransactionRequest{Input: encoded}))
+	response, err := h.DecodeTransaction(context.Background(), &pb.DecodeTransactionRequest{Input: encoded})
 	require.NoError(t, err)
 	require.Empty(t, fake.askedOwned)
-	require.True(t, response.Msg.Outputs[0].IsChange)
-	require.True(t, response.Msg.Outputs[1].IsChange)
-	require.False(t, response.Msg.Outputs[2].IsChange)
-	for _, output := range response.Msg.Outputs {
+	require.True(t, response.Outputs[0].IsChange)
+	require.True(t, response.Outputs[1].IsChange)
+	require.False(t, response.Outputs[2].IsChange)
+	for _, output := range response.Outputs {
 		require.False(t, output.IsMine)
 	}
 }
@@ -179,14 +179,14 @@ func TestDecodeTransactionReadsLocalDataWithoutAnIndexer(t *testing.T) {
 			if !tc.wallet {
 				walletID = ""
 			}
-			response, err := h.DecodeTransaction(context.Background(), connect.NewRequest(&pb.DecodeTransactionRequest{
+			response, err := h.DecodeTransaction(context.Background(), &pb.DecodeTransactionRequest{
 				Input: tc.input, WalletId: walletID,
-			}))
+			})
 			require.NoError(t, err)
 			require.Zero(t, source.reads.Load())
-			require.Equal(t, packet.UnsignedTx.TxHash().String(), response.Msg.Txid)
-			require.Len(t, response.Msg.Outputs, len(packet.Outputs))
-			for _, output := range response.Msg.Outputs {
+			require.Equal(t, packet.UnsignedTx.TxHash().String(), response.Txid)
+			require.Len(t, response.Outputs, len(packet.Outputs))
+			for _, output := range response.Outputs {
 				require.False(t, output.IsMine)
 			}
 		})
@@ -199,9 +199,9 @@ func TestDecodeTransactionReturnsOwnershipError(t *testing.T) {
 	require.NoError(t, err)
 	fake := &decodeBackend{detailsProvider: detailsProvider{ownedErr: errors.New("wallet read failed")}}
 	h, walletID := newDecodeHandler(t, fake)
-	response, err := h.DecodeTransaction(context.Background(), connect.NewRequest(&pb.DecodeTransactionRequest{
+	response, err := h.DecodeTransaction(context.Background(), &pb.DecodeTransactionRequest{
 		Input: encoded, WalletId: walletID, CheckOwnership: true,
-	}))
+	})
 	require.Nil(t, response)
 	require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 	require.ErrorContains(t, err, "wallet read failed")
@@ -222,9 +222,9 @@ func TestDecodeTransactionChecksOwnershipWithAnOfflineIndexer(t *testing.T) {
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			h, walletID, source := newOfflineDecodeHandler(t)
-			response, err := h.DecodeTransaction(context.Background(), connect.NewRequest(&pb.DecodeTransactionRequest{
+			response, err := h.DecodeTransaction(context.Background(), &pb.DecodeTransactionRequest{
 				Input: tc.input, WalletId: walletID, CheckOwnership: true,
-			}))
+			})
 			require.Nil(t, response)
 			require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 			require.ErrorContains(t, err, "the indexer is offline")
diff --git a/sidechain-orchestrator/api/wallet_handler_derive_test.go b/sidechain-orchestrator/api/wallet_handler_derive_test.go
index 8b8f701199..bf89a62e7c 100644
--- a/sidechain-orchestrator/api/wallet_handler_derive_test.go
+++ b/sidechain-orchestrator/api/wallet_handler_derive_test.go
@@ -5,7 +5,7 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/rs/zerolog"
@@ -37,23 +37,23 @@ func TestDeriveAddressesSupportsPublicMultisig(t *testing.T) {
 	h := NewWalletHandler(svc)
 	h.SetEngine(wallet.NewWalletEngine(svc, wallet.NewBackendRouter(svc, nil, backend), wallet.StaticParams(net), log))
 	ctx := context.Background()
-	request := connect.NewRequest(&pb.DeriveAddressesRequest{WalletId: w.ID, StartIndex: 0, Count: 1})
+	request := &pb.DeriveAddressesRequest{WalletId: w.ID, StartIndex: 0, Count: 1}
 	first, err := h.DeriveAddresses(ctx, request)
 	require.NoError(t, err)
-	require.Len(t, first.Msg.Addresses, 1)
+	require.Len(t, first.Addresses, 1)
 	next, err := backend.NextReceiveAddress(ctx, w.ID, wallet.ScriptUnknown)
 	require.NoError(t, err)
 	require.Zero(t, next.Index)
-	require.Equal(t, first.Msg.Addresses[0], next.Address)
+	require.Equal(t, first.Addresses[0], next.Address)
 	again, err := h.DeriveAddresses(ctx, request)
 	require.NoError(t, err)
-	require.Equal(t, first.Msg.Addresses, again.Msg.Addresses)
+	require.Equal(t, first.Addresses, again.Addresses)
 }
 
 func TestDeriveAddressesRejectsAbsentWallet(t *testing.T) {
 	h, _ := newDecodeHandler(t, &decodeBackend{})
-	_, err := h.DeriveAddresses(context.Background(), connect.NewRequest(&pb.DeriveAddressesRequest{
+	_, err := h.DeriveAddresses(context.Background(), &pb.DeriveAddressesRequest{
 		WalletId: "absent", StartIndex: 0, Count: 1,
-	}))
+	})
 	require.Equal(t, connect.CodeNotFound, connect.CodeOf(err))
 }
diff --git a/sidechain-orchestrator/api/wallet_handler_psbt_test.go b/sidechain-orchestrator/api/wallet_handler_psbt_test.go
index 90497fc3ca..06c26b494c 100644
--- a/sidechain-orchestrator/api/wallet_handler_psbt_test.go
+++ b/sidechain-orchestrator/api/wallet_handler_psbt_test.go
@@ -5,7 +5,6 @@ import (
 	"errors"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
@@ -79,25 +78,25 @@ func TestWalletHandlerPSBTRoundTrip(t *testing.T) {
 	ctx := context.Background()
 	const dest = "tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx"
 
-	created, err := h.CreatePsbt(ctx, connect.NewRequest(&pb.CreatePsbtRequest{
+	created, err := h.CreatePsbt(ctx, &pb.CreatePsbtRequest{
 		WalletId:           w.ID,
 		Destinations:       map[string]int64{dest: 50_000},
 		FeeRateSatPerVbyte: 2,
-	}))
+	})
 	require.NoError(t, err)
-	require.NotEmpty(t, created.Msg.PsbtBase64)
+	require.NotEmpty(t, created.PsbtBase64)
 
-	signed, err := h.SignPsbt(ctx, connect.NewRequest(&pb.SignPsbtRequest{
+	signed, err := h.SignPsbt(ctx, &pb.SignPsbtRequest{
 		WalletId:   w.ID,
-		PsbtBase64: created.Msg.PsbtBase64,
-	}))
+		PsbtBase64: created.PsbtBase64,
+	})
 	require.NoError(t, err)
 
-	final, err := h.FinalizePsbt(ctx, connect.NewRequest(&pb.FinalizePsbtRequest{
-		PsbtBase64: signed.Msg.PsbtBase64,
-	}))
+	final, err := h.FinalizePsbt(ctx, &pb.FinalizePsbtRequest{
+		PsbtBase64: signed.PsbtBase64,
+	})
 	require.NoError(t, err)
-	require.NotEmpty(t, final.Msg.RawTxHex)
+	require.NotEmpty(t, final.RawTxHex)
 }
 
 // TestWalletNeedsL1 covers the switch-time L1 decision: only electrum wallets
@@ -131,11 +130,11 @@ func TestListWalletsElectrumHasNoBip47Code(t *testing.T) {
 	require.NoError(t, err)
 
 	h := NewWalletHandler(svc)
-	resp, err := h.ListWallets(context.Background(), connect.NewRequest(&pb.ListWalletsRequest{}))
+	resp, err := h.ListWallets(context.Background(), &pb.ListWalletsRequest{})
 	require.NoError(t, err)
 
 	found := false
-	for _, mw := range resp.Msg.Wallets {
+	for _, mw := range resp.Wallets {
 		if mw.Id == w.ID {
 			found = true
 			require.Empty(t, mw.Bip47PaymentCode, "electrum wallet must not advertise a BIP47 code")
diff --git a/sidechain-orchestrator/api/wallet_handler_routing_test.go b/sidechain-orchestrator/api/wallet_handler_routing_test.go
index 7766c5c294..0493a03b78 100644
--- a/sidechain-orchestrator/api/wallet_handler_routing_test.go
+++ b/sidechain-orchestrator/api/wallet_handler_routing_test.go
@@ -7,7 +7,8 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -78,7 +79,7 @@ func TestSendTransactionRoutesPerWalletType(t *testing.T) {
 	h, elecFake, chainFake, elecID, coreID := newRoutedHandler(t)
 	ctx := context.Background()
 
-	resp, err := h.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+	resp, err := h.SendTransaction(ctx, &pb.SendTransactionRequest{
 		WalletId:           elecID,
 		Destinations:       map[string]int64{"addr": 10_000},
 		FeeRateSatPerVbyte: 2,
@@ -86,9 +87,9 @@ func TestSendTransactionRoutesPerWalletType(t *testing.T) {
 		RequiredInputs: []*pb.UnspentOutput{
 			{Txid: "pin", Vout: 3, AmountSats: 40_000},
 		},
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "fake-txid", resp.Msg.Txid)
+	assert.Equal(t, "fake-txid", resp.Txid)
 
 	assert.Equal(t, elecID, elecFake.lastSendWallet)
 	assert.Equal(t, int64(10_000), elecFake.lastSend.DestinationsSats["addr"])
@@ -98,10 +99,10 @@ func TestSendTransactionRoutesPerWalletType(t *testing.T) {
 	assert.Equal(t, wallet.RequiredInput{TxID: "pin", Vout: 3, AmountSats: 40_000}, elecFake.lastSend.RequiredInputs[0])
 	assert.Empty(t, chainFake.lastSendWallet)
 
-	_, err = h.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+	_, err = h.SendTransaction(ctx, &pb.SendTransactionRequest{
 		WalletId:     coreID,
 		Destinations: map[string]int64{"addr": 10_000},
-	}))
+	})
 	require.NoError(t, err)
 	assert.Equal(t, coreID, chainFake.lastSendWallet)
 }
@@ -118,12 +119,12 @@ func TestSendTransactionRefusesACoreMixedFeeFirst(t *testing.T) {
 		}
 	}
 
-	_, err := h.SendTransaction(ctx, connect.NewRequest(mixed(coreID)))
+	_, err := h.SendTransaction(ctx, mixed(coreID))
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	assert.Empty(t, chainFake.lastSendWallet)
 
-	_, err = h.SendTransaction(ctx, connect.NewRequest(mixed(elecID)))
+	_, err = h.SendTransaction(ctx, mixed(elecID))
 	require.NoError(t, err)
 	assert.Equal(t, elecID, elecFake.lastSendWallet)
 }
@@ -135,14 +136,14 @@ func TestSendTransactionPassesThroughConnectCodes(t *testing.T) {
 	// the handler must not rewrap it as internal.
 	elecFake.sendErr = connect.NewError(
 		connect.CodeInvalidArgument,
-		errors.New("this wallet cannot allow a replay"),
+		"this wallet cannot allow a replay",
 	)
 
-	_, err := h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err := h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:     elecID,
 		Destinations: map[string]int64{"addr": 10_000},
 		AllowReplay:  true,
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
@@ -150,10 +151,10 @@ func TestSendTransactionPassesThroughConnectCodes(t *testing.T) {
 func TestSendTransactionDustCheck(t *testing.T) {
 	h, elecFake, _, elecID, _ := newRoutedHandler(t)
 
-	_, err := h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err := h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:     elecID,
 		Destinations: map[string]int64{"addr": 100},
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 	assert.Empty(t, elecFake.lastSendWallet)
@@ -162,20 +163,20 @@ func TestSendTransactionDustCheck(t *testing.T) {
 func TestGetBalanceUsesProviderAndConvertsToSats(t *testing.T) {
 	h, _, _, _, coreID := newRoutedHandler(t)
 
-	resp, err := h.GetBalance(context.Background(), connect.NewRequest(&pb.GetBalanceRequest{WalletId: coreID}))
+	resp, err := h.GetBalance(context.Background(), &pb.GetBalanceRequest{WalletId: coreID})
 	require.NoError(t, err)
-	assert.Equal(t, float64(150_000_000), resp.Msg.ConfirmedSats)
-	assert.Equal(t, float64(25_000_000), resp.Msg.UnconfirmedSats)
-	assert.Equal(t, float64(625_000_000), resp.Msg.ImmatureSats)
+	assert.Equal(t, float64(150_000_000), resp.ConfirmedSats)
+	assert.Equal(t, float64(25_000_000), resp.UnconfirmedSats)
+	assert.Equal(t, float64(625_000_000), resp.ImmatureSats)
 }
 
 func TestGetBalanceEmptyWalletIDResolvesActive(t *testing.T) {
 	h, _, _, _, coreID := newRoutedHandler(t)
 
 	// GenerateWallet leaves the most recent wallet active (the core one).
-	resp, err := h.GetBalance(context.Background(), connect.NewRequest(&pb.GetBalanceRequest{}))
+	resp, err := h.GetBalance(context.Background(), &pb.GetBalanceRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, float64(150_000_000), resp.Msg.ConfirmedSats)
+	assert.Equal(t, float64(150_000_000), resp.ConfirmedSats)
 	_ = coreID
 }
 
@@ -238,13 +239,13 @@ func TestCancelTransactionRoutesPerWalletType(t *testing.T) {
 		{walletID: coreID, fake: chainFake, other: elecFake},
 	} {
 		tc.other.lastBumpWallet, tc.other.lastCancelTxid = "", ""
-		resp, err := h.CancelTransaction(context.Background(), connect.NewRequest(&pb.CancelTransactionRequest{
+		resp, err := h.CancelTransaction(context.Background(), &pb.CancelTransactionRequest{
 			WalletId: tc.walletID, Txid: "abc", MaxFeeSats: 5_332,
-		}))
+		})
 		require.NoError(t, err)
-		assert.Equal(t, "cancel-txid", resp.Msg.ReplacementTxid)
-		assert.Equal(t, int64(194_668), resp.Msg.RecoveredSats)
-		assert.Equal(t, int64(5_332), resp.Msg.FeeSats)
+		assert.Equal(t, "cancel-txid", resp.ReplacementTxid)
+		assert.Equal(t, int64(194_668), resp.RecoveredSats)
+		assert.Equal(t, int64(5_332), resp.FeeSats)
 		assert.Equal(t, tc.walletID, tc.fake.lastBumpWallet)
 		assert.Equal(t, "abc", tc.fake.lastCancelTxid)
 		assert.Equal(t, int64(5_332), tc.fake.lastCancelMaxFee)
@@ -258,16 +259,16 @@ func TestCancelTransactionRoutesPerWalletType(t *testing.T) {
 func TestBumpFeeCarriesOutputZero(t *testing.T) {
 	h, elecFake, _, elecID, _ := newRoutedHandler(t)
 
-	_, err := h.BumpFee(context.Background(), connect.NewRequest(&pb.BumpFeeRequest{
+	_, err := h.BumpFee(context.Background(), &pb.BumpFeeRequest{
 		WalletId: elecID, Txid: "abc", NewFeeRate: 10, FeeFromVout: proto.Int32(0),
-	}))
+	})
 	require.NoError(t, err)
 	require.NotNil(t, elecFake.lastBump.FeeFromVout)
 	assert.Equal(t, 0, *elecFake.lastBump.FeeFromVout)
 
-	_, err = h.BumpFee(context.Background(), connect.NewRequest(&pb.BumpFeeRequest{
+	_, err = h.BumpFee(context.Background(), &pb.BumpFeeRequest{
 		WalletId: elecID, Txid: "abc", NewFeeRate: 10,
-	}))
+	})
 	require.NoError(t, err)
 	assert.Nil(t, elecFake.lastBump.FeeFromVout, "an unset output means the change output")
 }
@@ -275,31 +276,31 @@ func TestBumpFeeCarriesOutputZero(t *testing.T) {
 func TestBumpFeeReportsThePlan(t *testing.T) {
 	h, _, _, elecID, _ := newRoutedHandler(t)
 
-	resp, err := h.BumpFee(context.Background(), connect.NewRequest(&pb.BumpFeeRequest{
+	resp, err := h.BumpFee(context.Background(), &pb.BumpFeeRequest{
 		WalletId: elecID, Txid: "abc", NewFeeRate: 10,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "replacement-txid", resp.Msg.NewTxid)
-	require.NotNil(t, resp.Msg.Plan)
-	assert.Equal(t, int64(150), resp.Msg.Plan.OldFeeSats)
-	assert.Equal(t, int64(1500), resp.Msg.Plan.NewFeeSats)
-	assert.Equal(t, int64(1350), resp.Msg.Plan.ExtraFeeSats)
-	assert.InDelta(t, 10.0, resp.Msg.Plan.NewFeeRateSatVb, 0.001)
-	assert.Equal(t, int32(1), resp.Msg.Plan.FeeFromVout)
-	assert.Equal(t, int64(99_850), resp.Msg.Plan.AmountBeforeSats)
-	assert.Equal(t, int64(98_500), resp.Msg.Plan.AmountAfterSats)
-	assert.False(t, resp.Msg.Plan.OutputRemoved)
-	assert.True(t, resp.Msg.Plan.ReducesPayment)
+	assert.Equal(t, "replacement-txid", resp.NewTxid)
+	require.NotNil(t, resp.Plan)
+	assert.Equal(t, int64(150), resp.Plan.OldFeeSats)
+	assert.Equal(t, int64(1500), resp.Plan.NewFeeSats)
+	assert.Equal(t, int64(1350), resp.Plan.ExtraFeeSats)
+	assert.InDelta(t, 10.0, resp.Plan.NewFeeRateSatVb, 0.001)
+	assert.Equal(t, int32(1), resp.Plan.FeeFromVout)
+	assert.Equal(t, int64(99_850), resp.Plan.AmountBeforeSats)
+	assert.Equal(t, int64(98_500), resp.Plan.AmountAfterSats)
+	assert.False(t, resp.Plan.OutputRemoved)
+	assert.True(t, resp.Plan.ReducesPayment)
 }
 
 func TestPreviewBumpFeeReportsEveryField(t *testing.T) {
 	h, _, _, elecID, _ := newRoutedHandler(t)
 
-	resp, err := h.PreviewBumpFee(context.Background(), connect.NewRequest(&pb.PreviewBumpFeeRequest{
+	resp, err := h.PreviewBumpFee(context.Background(), &pb.PreviewBumpFeeRequest{
 		WalletId: elecID, Txid: "abc",
-	}))
+	})
 	require.NoError(t, err)
-	msg := resp.Msg
+	msg := resp
 	assert.Equal(t, int32(2), msg.InputCount)
 	assert.Equal(t, int64(151), msg.VsizeVbytes)
 	assert.Equal(t, int64(151), msg.OldFeeSats)
@@ -327,22 +328,22 @@ func TestPreviewBumpFeeSurvivesAFailedCancelPreview(t *testing.T) {
 	h, elecFake, _, elecID, _ := newRoutedHandler(t)
 	elecFake.cancelErr = errors.New("read the parent abc: no such mempool transaction")
 
-	resp, err := h.PreviewBumpFee(context.Background(), connect.NewRequest(&pb.PreviewBumpFeeRequest{
+	resp, err := h.PreviewBumpFee(context.Background(), &pb.PreviewBumpFeeRequest{
 		WalletId: elecID, Txid: "abc",
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, int32(2), resp.Msg.InputCount)
-	assert.Nil(t, resp.Msg.Cancel)
-	assert.Contains(t, resp.Msg.CancelReason, "cannot price a cancel")
+	assert.Equal(t, int32(2), resp.InputCount)
+	assert.Nil(t, resp.Cancel)
+	assert.Contains(t, resp.CancelReason, "cannot price a cancel")
 }
 
 func TestBumpFeeKeepsTheBackendErrorCode(t *testing.T) {
 	h, elecFake, _, elecID, _ := newRoutedHandler(t)
-	elecFake.bumpErr = connect.NewError(connect.CodeFailedPrecondition, errors.New("transaction is confirmed"))
+	elecFake.bumpErr = connect.NewError(connect.CodeFailedPrecondition, "transaction is confirmed")
 
-	_, err := h.BumpFee(context.Background(), connect.NewRequest(&pb.BumpFeeRequest{
+	_, err := h.BumpFee(context.Background(), &pb.BumpFeeRequest{
 		WalletId: elecID, Txid: "abc",
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err),
 		"the dialog shows a reason, not an internal error")
@@ -412,14 +413,16 @@ func TestSendTransactionRequestRules(t *testing.T) {
 					send := h.SendTransaction
 					if mode == "connect" {
 						mux := http.NewServeMux()
-						mux.Handle(rpc.NewWalletManagerServiceHandler(h))
+						srv := connect.NewServer()
+						rpc.RegisterWalletManagerServiceHandler(srv, h)
+						connecthttp.Mount(mux, srv)
 						server := httptest.NewServer(mux)
 						t.Cleanup(server.Close)
-						send = rpc.NewWalletManagerServiceClient(server.Client(), server.URL).SendTransaction
+						send = rpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL))).SendTransaction
 					}
 
 					tc.request.WalletId = walletID
-					response, err := send(context.Background(), connect.NewRequest(tc.request))
+					response, err := send(context.Background(), tc.request)
 					assert.Empty(t, core.lastSendWallet)
 					if tc.wantErr != "" {
 						require.ErrorContains(t, err, tc.wantErr)
@@ -429,7 +432,7 @@ func TestSendTransactionRequestRules(t *testing.T) {
 					}
 
 					require.NoError(t, err)
-					assert.Equal(t, "fake-txid", response.Msg.Txid)
+					assert.Equal(t, "fake-txid", response.Txid)
 					assert.Equal(t, walletID, electrum.lastSendWallet)
 					assert.Equal(t, tc.request.FeeRateSatPerVbyte, electrum.lastSend.FeeRateSatPerVB)
 					assert.Equal(t, tc.request.FixedFeeSats, electrum.lastSend.FixedFeeSats)
diff --git a/sidechain-orchestrator/api/wallet_handler_txdetails_test.go b/sidechain-orchestrator/api/wallet_handler_txdetails_test.go
index 16e487e3b8..5ca205e77e 100644
--- a/sidechain-orchestrator/api/wallet_handler_txdetails_test.go
+++ b/sidechain-orchestrator/api/wallet_handler_txdetails_test.go
@@ -7,7 +7,7 @@ import (
 	"errors"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
@@ -106,18 +106,18 @@ func TestGetTransactionDetailsMarksTheChangeOutput(t *testing.T) {
 	}
 	h, walletID := newDetailsHandler(t, fake)
 
-	resp, err := h.GetTransactionDetails(context.Background(), connect.NewRequest(&pb.GetTransactionDetailsRequest{
+	resp, err := h.GetTransactionDetails(context.Background(), &pb.GetTransactionDetailsRequest{
 		WalletId: walletID,
 		Txid:     "tx",
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, resp.Msg.Outputs, 3)
+	require.Len(t, resp.Outputs, 3)
 
-	assert.False(t, resp.Msg.Outputs[0].IsMine, "the payment leaves the wallet")
-	assert.False(t, resp.Msg.Outputs[0].IsChange)
-	assert.False(t, resp.Msg.Outputs[1].IsMine, "an OP_RETURN output has no address")
-	assert.True(t, resp.Msg.Outputs[2].IsMine)
-	assert.True(t, resp.Msg.Outputs[2].IsChange)
+	assert.False(t, resp.Outputs[0].IsMine, "the payment leaves the wallet")
+	assert.False(t, resp.Outputs[0].IsChange)
+	assert.False(t, resp.Outputs[1].IsMine, "an OP_RETURN output has no address")
+	assert.True(t, resp.Outputs[2].IsMine)
+	assert.True(t, resp.Outputs[2].IsChange)
 	assert.Equal(t, []string{"stranger", "", "change"}, fake.askedOwned)
 }
 
@@ -128,15 +128,15 @@ func TestGetTransactionDetailsMarksAReceiveOutput(t *testing.T) {
 	}
 	h, walletID := newDetailsHandler(t, fake)
 
-	resp, err := h.GetTransactionDetails(context.Background(), connect.NewRequest(&pb.GetTransactionDetailsRequest{
+	resp, err := h.GetTransactionDetails(context.Background(), &pb.GetTransactionDetailsRequest{
 		WalletId: walletID,
 		Txid:     "tx",
-	}))
+	})
 	require.NoError(t, err)
-	require.Len(t, resp.Msg.Outputs, 3)
+	require.Len(t, resp.Outputs, 3)
 
-	assert.True(t, resp.Msg.Outputs[0].IsMine)
-	assert.False(t, resp.Msg.Outputs[0].IsChange, "a receive address is not change")
+	assert.True(t, resp.Outputs[0].IsMine)
+	assert.False(t, resp.Outputs[0].IsChange, "a receive address is not change")
 }
 
 func TestGetTransactionDetailsFailsOnAnOwnershipError(t *testing.T) {
@@ -146,10 +146,10 @@ func TestGetTransactionDetailsFailsOnAnOwnershipError(t *testing.T) {
 	}
 	h, walletID := newDetailsHandler(t, fake)
 
-	_, err := h.GetTransactionDetails(context.Background(), connect.NewRequest(&pb.GetTransactionDetailsRequest{
+	_, err := h.GetTransactionDetails(context.Background(), &pb.GetTransactionDetailsRequest{
 		WalletId: walletID,
 		Txid:     "tx",
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 }
@@ -159,16 +159,16 @@ func TestSetFrozenCoinsRecordsTheWholeSet(t *testing.T) {
 	h, _ := newDetailsHandler(t, fake)
 	ctx := context.Background()
 
-	_, err := h.SetFrozenCoins(ctx, connect.NewRequest(&pb.SetFrozenCoinsRequest{
+	_, err := h.SetFrozenCoins(ctx, &pb.SetFrozenCoinsRequest{
 		Outpoints: []*pb.FrozenOutpoint{{Txid: "held", Vout: 1}},
-	}))
+	})
 	require.NoError(t, err)
 
 	held := h.svc.HeldCoins()
 	assert.True(t, held[wallet.Outpoint{TxID: "held", Vout: 1}.Key()])
 
 	// An unfreeze arrives as a smaller set, and it must free the coin.
-	_, err = h.SetFrozenCoins(ctx, connect.NewRequest(&pb.SetFrozenCoinsRequest{}))
+	_, err = h.SetFrozenCoins(ctx, &pb.SetFrozenCoinsRequest{})
 	require.NoError(t, err)
 	assert.Empty(t, h.svc.HeldCoins())
 }
@@ -177,9 +177,9 @@ func TestSetFrozenCoinsRefusesACoinWithoutATxid(t *testing.T) {
 	fake := &detailsProvider{rawTx: paymentWithChange()}
 	h, _ := newDetailsHandler(t, fake)
 
-	_, err := h.SetFrozenCoins(context.Background(), connect.NewRequest(&pb.SetFrozenCoinsRequest{
+	_, err := h.SetFrozenCoins(context.Background(), &pb.SetFrozenCoinsRequest{
 		Outpoints: []*pb.FrozenOutpoint{{Vout: 1}},
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
 }
@@ -209,12 +209,12 @@ func TestCreateCpfpRefusesAFrozenParent(t *testing.T) {
 	h, walletID := newDetailsHandler(t, fake)
 	h.svc.SetHeldCoins([]wallet.Outpoint{{TxID: "parent", Vout: 1}})
 
-	_, err := h.CreateCpfp(context.Background(), connect.NewRequest(&pb.CreateCpfpRequest{
+	_, err := h.CreateCpfp(context.Background(), &pb.CreateCpfpRequest{
 		WalletId:      walletID,
 		ParentTxid:    "parent",
 		ParentVout:    1,
 		TargetFeeRate: 10,
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	assert.Contains(t, err.Error(), "is frozen")
@@ -226,11 +226,11 @@ func TestSendRefusesAFrozenRequiredInput(t *testing.T) {
 	h, walletID := newDetailsHandler(t, fake)
 	h.svc.SetHeldCoins([]wallet.Outpoint{{TxID: "frozen", Vout: 0}})
 
-	_, err := h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err := h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:       walletID,
 		Destinations:   map[string]int64{"bcrt1qdest": 50_000},
 		RequiredInputs: []*pb.UnspentOutput{{Txid: "frozen", Vout: 0}},
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	assert.Contains(t, err.Error(), "is frozen")
@@ -242,11 +242,11 @@ func TestSendAllowsAPinThatIsNotFrozen(t *testing.T) {
 	h, walletID := newDetailsHandler(t, fake)
 	h.svc.SetHeldCoins([]wallet.Outpoint{{TxID: "frozen", Vout: 0}})
 
-	_, err := h.SendTransaction(context.Background(), connect.NewRequest(&pb.SendTransactionRequest{
+	_, err := h.SendTransaction(context.Background(), &pb.SendTransactionRequest{
 		WalletId:       walletID,
 		Destinations:   map[string]int64{"bcrt1qdest": 50_000},
 		RequiredInputs: []*pb.UnspentOutput{{Txid: "free", Vout: 0}},
-	}))
+	})
 	// The fake backend cannot send, so the call fails later than the check.
 	require.Error(t, err)
 	assert.NotContains(t, err.Error(), "is frozen")
@@ -270,10 +270,10 @@ func TestBroadcastRefusesAFrozenInput(t *testing.T) {
 
 	h.svc.SetHeldCoins([]wallet.Outpoint{{TxID: parent.String(), Vout: 1}})
 
-	_, err = h.BroadcastTransaction(context.Background(), connect.NewRequest(&pb.BroadcastTransactionRequest{
+	_, err = h.BroadcastTransaction(context.Background(), &pb.BroadcastTransactionRequest{
 		WalletId: walletID,
 		TxHex:    hex.EncodeToString(raw.Bytes()),
-	}))
+	})
 	require.Error(t, err)
 	assert.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
 	assert.Contains(t, err.Error(), "is frozen")
diff --git a/sidechain-orchestrator/api/wallet_status_test.go b/sidechain-orchestrator/api/wallet_status_test.go
index 15bbc081e1..a5a45b9059 100644
--- a/sidechain-orchestrator/api/wallet_status_test.go
+++ b/sidechain-orchestrator/api/wallet_status_test.go
@@ -2,6 +2,8 @@ package api
 
 import (
 	"context"
+	"errors"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -9,7 +11,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -28,12 +31,12 @@ func TestWalletStatusAndUnlockCodes(t *testing.T) {
 
 	status := func() *pb.GetWalletStatusResponse {
 		t.Helper()
-		resp, err := h.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		resp, err := h.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		return resp.Msg
+		return resp
 	}
 	unlock := func(password string) connect.Code {
-		_, err := h.UnlockWallet(ctx, connect.NewRequest(&pb.UnlockWalletRequest{Password: password}))
+		_, err := h.UnlockWallet(ctx, &pb.UnlockWalletRequest{Password: password})
 		return connect.CodeOf(err)
 	}
 
@@ -58,7 +61,7 @@ func TestWalletStatusAndUnlockCodes(t *testing.T) {
 	require.False(t, s.Unlocked) //nolint:staticcheck // old apps read it
 
 	require.Equal(t, connect.CodeUnauthenticated, unlock("wrong"))
-	_, err = h.UnlockWallet(ctx, connect.NewRequest(&pb.UnlockWalletRequest{Password: "pass"}))
+	_, err = h.UnlockWallet(ctx, &pb.UnlockWalletRequest{Password: "pass"})
 	require.NoError(t, err)
 	require.Equal(t, pb.WalletState_WALLET_STATE_UNLOCKED, status().State)
 }
@@ -69,18 +72,18 @@ func TestWalletPasswordCodes(t *testing.T) {
 		call func(*WalletHandler, string) error
 	}{
 		{"unlock", func(h *WalletHandler, password string) error {
-			_, err := h.UnlockWallet(t.Context(), connect.NewRequest(&pb.UnlockWalletRequest{Password: password}))
+			_, err := h.UnlockWallet(t.Context(), &pb.UnlockWalletRequest{Password: password})
 			return err
 		}},
 		{"change password", func(h *WalletHandler, password string) error {
-			_, err := h.ChangePassword(t.Context(), connect.NewRequest(&pb.ChangePasswordRequest{
+			_, err := h.ChangePassword(t.Context(), &pb.ChangePasswordRequest{
 				OldPassword: password,
 				NewPassword: "newpass",
-			}))
+			})
 			return err
 		}},
 		{"remove encryption", func(h *WalletHandler, password string) error {
-			_, err := h.RemoveEncryption(t.Context(), connect.NewRequest(&pb.RemoveEncryptionRequest{Password: password}))
+			_, err := h.RemoveEncryption(t.Context(), &pb.RemoveEncryptionRequest{Password: password})
 			return err
 		}},
 	} {
@@ -124,10 +127,10 @@ func TestChangePasswordFileError(t *testing.T) {
 	require.NoError(t, os.Chmod(metaPath, 0400))
 	require.NoError(t, os.Mkdir(metaPath+".tmp", 0700))
 
-	_, err = NewWalletHandler(svc).ChangePassword(t.Context(), connect.NewRequest(&pb.ChangePasswordRequest{
+	_, err = NewWalletHandler(svc).ChangePassword(t.Context(), &pb.ChangePasswordRequest{
 		OldPassword: "oldpass",
 		NewPassword: "newpass",
-	}))
+	})
 	require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
 	require.ErrorContains(t, err, "write encryption metadata")
 	var pathErr *os.PathError
@@ -145,29 +148,41 @@ func TestLockSendsALockedFrame(t *testing.T) {
 	require.NoError(t, svc.EncryptWallet("pass"))
 
 	mux := http.NewServeMux()
-	mux.Handle(rpc.NewWalletManagerServiceHandler(NewWalletHandler(svc)))
+	srv := connect.NewServer()
+	rpc.RegisterWalletManagerServiceHandler(srv, NewWalletHandler(svc))
+	connecthttp.Mount(mux, srv, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
-	client := rpc.NewWalletManagerServiceClient(server.Client(), server.URL)
+	client := rpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
-	stream, err := client.WatchWalletData(ctx, connect.NewRequest(&emptypb.Empty{}))
+	stream, err := client.WatchWalletData(ctx, &emptypb.Empty{})
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = stream.Close() })
 
-	require.True(t, stream.Receive(), stream.Err())
-	require.Equal(t, pb.WalletState_WALLET_STATE_UNLOCKED, stream.Msg().State)
+	response, err := stream.Receive()
+	require.NoError(t, err)
+	require.Equal(t, pb.WalletState_WALLET_STATE_UNLOCKED, response.State)
 
 	svc.LockWallet()
 
-	for stream.Receive() {
-		if stream.Msg().Heartbeat {
+	var streamErr error
+	for {
+		msg, err := stream.Receive()
+		if err != nil {
+			streamErr = err
+			break
+		}
+		if msg.Heartbeat {
 			continue
 		}
-		require.Equal(t, pb.WalletState_WALLET_STATE_LOCKED, stream.Msg().State)
-		require.Empty(t, stream.Msg().Wallets)
+		require.Equal(t, pb.WalletState_WALLET_STATE_LOCKED, msg.State)
+		require.Empty(t, msg.Wallets)
 		return
 	}
-	t.Fatalf("no frame after the lock: %v", stream.Err())
+	if errors.Is(streamErr, io.EOF) {
+		streamErr = nil
+	}
+	t.Fatalf("no frame after the lock: %v", streamErr)
 }
diff --git a/sidechain-orchestrator/backend_only_test.go b/sidechain-orchestrator/backend_only_test.go
index 106c3e96c4..93d1f11d97 100644
--- a/sidechain-orchestrator/backend_only_test.go
+++ b/sidechain-orchestrator/backend_only_test.go
@@ -89,6 +89,7 @@ func TestBackendOnlyStopKeepsTheWindowCleanup(t *testing.T) {
 	require.True(t, o.process.IsRunning(guiName))
 
 	require.NoError(t, o.Stop(context.Background(), config.Name, true))
+	o.process.WaitForExit(config.Name, 5*time.Second)
 	o.process.WaitForExit(guiName, 5*time.Second)
 	require.False(t, o.process.IsRunning(guiName),
 		"a backend-only daemon must still close a window it adopted")
@@ -132,7 +133,7 @@ func TestBackendOnlyBareStartCarriesHeadless(t *testing.T) {
 
 	_, err := o.Start(context.Background(), config.Name, nil, nil)
 	require.NoError(t, err)
-	t.Cleanup(func() { _ = o.process.Stop(context.Background(), config.Name, true) })
+	stopOnCleanup(t, o.process, config.Name)
 
 	proc := o.process.Get(config.Name)
 	require.NotNil(t, proc)
@@ -163,7 +164,7 @@ func TestBackendOnlyStartTakesTheDaemonSlot(t *testing.T) {
 	pid, err := o.Start(context.Background(), config.Name, nil, nil)
 	require.NoError(t, err)
 	require.NotZero(t, pid)
-	t.Cleanup(func() { _ = o.process.Stop(context.Background(), config.Name, true) })
+	stopOnCleanup(t, o.process, config.Name)
 
 	time.Sleep(250 * time.Millisecond)
 	require.True(t, o.process.IsRunning(config.Name), "the daemon slot must hold the process")
@@ -209,7 +210,7 @@ func TestBackendOnlyBareStartNamesTheStarter(t *testing.T) {
 
 	_, err = o.Start(context.Background(), config.Name, nil, nil)
 	require.NoError(t, err)
-	t.Cleanup(func() { _ = o.process.Stop(context.Background(), config.Name, true) })
+	stopOnCleanup(t, o.process, config.Name)
 
 	proc := o.process.Get(config.Name)
 	require.NotNil(t, proc)
diff --git a/sidechain-orchestrator/bmm_bbc_integration_test.go b/sidechain-orchestrator/bmm_bbc_integration_test.go
index 360c7a76ae..dcb3e76135 100644
--- a/sidechain-orchestrator/bmm_bbc_integration_test.go
+++ b/sidechain-orchestrator/bmm_bbc_integration_test.go
@@ -16,7 +16,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	bmmpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1/bmmv1connect"
@@ -103,10 +104,10 @@ func TestBbcBMM(t *testing.T) {
 	startOrchestrator(t, orchBin, home, mainDir)
 	httpClient := &http.Client{Timeout: 60 * time.Second}
 	orchURL := fmt.Sprintf("http://127.0.0.1:%d", orchestratorPort)
-	wallets := walletmanagerv1connect.NewWalletManagerServiceClient(httpClient, orchURL)
-	bmm := bmmv1connect.NewBMMServiceClient(httpClient, orchURL)
+	wallets := walletmanagerv1connect.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(httpClient, orchURL, connecthttp.WithReadMaxBytes(0))))
+	bmm := bmmv1connect.NewBMMServiceClient(connect.NewClient(connecthttp.NewTransport(httpClient, orchURL, connecthttp.WithReadMaxBytes(0))))
 	waitFor(t, 60*time.Second, "drivechaind", func() bool {
-		_, err := wallets.GetWalletStatus(ctx, connect.NewRequest(&wmpb.GetWalletStatusRequest{}))
+		_, err := wallets.GetWalletStatus(ctx, &wmpb.GetWalletStatusRequest{})
 		return err == nil
 	})
 
@@ -114,15 +115,15 @@ func TestBbcBMM(t *testing.T) {
 	// the bare scriptPubKey an M8 request needs, so bidding runs on a second.
 	generateWallet(ctx, t, wallets, "enforcer")
 	coreWallet := generateWallet(ctx, t, wallets, "core")
-	_, err := wallets.SwitchWallet(ctx, connect.NewRequest(&wmpb.SwitchWalletRequest{WalletId: coreWallet}))
+	_, err := wallets.SwitchWallet(ctx, &wmpb.SwitchWalletRequest{WalletId: coreWallet})
 	require.NoError(t, err)
 
-	addr, err := wallets.GetNewAddress(ctx, connect.NewRequest(&wmpb.GetNewAddressRequest{}))
+	addr, err := wallets.GetNewAddress(ctx, &wmpb.GetNewAddressRequest{})
 	require.NoError(t, err)
-	mineMainchain(ctx, t, enforcer, 150, addr.Msg.Address)
+	mineMainchain(ctx, t, enforcer, 150, addr.Address)
 	waitFor(t, 60*time.Second, "bidding funds", func() bool {
-		bal, err := wallets.GetBalance(ctx, connect.NewRequest(&wmpb.GetBalanceRequest{}))
-		return err == nil && bal.Msg.ConfirmedSats > 0
+		bal, err := wallets.GetBalance(ctx, &wmpb.GetBalanceRequest{})
+		return err == nil && bal.ConfirmedSats > 0
 	})
 
 	var height int64
@@ -130,29 +131,29 @@ func TestBbcBMM(t *testing.T) {
 	require.Zero(t, height, "sidechain should start empty")
 
 	blindMergeMine := func(cycle int64) {
-		bid, err := bmm.CreateBid(ctx, connect.NewRequest(&bmmpb.CreateBidRequest{
+		bid, err := bmm.CreateBid(ctx, &bmmpb.CreateBidRequest{
 			Sidechain: orchpb.BinaryType_BINARY_TYPE_BBC,
 			BidSats:   1000,
-		}))
+		})
 		require.NoError(t, err, "cycle %d: create bid", cycle)
-		require.NotEmpty(t, bid.Msg.BmmTxid, "bid must be broadcast on the mainchain")
-		require.NotEmpty(t, bid.Msg.PrevMainHash)
+		require.NotEmpty(t, bid.BmmTxid, "bid must be broadcast on the mainchain")
+		require.NotEmpty(t, bid.PrevMainHash)
 
-		mineMainchain(ctx, t, enforcer, 1, addr.Msg.Address)
+		mineMainchain(ctx, t, enforcer, 1, addr.Address)
 
 		// The sidechain node has to see the commitment in the new mainchain
 		// block before it will accept the block, and it learns that by polling.
 		var connected *bmmpb.ConnectBidResponse
 		waitFor(t, 60*time.Second, "bid inclusion", func() bool {
-			resp, err := bmm.ConnectBid(ctx, connect.NewRequest(&bmmpb.ConnectBidRequest{
+			resp, err := bmm.ConnectBid(ctx, &bmmpb.ConnectBidRequest{
 				Sidechain:    orchpb.BinaryType_BINARY_TYPE_BBC,
-				CriticalHash: bid.Msg.CriticalHash,
-				BlockJson:    bid.Msg.BlockJson,
-			}))
-			if err != nil || !resp.Msg.Connected {
+				CriticalHash: bid.CriticalHash,
+				BlockJson:    bid.BlockJson,
+			})
+			if err != nil || !resp.Connected {
 				return false
 			}
-			connected = resp.Msg
+			connected = resp
 			return true
 		})
 		require.NotEmpty(t, connected.MainBlockHash)
@@ -173,19 +174,19 @@ func TestBbcBMM(t *testing.T) {
 	var sideAddress string
 	require.NoError(t, sidechain.call(ctx, "getnewaddress", nil, &sideAddress))
 
-	deposit, err := wallets.CreateDeposit(ctx, connect.NewRequest(&wmpb.CreateDepositRequest{
+	deposit, err := wallets.CreateDeposit(ctx, &wmpb.CreateDepositRequest{
 		Slot:        bbcSlot,
 		Destination: sideAddress,
 		AmountSats:  depositSats,
 		FeeSats:     10_000,
-	}))
+	})
 	require.NoError(t, err, "create deposit")
-	require.NotEmpty(t, deposit.Msg.Txid)
-	require.EqualValues(t, depositSats, deposit.Msg.TreasurySats, "first deposit starts the treasury")
+	require.NotEmpty(t, deposit.Txid)
+	require.EqualValues(t, depositSats, deposit.TreasurySats, "first deposit starts the treasury")
 
 	// The deposit must confirm at or below the mainchain tip the next template
 	// builds on, or it falls outside the range that coinbase covers.
-	mineMainchain(ctx, t, enforcer, 1, addr.Msg.Address)
+	mineMainchain(ctx, t, enforcer, 1, addr.Address)
 	blindMergeMine(4)
 
 	var addressInfo struct {
@@ -340,9 +341,9 @@ func generateWallet(
 	wallets walletmanagerv1connect.WalletManagerServiceClient, name string,
 ) string {
 	t.Helper()
-	resp, err := wallets.GenerateWallet(ctx, connect.NewRequest(&wmpb.GenerateWalletRequest{Name: name}))
+	resp, err := wallets.GenerateWallet(ctx, &wmpb.GenerateWalletRequest{Name: name})
 	require.NoError(t, err)
-	return resp.Msg.WalletId
+	return resp.WalletId
 }
 
 func buildDrivechaind(t *testing.T) string {
diff --git a/sidechain-orchestrator/buf.go.gen.yaml b/sidechain-orchestrator/buf.go.gen.yaml
index 68a33f68d7..34d4062cd8 100644
--- a/sidechain-orchestrator/buf.go.gen.yaml
+++ b/sidechain-orchestrator/buf.go.gen.yaml
@@ -16,7 +16,7 @@ plugins:
     opt:
       - paths=source_relative
 
-  - remote: buf.build/connectrpc/go:v1.20.0
+  - remote: buf.build/connectrpc/go:v2.0.1
     out: gen
     opt:
       - paths=source_relative
diff --git a/sidechain-orchestrator/cmd/drivechaind/main.go b/sidechain-orchestrator/cmd/drivechaind/main.go
index 50c5b24245..ef28e83576 100644
--- a/sidechain-orchestrator/cmd/drivechaind/main.go
+++ b/sidechain-orchestrator/cmd/drivechaind/main.go
@@ -15,7 +15,9 @@ import (
 	"syscall"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/rs/zerolog"
 	"github.com/urfave/cli/v2"
@@ -310,6 +312,7 @@ func run(cctx *cli.Context) error {
 	// Set up gRPC/ConnectRPC server
 	handler := api.NewHandler(orch)
 	mux := http.NewServeMux()
+	rpcServer := connect.NewServer(localauth.ServerInterceptor(authDir))
 	if localAuth {
 		// Allows a relaunched bitwindowd to verify that an occupied RPC port is
 		// the previous drivechaind without sending the bearer cookie to an
@@ -337,8 +340,7 @@ func run(cctx *cli.Context) error {
 		})
 	}
 
-	path, h := rpc.NewOrchestratorServiceHandler(handler, connect.WithInterceptors(authIC))
-	mux.Handle(path, h)
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, handler)
 
 	// Wallet manager service
 	walletHandler := api.NewWalletHandler(walletSvc)
@@ -559,8 +561,7 @@ func run(cctx *cli.Context) error {
 		}
 	}()
 
-	bmmPath, bmmH := bmmrpc.NewBMMServiceHandler(bmmHandler, connect.WithInterceptors(authIC))
-	mux.Handle(bmmPath, bmmH)
+	bmmrpc.RegisterBMMServiceHandler(rpcServer, bmmHandler)
 
 	stratumHandler := api.NewStratumHandler(ctx, api.StratumDeps{
 		Network:  orch,
@@ -574,25 +575,20 @@ func run(cctx *cli.Context) error {
 		Log:         log.With().Str("component", "stratum").Logger(),
 	})
 	walletEngine.OnNetworkReset(stratumHandler.Reset)
-	stratumPath, stratumH := stratumrpc.NewStratumServiceHandler(stratumHandler, connect.WithInterceptors(authIC))
-	mux.Handle(stratumPath, stratumH)
+	stratumrpc.RegisterStratumServiceHandler(rpcServer, stratumHandler)
 
 	explorerHandler := api.NewExplorerHandler(orch)
 	explorerHandler.SetCoreCaller(handler.RawCoreCall)
-	explorerPath, explorerH := explorerrpc.NewExplorerServiceHandler(explorerHandler, connect.WithInterceptors(authIC))
-	mux.Handle(explorerPath, explorerH)
+	explorerrpc.RegisterExplorerServiceHandler(rpcServer, explorerHandler)
 
-	walletPath, walletH := walletrpc.NewWalletManagerServiceHandler(walletHandler, connect.WithInterceptors(authIC))
-	mux.Handle(walletPath, walletH)
+	walletrpc.RegisterWalletManagerServiceHandler(rpcServer, walletHandler)
 
-	multisigLoungePath, multisigLoungeH := multisigloungerpc.NewMultisigLoungeServiceHandler(multisigLoungeHandler, connect.WithInterceptors(authIC))
-	mux.Handle(multisigLoungePath, multisigLoungeH)
+	multisigloungerpc.RegisterMultisigLoungeServiceHandler(rpcServer, multisigLoungeHandler)
 
 	// Bitcoin config service
 	if orch.BitcoinConf != nil {
 		confHandler := api.NewBitcoinConfHandler(orch)
-		confPath, confH := rpc.NewBitcoinConfServiceHandler(confHandler, connect.WithInterceptors(authIC))
-		mux.Handle(confPath, confH)
+		rpc.RegisterBitcoinConfServiceHandler(rpcServer, confHandler)
 	}
 
 	// Bitcoin Core proxy (btc-buf BitcoinService) — single canonical route
@@ -621,13 +617,13 @@ func run(cctx *cli.Context) error {
 				log.Warn().Err(err).Str("reason", reason).Msg("failed to start bitcoin core proxy")
 				return
 			}
-			_, h := corerpc.NewBitcoinServiceHandler(proxy, connect.WithInterceptors(authIC, meterIC))
+			_, h := corerpc.NewBitcoinServiceHandler(proxy, connectv1.WithInterceptors(authIC, meterIC))
 			swappable.swap(h)
 			log.Info().Str("reason", reason).Msg("bitcoin core proxy ready")
 		}
 		rebuildCoreProxy("startup")
 		// The path is constant; register once.
-		corePath, _ := corerpc.NewBitcoinServiceHandler(noopBitcoinService{}, connect.WithInterceptors(authIC, meterIC))
+		corePath, _ := corerpc.NewBitcoinServiceHandler(noopBitcoinService{}, connectv1.WithInterceptors(authIC, meterIC))
 		mux.Handle(corePath, swappable)
 		log.Info().Str("service", "bitcoin.bitcoind.v1alpha.BitcoinService").Msg("registered bitcoin core proxy")
 
@@ -640,14 +636,12 @@ func run(cctx *cli.Context) error {
 	// Enforcer config service
 	if orch.EnforcerConf != nil {
 		enforcerHandler := api.NewEnforcerConfHandler(orch.EnforcerConf)
-		enforcerPath, enforcerH := rpc.NewEnforcerConfServiceHandler(enforcerHandler, connect.WithInterceptors(authIC))
-		mux.Handle(enforcerPath, enforcerH)
+		rpc.RegisterEnforcerConfServiceHandler(rpcServer, enforcerHandler)
 	}
 
 	// Generic sidechain config service (all sidechains)
 	sidechainConfHandler := api.NewSidechainConfHandler(orch.SidechainConfs)
-	scConfPath, scConfH := rpc.NewSidechainConfServiceHandler(sidechainConfHandler, connect.WithInterceptors(authIC))
-	mux.Handle(scConfPath, scConfH)
+	rpc.RegisterSidechainConfServiceHandler(rpcServer, sidechainConfHandler)
 
 	// Per-sidechain typed RPC services (proxy to sidechain binary JSON-RPC)
 	for name, cfg := range orch.Configs() {
@@ -655,44 +649,37 @@ func run(cctx *cli.Context) error {
 		switch name {
 		case "thunder":
 			h := thundersvc.NewHandlerWithIndex(proxy, cctx.String("thunder-esplora-url"))
-			path, thunderHandler := thunderrpc.NewThunderServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, thunderHandler)
+			thunderrpc.RegisterThunderServiceHandler(rpcServer, h)
 			handler.SetSidechainBalance(name, h.WalletBalance)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		case "bitnames":
 			h := bitnamessvc.NewHandler(proxy)
 			handler.SetSidechainBalance(name, h.WalletBalance)
-			path, bitnamesHandler := bitnamesrpc.NewBitnamesServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, bitnamesHandler)
+			bitnamesrpc.RegisterBitnamesServiceHandler(rpcServer, h)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		case "bitassets":
 			h := bitassetssvc.NewHandler(proxy)
 			handler.SetSidechainBalance(name, h.WalletBalance)
-			path, bitassetsHandler := bitassetsrpc.NewBitAssetsServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, bitassetsHandler)
+			bitassetsrpc.RegisterBitAssetsServiceHandler(rpcServer, h)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		case "photon":
 			h := photonsvc.NewHandler(proxy)
 			handler.SetSidechainBalance(name, h.WalletBalance)
-			path, photonHandler := photonrpc.NewPhotonServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, photonHandler)
+			photonrpc.RegisterPhotonServiceHandler(rpcServer, h)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		case "truthcoin":
 			h := truthcoinsvc.NewHandler(proxy)
 			handler.SetSidechainBalance(name, h.WalletBalance)
-			path, truthcoinHandler := truthcoinrpc.NewTruthcoinServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, truthcoinHandler)
+			truthcoinrpc.RegisterTruthcoinServiceHandler(rpcServer, h)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		case "coinshift":
 			h := coinshiftsvc.NewHandler(proxy)
 			handler.SetSidechainBalance(name, h.WalletBalance)
-			path, coinshiftHandler := coinshiftrpc.NewCoinShiftServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, coinshiftHandler)
+			coinshiftrpc.RegisterCoinShiftServiceHandler(rpcServer, h)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		case "zside":
 			h := zsidesvc.NewHandler(proxy)
-			path, handler := zsiderpc.NewZSideServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, handler)
+			zsiderpc.RegisterZSideServiceHandler(rpcServer, h)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		case "bbc":
 			// Core derived: its own client, authenticated by the node's cookie.
@@ -703,12 +690,13 @@ func run(cctx *cli.Context) error {
 			}
 			cookie := filepath.Join(dirs.DatadirNetwork(config.Network(orch.Network), ""), ".cookie")
 			h := bbcsvc.NewHandler(bbcsvc.NewClient(cfg.RPCHost(), cfg.Port, cookie))
-			path, handler := bbcrpc.NewBbcServiceHandler(h, connect.WithInterceptors(authIC))
-			mux.Handle(path, handler)
+			bbcrpc.RegisterBbcServiceHandler(rpcServer, h)
 			log.Info().Str("sidechain", name).Int("port", cfg.Port).Msg("registered sidechain RPC service")
 		}
 	}
 
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
+
 	// h2c (HTTP/2 cleartext) via http.Server.Protocols — the ConnectRPC-blessed
 	// replacement for h2c.NewHandler. Carries Connect, gRPC and gRPC-Web on one
 	// listener. SendPingTimeout preserves the old http2.Server.ReadIdleTimeout
diff --git a/sidechain-orchestrator/commands/bmm.go b/sidechain-orchestrator/commands/bmm.go
index 9d9e68431d..1006bcc8c9 100644
--- a/sidechain-orchestrator/commands/bmm.go
+++ b/sidechain-orchestrator/commands/bmm.go
@@ -6,7 +6,8 @@ import (
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/urfave/cli/v2"
 
 	bmmpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1"
@@ -20,12 +21,13 @@ import (
 )
 
 func newBMMClient(cctx *cli.Context) bmmv1connect.BMMServiceClient {
-	return bmmv1connect.NewBMMServiceClient(
+	return bmmv1connect.NewBMMServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		fmt.Sprintf("http://%s", cctx.String("rpcserver")),
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir(cctx))),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), localauth.ClientInterceptor(cookieDir(cctx)),
+	))
 }
 
 // sidechainType resolves a name the way a person would type it: "bbc"
@@ -75,15 +77,15 @@ var bmmMineCommand = &cli.Command{
 		client := newBMMClient(cctx)
 
 		for i := 1; i <= cctx.Int("blocks"); i++ {
-			bid, err := client.CreateBid(cctx.Context, connect.NewRequest(&bmmpb.CreateBidRequest{
+			bid, err := client.CreateBid(cctx.Context, &bmmpb.CreateBidRequest{
 				Sidechain: sidechain,
 				WalletId:  cctx.String("wallet"),
 				BidSats:   cctx.Int64("bid"),
-			}))
+			})
 			if err != nil {
 				return fmt.Errorf("create bid %d: %w", i, err)
 			}
-			fmt.Printf("bid %d broadcast: %s\n", i, bid.Msg.BmmTxid)
+			fmt.Printf("bid %d broadcast: %s\n", i, bid.BmmTxid)
 
 			// A bid is worth nothing until a mainchain miner takes it. On a real
 			// network that is somebody else's decision and all we can do is
@@ -95,13 +97,13 @@ var bmmMineCommand = &cli.Command{
 			}
 			deadline := time.Now().Add(cctx.Duration("timeout"))
 			for {
-				connected, err := client.ConnectBid(cctx.Context, connect.NewRequest(&bmmpb.ConnectBidRequest{
+				connected, err := client.ConnectBid(cctx.Context, &bmmpb.ConnectBidRequest{
 					Sidechain:    sidechain,
-					CriticalHash: bid.Msg.CriticalHash,
-					BlockJson:    bid.Msg.BlockJson,
-				}))
-				if err == nil && connected.Msg.Connected {
-					fmt.Printf("  connected in mainchain block %s\n", connected.Msg.MainBlockHash)
+					CriticalHash: bid.CriticalHash,
+					BlockJson:    bid.BlockJson,
+				})
+				if err == nil && connected.Connected {
+					fmt.Printf("  connected in mainchain block %s\n", connected.MainBlockHash)
 					break
 				}
 				if time.Now().After(deadline) {
@@ -121,21 +123,22 @@ func generateMainchainBlock(cctx *cli.Context) error {
 	// An empty wallet id resolves to the active wallet. resolveWalletID would
 	// read this command's positional argument, which names a sidechain.
 	wallet := newWalletClient(cctx)
-	address, err := wallet.GetNewAddress(cctx.Context, connect.NewRequest(&walletpb.GetNewAddressRequest{}))
+	address, err := wallet.GetNewAddress(cctx.Context, &walletpb.GetNewAddressRequest{})
 	if err != nil {
 		return fmt.Errorf("get an address to mine to: %w", err)
 	}
 
-	mining := mainchainv1connect.NewMiningServiceClient(
+	mining := mainchainv1connect.NewMiningServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		fmt.Sprintf("http://%s", cctx.String("rpcserver")),
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir(cctx))),
-	)
-	_, err = mining.GenerateToAddress(cctx.Context, connect.NewRequest(&mainchainpb.GenerateToAddressRequest{
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), localauth.ClientInterceptor(cookieDir(cctx)),
+	))
+	_, err = mining.GenerateToAddress(cctx.Context, &mainchainpb.GenerateToAddressRequest{
 		Blocks:  wrapperspb.UInt32(1),
-		Address: address.Msg.Address,
-	}))
+		Address: address.Address,
+	})
 	return err
 }
 
@@ -160,12 +163,12 @@ var bmmStartCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		if _, err := newBMMClient(cctx).Start(cctx.Context, connect.NewRequest(&bmmpb.StartRequest{
+		if _, err := newBMMClient(cctx).Start(cctx.Context, &bmmpb.StartRequest{
 			Sidechain:       sidechain,
 			WalletId:        cctx.String("wallet"),
 			MaxBidSats:      cctx.Int64("max-bid"),
 			CapToBlockWorth: cctx.Bool("cap-to-block-worth"),
-		})); err != nil {
+		}); err != nil {
 			return err
 		}
 		fmt.Printf("bidding on %s\n", cctx.Args().First())
@@ -185,9 +188,9 @@ var bmmStopCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		if _, err := newBMMClient(cctx).Stop(cctx.Context, connect.NewRequest(&bmmpb.StopRequest{
+		if _, err := newBMMClient(cctx).Stop(cctx.Context, &bmmpb.StopRequest{
 			Sidechain: sidechain,
-		})); err != nil {
+		}); err != nil {
 			return err
 		}
 		fmt.Printf("stopped bidding on %s\n", cctx.Args().First())
diff --git a/sidechain-orchestrator/commands/commands.go b/sidechain-orchestrator/commands/commands.go
index f5518539f8..9331de7f92 100644
--- a/sidechain-orchestrator/commands/commands.go
+++ b/sidechain-orchestrator/commands/commands.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
 	"os/exec"
@@ -18,7 +19,8 @@ import (
 	"time"
 	"unicode"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	orchestrator "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config/netcatalog"
@@ -111,12 +113,13 @@ func cookieDir(cctx *cli.Context) string {
 func newClient(cctx *cli.Context) rpc.OrchestratorServiceClient {
 	addr := cctx.String("rpcserver")
 	url := fmt.Sprintf("http://%s", addr)
-	return rpc.NewOrchestratorServiceClient(
+	return rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		url,
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir(cctx))),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), localauth.ClientInterceptor(cookieDir(cctx)),
+	))
 }
 
 var downloadCommand = &cli.Command{
@@ -140,14 +143,14 @@ var downloadCommand = &cli.Command{
 	Action: func(cctx *cli.Context) error {
 		if cctx.NArg() < 1 {
 			client := newClient(cctx)
-			resp, err := client.ListBinaries(cctx.Context, connect.NewRequest(&pb.ListBinariesRequest{}))
+			resp, err := client.ListBinaries(cctx.Context, &pb.ListBinariesRequest{})
 			if err != nil {
 				return fmt.Errorf("usage: drivechain-cli download <binary>\n  (could not fetch binary list: %w)", err)
 			}
 			fmt.Println("usage: drivechain-cli download <binary>")
 			fmt.Println()
 			fmt.Println("available binaries:")
-			for _, b := range resp.Msg.Binaries {
+			for _, b := range resp.Binaries {
 				if !b.Downloadable {
 					continue
 				}
@@ -209,13 +212,13 @@ func runStart(cctx *cli.Context, client rpc.OrchestratorServiceClient) error {
 
 	autoDownload := cctx.Bool("auto-download") || os.Getenv("ORCHESTRATOR_AUTO_DOWNLOAD") != ""
 	for _, bin := range needed {
-		resp, err := client.GetBinaryStatus(cctx.Context, connect.NewRequest(&pb.GetBinaryStatusRequest{
+		resp, err := client.GetBinaryStatus(cctx.Context, &pb.GetBinaryStatusRequest{
 			Name: bin,
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		s := resp.Msg.Status
+		s := resp.Status
 		if s.Downloaded || !s.Downloadable {
 			continue
 		}
@@ -255,22 +258,22 @@ func runStart(cctx *cli.Context, client rpc.OrchestratorServiceClient) error {
 		// Fire-and-forget on the server side — boot proceeds in a
 		// background goroutine. Poll GetSyncStatus / ListBinaries via
 		// `drivechain-cli status` for progress.
-		if _, err := client.StartWithL1(cctx.Context, connect.NewRequest(&pb.StartWithL1Request{
+		if _, err := client.StartWithL1(cctx.Context, &pb.StartWithL1Request{
 			Target:     name,
 			TargetArgs: cctx.StringSlice("args"),
-		})); err != nil {
+		}); err != nil {
 			return err
 		}
 		fmt.Println("L1 boot kicked off; poll status for progress")
 	} else {
-		resp, err := client.StartBinary(cctx.Context, connect.NewRequest(&pb.StartBinaryRequest{
+		resp, err := client.StartBinary(cctx.Context, &pb.StartBinaryRequest{
 			Name:      name,
 			ExtraArgs: cctx.StringSlice("args"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("started %s (PID %d)\n", name, resp.Msg.Pid)
+		fmt.Printf("started %s (PID %d)\n", name, resp.Pid)
 	}
 
 	if daemon {
@@ -290,20 +293,29 @@ func runStart(cctx *cli.Context, client rpc.OrchestratorServiceClient) error {
 		cancel()
 	}()
 
-	logStream, err := client.StreamLogs(ctx, connect.NewRequest(&pb.StreamLogsRequest{
+	logStream, err := client.StreamLogs(ctx, &pb.StreamLogsRequest{
 		Name: name,
 		Tail: 10,
-	}))
+	})
 	if err != nil {
 		return err
 	}
-	for logStream.Receive() {
-		msg := logStream.Msg()
+	var streamErr2 error
+	for {
+		msg2, err := logStream.Receive()
+		if err != nil {
+			streamErr2 = err
+			break
+		}
+		msg := msg2
 		ts := time.Unix(msg.TimestampUnix, 0).Format("15:04:05")
 		fmt.Printf("[%s] %s\n", ts, msg.Line)
 	}
+	if errors.Is(streamErr2, io.EOF) {
+		streamErr2 = nil
+	}
 	var streamErr error
-	if err := logStream.Err(); err != nil && ctx.Err() == nil {
+	if err := streamErr2; err != nil && ctx.Err() == nil {
 		streamErr = fmt.Errorf("stream %s logs: %w", name, err)
 	}
 
@@ -345,7 +357,7 @@ func stopOneBinary(client rpc.OrchestratorServiceClient, name string) error {
 	ctx, cancel := context.WithTimeout(context.Background(), stopBinaryTimeout)
 	defer cancel()
 
-	_, err := client.StopBinary(ctx, connect.NewRequest(&pb.StopBinaryRequest{Name: name}))
+	_, err := client.StopBinary(ctx, &pb.StopBinaryRequest{Name: name})
 	return err
 }
 
@@ -362,17 +374,17 @@ type binarySnapshot struct {
 }
 
 func takeBinarySnapshot(ctx context.Context, client rpc.OrchestratorServiceClient) (binarySnapshot, error) {
-	resp, err := client.ListBinaries(ctx, connect.NewRequest(&pb.ListBinariesRequest{}))
+	resp, err := client.ListBinaries(ctx, &pb.ListBinariesRequest{})
 	if err != nil {
 		return binarySnapshot{}, fmt.Errorf("list binaries: %w", err)
 	}
 
 	snapshot := binarySnapshot{
-		daemons:    make(map[string]bool, len(resp.Msg.Binaries)),
-		busy:       make(map[string]bool, len(resp.Msg.Binaries)),
-		sidechains: make(map[string]bool, len(resp.Msg.Binaries)),
+		daemons:    make(map[string]bool, len(resp.Binaries)),
+		busy:       make(map[string]bool, len(resp.Binaries)),
+		sidechains: make(map[string]bool, len(resp.Binaries)),
 	}
-	for _, s := range resp.Msg.Binaries {
+	for _, s := range resp.Binaries {
 		if s.Running {
 			snapshot.daemons[s.Name] = true
 		}
@@ -459,10 +471,10 @@ var stopCommand = &cli.Command{
 		}
 
 		client := newClient(cctx)
-		_, err := client.StopBinary(cctx.Context, connect.NewRequest(&pb.StopBinaryRequest{
+		_, err := client.StopBinary(cctx.Context, &pb.StopBinaryRequest{
 			Name:  cctx.Args().First(),
 			Force: cctx.Bool("force"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -480,22 +492,22 @@ var statusCommand = &cli.Command{
 		client := newClient(cctx)
 
 		if cctx.NArg() > 0 {
-			resp, err := client.GetBinaryStatus(cctx.Context, connect.NewRequest(&pb.GetBinaryStatusRequest{
+			resp, err := client.GetBinaryStatus(cctx.Context, &pb.GetBinaryStatusRequest{
 				Name: cctx.Args().First(),
-			}))
+			})
 			if err != nil {
 				return err
 			}
-			printStatus(resp.Msg.Status)
+			printStatus(resp.Status)
 			return nil
 		}
 
-		resp, err := client.ListBinaries(cctx.Context, connect.NewRequest(&pb.ListBinariesRequest{}))
+		resp, err := client.ListBinaries(cctx.Context, &pb.ListBinariesRequest{})
 		if err != nil {
 			return err
 		}
 
-		for _, s := range resp.Msg.Binaries {
+		for _, s := range resp.Binaries {
 			printStatus(s)
 		}
 		return nil
@@ -528,7 +540,7 @@ func runWipe(cctx *cli.Context, client rpc.OrchestratorServiceClient) error {
 		return err
 	}
 
-	if _, err := client.StopBinary(cctx.Context, connect.NewRequest(&pb.StopBinaryRequest{Name: name, Force: true})); err != nil {
+	if _, err := client.StopBinary(cctx.Context, &pb.StopBinaryRequest{Name: name, Force: true}); err != nil {
 		return fmt.Errorf("stop %s: %w", name, err)
 	}
 
@@ -540,25 +552,30 @@ func runWipe(cctx *cli.Context, client rpc.OrchestratorServiceClient) error {
 	if cctx.Bool("include-wallets") {
 		deletions = append(deletions, pb.DeletionType_DELETION_TYPE_WALLET)
 	}
-	stream, err := client.DeleteFiles(cctx.Context, connect.NewRequest(&pb.DeleteFilesRequest{
+	stream, err := client.DeleteFiles(cctx.Context, &pb.DeleteFilesRequest{
 		Items: []*pb.SingleDeletion{{Binary: binary, Deletions: deletions}},
-	}))
+	})
 	if err != nil {
 		return err
 	}
 
 	var failed []string
-	for stream.Receive() {
-		msg := stream.Msg()
+	for {
+		msg2, err := stream.Receive()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
+			return err
+		}
+		msg := msg2
 		if msg.Error != "" {
 			failed = append(failed, fmt.Sprintf("%s: %s", msg.Path, msg.Error))
 			continue
 		}
 		fmt.Printf("removed %s\n", msg.Path)
 	}
-	if err := stream.Err(); err != nil {
-		return err
-	}
+
 	if len(failed) > 0 {
 		return fmt.Errorf("wipe %s: %s", name, strings.Join(failed, "; "))
 	}
@@ -573,11 +590,11 @@ var infoCommand = &cli.Command{
 	Action: func(cctx *cli.Context) error {
 		client := newClient(cctx)
 
-		mainchain, err := client.GetMainchainBlockchainInfo(cctx.Context, connect.NewRequest(&pb.GetMainchainBlockchainInfoRequest{}))
+		mainchain, err := client.GetMainchainBlockchainInfo(cctx.Context, &pb.GetMainchainBlockchainInfoRequest{})
 		if err != nil {
 			fmt.Printf("mainchain: unavailable (%v)\n", err)
 		} else {
-			m := mainchain.Msg
+			m := mainchain
 			fmt.Println("mainchain:")
 			fmt.Printf("  chain:    %s\n", m.Chain)
 			fmt.Printf("  blocks:   %d\n", m.Blocks)
@@ -587,11 +604,11 @@ var infoCommand = &cli.Command{
 			fmt.Printf("  size:     %s\n", formatBytes(m.SizeOnDisk))
 		}
 
-		enforcer, err := client.GetEnforcerBlockchainInfo(cctx.Context, connect.NewRequest(&pb.GetEnforcerBlockchainInfoRequest{}))
+		enforcer, err := client.GetEnforcerBlockchainInfo(cctx.Context, &pb.GetEnforcerBlockchainInfoRequest{})
 		if err != nil {
 			fmt.Printf("\nenforcer: unavailable (%v)\n", err)
 		} else {
-			e := enforcer.Msg
+			e := enforcer
 			fmt.Println("\nenforcer:")
 			fmt.Printf("  blocks:   %d\n", e.Blocks)
 			fmt.Printf("  headers:  %d\n", e.Headers)
@@ -606,12 +623,12 @@ var balanceCommand = &cli.Command{
 	Usage: "Show mainchain wallet balance",
 	Action: func(cctx *cli.Context) error {
 		client := newClient(cctx)
-		resp, err := client.GetMainchainBalance(cctx.Context, connect.NewRequest(&pb.GetMainchainBalanceRequest{}))
+		resp, err := client.GetMainchainBalance(cctx.Context, &pb.GetMainchainBalanceRequest{})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("confirmed:   %.8f BTC\n", resp.Msg.Confirmed)
-		fmt.Printf("unconfirmed: %.8f BTC\n", resp.Msg.Unconfirmed)
+		fmt.Printf("confirmed:   %.8f BTC\n", resp.Confirmed)
+		fmt.Printf("unconfirmed: %.8f BTC\n", resp.Unconfirmed)
 		return nil
 	},
 }
@@ -621,12 +638,12 @@ var priceCommand = &cli.Command{
 	Usage: "Show current BTC/USD price",
 	Action: func(cctx *cli.Context) error {
 		client := newClient(cctx)
-		resp, err := client.GetBTCPrice(cctx.Context, connect.NewRequest(&pb.GetBTCPriceRequest{}))
+		resp, err := client.GetBTCPrice(cctx.Context, &pb.GetBTCPriceRequest{})
 		if err != nil {
 			return err
 		}
-		t := time.Unix(resp.Msg.LastUpdatedUnix, 0)
-		fmt.Printf("$%.2f (updated %s)\n", resp.Msg.Btcusd, t.Format("15:04:05"))
+		t := time.Unix(resp.LastUpdatedUnix, 0)
+		fmt.Printf("$%.2f (updated %s)\n", resp.Btcusd, t.Format("15:04:05"))
 		return nil
 	},
 }
@@ -636,7 +653,7 @@ var doctorCommand = &cli.Command{
 	Usage: "Check system health and suggest next steps",
 	Action: func(cctx *cli.Context) error {
 		client := newClient(cctx)
-		resp, err := client.ListBinaries(cctx.Context, connect.NewRequest(&pb.ListBinariesRequest{}))
+		resp, err := client.ListBinaries(cctx.Context, &pb.ListBinariesRequest{})
 		if err != nil {
 			return fmt.Errorf("cannot reach orchestrator daemon: %w", err)
 		}
@@ -645,7 +662,7 @@ var doctorCommand = &cli.Command{
 		var notRunning []string
 		allGood := true
 
-		for _, b := range resp.Msg.Binaries {
+		for _, b := range resp.Binaries {
 			if !b.Downloadable {
 				continue
 			}
@@ -702,12 +719,12 @@ var versionCommand = &cli.Command{
 	Usage: "Show version info for all binaries",
 	Action: func(cctx *cli.Context) error {
 		client := newClient(cctx)
-		resp, err := client.ListBinaries(cctx.Context, connect.NewRequest(&pb.ListBinariesRequest{}))
+		resp, err := client.ListBinaries(cctx.Context, &pb.ListBinariesRequest{})
 		if err != nil {
 			return fmt.Errorf("cannot reach orchestrator daemon: %w", err)
 		}
 
-		for _, b := range resp.Msg.Binaries {
+		for _, b := range resp.Binaries {
 			if !b.Downloadable {
 				continue
 			}
@@ -790,13 +807,13 @@ var updateCommand = &cli.Command{
 		client := newClient(cctx)
 
 		// Stop if running.
-		status, err := client.GetBinaryStatus(cctx.Context, connect.NewRequest(&pb.GetBinaryStatusRequest{Name: name}))
+		status, err := client.GetBinaryStatus(cctx.Context, &pb.GetBinaryStatusRequest{Name: name})
 		if err != nil {
 			return err
 		}
-		if status.Msg.Status.Running {
+		if status.Status.Running {
 			fmt.Printf("stopping %s...\n", name)
-			if _, err := client.StopBinary(cctx.Context, connect.NewRequest(&pb.StopBinaryRequest{Name: name})); err != nil {
+			if _, err := client.StopBinary(cctx.Context, &pb.StopBinaryRequest{Name: name}); err != nil {
 				return fmt.Errorf("stop %s: %w", name, err)
 			}
 		}
@@ -869,10 +886,10 @@ func servedECashNetwork(cctx *cli.Context, bitwindowDir string) string {
 	defer cancel()
 
 	resp, err := newClient(cctx).GetPendingNetworkGeneration(
-		ctx, connect.NewRequest(&pb.GetPendingNetworkGenerationRequest{}),
+		ctx, &pb.GetPendingNetworkGenerationRequest{},
 	)
 	if err == nil {
-		return resp.Msg.CurrentNetworkId
+		return resp.CurrentNetworkId
 	}
 	// No daemon answers. The next start serves the network this install records,
 	// and only then the one compiled into the binary.
@@ -922,11 +939,11 @@ func formatBytes(b int64) string {
 func runDownload(ctx context.Context, client rpc.OrchestratorServiceClient, name string, force, wait, forceBackend bool) error {
 	// DownloadBinary is fire-and-forget on the server — it returns before the
 	// file lands on disk.
-	if _, err := client.DownloadBinary(ctx, connect.NewRequest(&pb.DownloadBinaryRequest{
+	if _, err := client.DownloadBinary(ctx, &pb.DownloadBinaryRequest{
 		Name:         name,
 		Force:        force,
 		ForceBackend: forceBackend,
-	})); err != nil {
+	}); err != nil {
 		return err
 	}
 
@@ -940,11 +957,11 @@ func runDownload(ctx context.Context, client rpc.OrchestratorServiceClient, name
 	defer cancel()
 	fmt.Printf("downloading %s (waiting for completion)...\n", name)
 	for {
-		resp, err := client.GetBinaryStatus(ctx, connect.NewRequest(&pb.GetBinaryStatusRequest{Name: name, ForceBackend: forceBackend}))
+		resp, err := client.GetBinaryStatus(ctx, &pb.GetBinaryStatusRequest{Name: name, ForceBackend: forceBackend})
 		if err != nil {
 			return fmt.Errorf("poll %s status: %w", name, err)
 		}
-		s := resp.Msg.Status
+		s := resp.Status
 		if s.Downloaded {
 			fmt.Printf("%s downloaded\n", name)
 			return nil
@@ -973,12 +990,12 @@ func confirmYes() bool {
 // printUsageWithBinaries prints a usage line and lists available binaries.
 func printUsageWithBinaries(cctx *cli.Context, command string) error {
 	client := newClient(cctx)
-	resp, err := client.ListBinaries(cctx.Context, connect.NewRequest(&pb.ListBinariesRequest{}))
+	resp, err := client.ListBinaries(cctx.Context, &pb.ListBinariesRequest{})
 	if err != nil {
 		return fmt.Errorf("usage: drivechain-cli %s <binary>", command)
 	}
 	fmt.Printf("usage: drivechain-cli %s <binary>\n\navailable binaries:\n", command)
-	for _, b := range resp.Msg.Binaries {
+	for _, b := range resp.Binaries {
 		fmt.Printf("  %s\n", b.Name)
 	}
 	return nil
@@ -1016,21 +1033,30 @@ var logsCommand = &cli.Command{
 		}
 
 		client := newClient(cctx)
-		stream, err := client.StreamLogs(cctx.Context, connect.NewRequest(&pb.StreamLogsRequest{
+		stream, err := client.StreamLogs(cctx.Context, &pb.StreamLogsRequest{
 			Name: cctx.Args().First(),
 			Tail: int32(cctx.Int("tail")),
-		}))
+		})
 		if err != nil {
 			return err
 		}
 
-		for stream.Receive() {
-			msg := stream.Msg()
+		var streamErr error
+		for {
+			msg2, err := stream.Receive()
+			if err != nil {
+				streamErr = err
+				break
+			}
+			msg := msg2
 			ts := time.Unix(msg.TimestampUnix, 0).Format("15:04:05")
 			fmt.Printf("[%s] [%s] %s\n", ts, msg.Stream, msg.Line)
 		}
+		if errors.Is(streamErr, io.EOF) {
+			streamErr = nil
+		}
 
-		return stream.Err()
+		return streamErr
 	},
 }
 
@@ -1045,15 +1071,21 @@ var shutdownCommand = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		client := newClient(cctx)
-		stream, err := client.ShutdownAll(cctx.Context, connect.NewRequest(&pb.ShutdownAllRequest{
+		stream, err := client.ShutdownAll(cctx.Context, &pb.ShutdownAllRequest{
 			Force: cctx.Bool("force"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
 
-		for stream.Receive() {
-			msg := stream.Msg()
+		var streamErr error
+		for {
+			msg2, err := stream.Receive()
+			if err != nil {
+				streamErr = err
+				break
+			}
+			msg := msg2
 			if msg.Error != "" {
 				fmt.Printf("error: %s\n", msg.Error)
 			}
@@ -1064,8 +1096,11 @@ var shutdownCommand = &cli.Command{
 				fmt.Println("shutdown complete")
 			}
 		}
+		if errors.Is(streamErr, io.EOF) {
+			streamErr = nil
+		}
 
-		return stream.Err()
+		return streamErr
 	},
 }
 
@@ -1257,26 +1292,26 @@ func runSidechainBalance(cctx *cli.Context, sidechainName string) error {
 	if err != nil {
 		return err
 	}
-	resp, err := client.GetSidechainBalance(cctx.Context, connect.NewRequest(&pb.GetSidechainBalanceRequest{
+	resp, err := client.GetSidechainBalance(cctx.Context, &pb.GetSidechainBalanceRequest{
 		Sidechain: binaryType,
-	}))
+	})
 	if err != nil {
 		return err
 	}
-	fmt.Printf("confirmed: %s BTC (%d sats)\n", satsToBtcUint(resp.Msg.ConfirmedSats), resp.Msg.ConfirmedSats)
-	fmt.Printf("pending:   %s BTC (%d sats)\n", satsToBtcUint(resp.Msg.PendingSats), resp.Msg.PendingSats)
+	fmt.Printf("confirmed: %s BTC (%d sats)\n", satsToBtcUint(resp.ConfirmedSats), resp.ConfirmedSats)
+	fmt.Printf("pending:   %s BTC (%d sats)\n", satsToBtcUint(resp.PendingSats), resp.PendingSats)
 	return nil
 }
 
 func ensureSidechainDownloaded(cctx *cli.Context, client rpc.OrchestratorServiceClient, sidechainName, commandName string) error {
-	resp, err := client.GetBinaryStatus(cctx.Context, connect.NewRequest(&pb.GetBinaryStatusRequest{
+	resp, err := client.GetBinaryStatus(cctx.Context, &pb.GetBinaryStatusRequest{
 		Name: sidechainName,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("failed to check %s status: %w", sidechainName, err)
 	}
 
-	status := resp.Msg.Status
+	status := resp.Status
 	if !status.Downloaded {
 		// Binary not downloaded - ask user or auto-download in CI
 		autoDownload := cctx.Bool("auto-download") || os.Getenv("ORCHESTRATOR_AUTO_DOWNLOAD") != ""
diff --git a/sidechain-orchestrator/commands/ecash.go b/sidechain-orchestrator/commands/ecash.go
index d60c3f74d0..fb755e3d3b 100644
--- a/sidechain-orchestrator/commands/ecash.go
+++ b/sidechain-orchestrator/commands/ecash.go
@@ -8,7 +8,6 @@ import (
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect"
 	"github.com/urfave/cli/v2"
@@ -65,21 +64,21 @@ func runECashMigrate(cctx *cli.Context, client rpc.OrchestratorServiceClient, in
 	}
 
 	if cctx.Bool("preview") || !cctx.Bool("yes") {
-		resp, err := client.PreviewECashMigration(cctx.Context, connect.NewRequest(&pb.PreviewECashMigrationRequest{
+		resp, err := client.PreviewECashMigration(cctx.Context, &pb.PreviewECashMigrationRequest{
 			FromId: fromID,
 			ToId:   toID,
-		}))
+		})
 		if err != nil {
 			return fmt.Errorf("get the migration preview: %w", err)
 		}
-		if err := checkECashMigrationTarget(resp.Msg.Status, fromID, toID); err != nil {
+		if err := checkECashMigrationTarget(resp.Status, fromID, toID); err != nil {
 			return err
 		}
-		if err := writeECashMigrationStatus(cctx.App.Writer, resp.Msg.Status, cctx.Bool("json")); err != nil {
+		if err := writeECashMigrationStatus(cctx.App.Writer, resp.Status, cctx.Bool("json")); err != nil {
 			return err
 		}
-		if resp.Msg.Status.Error != "" {
-			return errors.New(resp.Msg.Status.Error)
+		if resp.Status.Error != "" {
+			return errors.New(resp.Status.Error)
 		}
 		if cctx.Bool("preview") {
 			return nil
@@ -100,14 +99,14 @@ func runECashMigrate(cctx *cli.Context, client rpc.OrchestratorServiceClient, in
 		}
 	}
 
-	resp, err := client.StartECashMigration(cctx.Context, connect.NewRequest(&pb.StartECashMigrationRequest{
+	resp, err := client.StartECashMigration(cctx.Context, &pb.StartECashMigrationRequest{
 		FromId: fromID,
 		ToId:   toID,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("start the migration: %w", err)
 	}
-	status := resp.Msg.Status
+	status := resp.Status
 	if err := checkECashMigrationTarget(status, fromID, toID); err != nil {
 		return err
 	}
@@ -151,11 +150,11 @@ func runECashMigrate(cctx *cli.Context, client rpc.OrchestratorServiceClient, in
 			return fmt.Errorf("the daemon keeps the migration job; use ecash migration-status: %w", cctx.Err())
 		case <-timer.C:
 		}
-		next, err := client.GetECashMigrationStatus(cctx.Context, connect.NewRequest(&pb.GetECashMigrationStatusRequest{}))
+		next, err := client.GetECashMigrationStatus(cctx.Context, &pb.GetECashMigrationStatusRequest{})
 		if err != nil {
 			return fmt.Errorf("read the migration status; use ecash migration-status to check the daemon: %w", err)
 		}
-		status = next.Msg.Status
+		status = next.Status
 	}
 }
 
@@ -163,15 +162,15 @@ func runECashMigrationStatus(cctx *cli.Context, client rpc.OrchestratorServiceCl
 	if cctx.NArg() != 0 {
 		return errors.New("migration-status accepts no positional arguments")
 	}
-	resp, err := client.GetECashMigrationStatus(cctx.Context, connect.NewRequest(&pb.GetECashMigrationStatusRequest{}))
+	resp, err := client.GetECashMigrationStatus(cctx.Context, &pb.GetECashMigrationStatusRequest{})
 	if err != nil {
 		return fmt.Errorf("read the migration status: %w", err)
 	}
-	if err := writeECashMigrationStatus(cctx.App.Writer, resp.Msg.Status, cctx.Bool("json")); err != nil {
+	if err := writeECashMigrationStatus(cctx.App.Writer, resp.Status, cctx.Bool("json")); err != nil {
 		return err
 	}
-	if resp.Msg.Status.Error != "" {
-		return errors.New(resp.Msg.Status.Error)
+	if resp.Status.Error != "" {
+		return errors.New(resp.Status.Error)
 	}
 	return nil
 }
diff --git a/sidechain-orchestrator/commands/ecash_test.go b/sidechain-orchestrator/commands/ecash_test.go
index 57ef5d2077..ee435d96af 100644
--- a/sidechain-orchestrator/commands/ecash_test.go
+++ b/sidechain-orchestrator/commands/ecash_test.go
@@ -4,15 +4,16 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"flag"
 	"io"
+	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/localauth"
@@ -34,39 +35,42 @@ type ecashMigrationServer struct {
 	statusCalls  int
 }
 
-func (s *ecashMigrationServer) PreviewECashMigration(_ context.Context, req *connect.Request[pb.PreviewECashMigrationRequest]) (*connect.Response[pb.PreviewECashMigrationResponse], error) {
-	s.previews = append(s.previews, req.Msg)
+func (s *ecashMigrationServer) PreviewECashMigration(_ context.Context, req *pb.PreviewECashMigrationRequest) (*pb.PreviewECashMigrationResponse, error) {
+	s.previews = append(s.previews, req)
 	if s.previewError != nil {
 		return nil, s.previewError
 	}
-	return connect.NewResponse(&pb.PreviewECashMigrationResponse{Status: s.preview}), nil
+	return &pb.PreviewECashMigrationResponse{Status: s.preview}, nil
 }
 
-func (s *ecashMigrationServer) StartECashMigration(_ context.Context, req *connect.Request[pb.StartECashMigrationRequest]) (*connect.Response[pb.StartECashMigrationResponse], error) {
-	s.starts = append(s.starts, req.Msg)
+func (s *ecashMigrationServer) StartECashMigration(_ context.Context, req *pb.StartECashMigrationRequest) (*pb.StartECashMigrationResponse, error) {
+	s.starts = append(s.starts, req)
 	if s.startError != nil {
 		return nil, s.startError
 	}
-	return connect.NewResponse(&pb.StartECashMigrationResponse{Status: s.start}), nil
+	return &pb.StartECashMigrationResponse{Status: s.start}, nil
 }
 
-func (s *ecashMigrationServer) GetECashMigrationStatus(_ context.Context, _ *connect.Request[pb.GetECashMigrationStatusRequest]) (*connect.Response[pb.GetECashMigrationStatusResponse], error) {
+func (s *ecashMigrationServer) GetECashMigrationStatus(_ context.Context, _ *pb.GetECashMigrationStatusRequest) (*pb.GetECashMigrationStatusResponse, error) {
 	s.statusCalls++
 	if s.statusError != nil {
 		return nil, s.statusError
 	}
 	if s.statusCalls > len(s.statuses) {
-		return nil, connect.NewError(connect.CodeInternal, errors.New("the test has no more status data"))
+		return nil, connect.NewError(connect.CodeInternal, "the test has no more status data")
 	}
-	return connect.NewResponse(&pb.GetECashMigrationStatusResponse{Status: s.statuses[s.statusCalls-1]}), nil
+	return &pb.GetECashMigrationStatusResponse{Status: s.statuses[s.statusCalls-1]}, nil
 }
 
 func newECashMigrationClient(t *testing.T, service *ecashMigrationServer) rpc.OrchestratorServiceClient {
 	t.Helper()
-	_, handler := rpc.NewOrchestratorServiceHandler(service)
+	rpcServer := connect.NewServer()
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, service)
+	handler := http.NewServeMux()
+	connecthttp.Mount(handler, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
-	return rpc.NewOrchestratorServiceClient(server.Client(), server.URL)
+	return rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 }
 
 func ecashCommandContext(t *testing.T, command *cli.Command, args ...string) (*cli.Context, *bytes.Buffer) {
@@ -238,7 +242,7 @@ func TestECashPreviewRejectsDifferentNetworks(t *testing.T) {
 func TestECashMigrateReturnsStatusRPCError(t *testing.T) {
 	service := &ecashMigrationServer{
 		start:       ecashTestStatus(),
-		statusError: connect.NewError(connect.CodeUnavailable, errors.New("the daemon stopped")),
+		statusError: connect.NewError(connect.CodeUnavailable, "the daemon stopped"),
 	}
 	cctx, _ := ecashCommandContext(t, ecashMigrateCommand, "--from", "alphanet", "--to", "betanet", "--yes")
 
@@ -328,7 +332,10 @@ func TestECashCommandUsesRPCAddressAndAuthCookie(t *testing.T) {
 	_, err := localauth.WriteCookie(cookieDir)
 	require.NoError(t, err)
 	service := &ecashMigrationServer{preview: ecashTestStatus()}
-	_, handler := rpc.NewOrchestratorServiceHandler(service, connect.WithInterceptors(localauth.Interceptor(cookieDir)))
+	rpcServer := connect.NewServer(localauth.ServerInterceptor(cookieDir))
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, service)
+	handler := http.NewServeMux()
+	connecthttp.Mount(handler, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 	out := new(bytes.Buffer)
diff --git a/sidechain-orchestrator/commands/mining.go b/sidechain-orchestrator/commands/mining.go
index 6cc2174392..c8e00ca2fe 100644
--- a/sidechain-orchestrator/commands/mining.go
+++ b/sidechain-orchestrator/commands/mining.go
@@ -9,7 +9,8 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/urfave/cli/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/stratum/v1"
@@ -18,12 +19,13 @@ import (
 )
 
 func newStratumClient(cctx *cli.Context) stratumv1connect.StratumServiceClient {
-	return stratumv1connect.NewStratumServiceClient(
+	return stratumv1connect.NewStratumServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		fmt.Sprintf("http://%s", cctx.String("rpcserver")),
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir(cctx))),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), localauth.ClientInterceptor(cookieDir(cctx)),
+	))
 }
 
 var miningCommand = &cli.Command{
@@ -66,7 +68,7 @@ var cpuCommand = &cli.Command{
 			threads := uint32(cctx.Uint("threads"))
 			req.CpuThreads = &threads
 		}
-		if _, err := newStratumClient(cctx).SetMiningSettings(cctx.Context, connect.NewRequest(req)); err != nil {
+		if _, err := newStratumClient(cctx).SetMiningSettings(cctx.Context, req); err != nil {
 			return err
 		}
 		fmt.Printf("this computer mines: %s\n", cctx.Args().First())
@@ -99,7 +101,7 @@ var settingsCommand = &cli.Command{
 		if req.Port == nil && req.CpuThreads == nil && req.KeepMiningOnClose == nil {
 			return fmt.Errorf("usage: mining settings [--port=N] [--threads=N] [--keep-mining]")
 		}
-		if _, err := newStratumClient(cctx).SetMiningSettings(cctx.Context, connect.NewRequest(req)); err != nil {
+		if _, err := newStratumClient(cctx).SetMiningSettings(cctx.Context, req); err != nil {
 			return err
 		}
 		fmt.Println("mining settings saved")
@@ -126,9 +128,9 @@ var stratumStartCommand = &cli.Command{
 	Action: func(cctx *cli.Context) error {
 		// A port of zero takes the saved one, so a flag nobody set never
 		// overrules `mining settings --port`.
-		_, err := newStratumClient(cctx).StartStratum(cctx.Context, connect.NewRequest(&pb.StartStratumRequest{
+		_, err := newStratumClient(cctx).StartStratum(cctx.Context, &pb.StartStratumRequest{
 			Port: uint32(cctx.Uint("port")),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -141,7 +143,7 @@ var stratumStopCommand = &cli.Command{
 	Name:  "stop",
 	Usage: "Stop the Stratum server",
 	Action: func(cctx *cli.Context) error {
-		if _, err := newStratumClient(cctx).StopStratum(cctx.Context, connect.NewRequest(&pb.StopStratumRequest{})); err != nil {
+		if _, err := newStratumClient(cctx).StopStratum(cctx.Context, &pb.StopStratumRequest{}); err != nil {
 			return err
 		}
 		fmt.Println("stratum server stopped")
@@ -153,11 +155,11 @@ var stratumStatusCommand = &cli.Command{
 	Name:  "status",
 	Usage: "Show the server, its miners and the blocks they found",
 	Action: func(cctx *cli.Context) error {
-		resp, err := newStratumClient(cctx).GetStratumStatus(cctx.Context, connect.NewRequest(&pb.GetStratumStatusRequest{}))
+		resp, err := newStratumClient(cctx).GetStratumStatus(cctx.Context, &pb.GetStratumStatusRequest{})
 		if err != nil {
 			return err
 		}
-		return printStratumStatus(os.Stdout, resp.Msg, time.Now())
+		return printStratumStatus(os.Stdout, resp, time.Now())
 	},
 }
 
@@ -176,7 +178,7 @@ var stratumTargetCommand = &cli.Command{
 			return fmt.Errorf("usage: mining stratum target [flags] <solo|pool-id|custom>")
 		}
 		target := stratumTarget(cctx.Args().First(), cctx.String("url"), cctx.String("worker"), cctx.String("password"))
-		if _, err := newStratumClient(cctx).SetTarget(cctx.Context, connect.NewRequest(&pb.SetTargetRequest{Target: target})); err != nil {
+		if _, err := newStratumClient(cctx).SetTarget(cctx.Context, &pb.SetTargetRequest{Target: target}); err != nil {
 			return err
 		}
 		fmt.Printf("stratum target: %s\n", describeTarget(target))
@@ -220,10 +222,10 @@ var workModeCommand = &cli.Command{
 		if !ok {
 			return fmt.Errorf("work mode %q is not low, mid or high", cctx.Args().Get(1))
 		}
-		_, err := newStratumClient(cctx).SetWorkMode(cctx.Context, connect.NewRequest(&pb.SetWorkModeRequest{
+		_, err := newStratumClient(cctx).SetWorkMode(cctx.Context, &pb.SetWorkModeRequest{
 			Address: cctx.Args().First(),
 			Mode:    mode,
-		}))
+		})
 		if err != nil {
 			return err
 		}
diff --git a/sidechain-orchestrator/commands/reset.go b/sidechain-orchestrator/commands/reset.go
index 7894bd6e68..2807f711e9 100644
--- a/sidechain-orchestrator/commands/reset.go
+++ b/sidechain-orchestrator/commands/reset.go
@@ -2,11 +2,12 @@ package commands
 
 import (
 	"encoding/hex"
+	"errors"
 	"fmt"
+	"io"
 	"os"
 	"text/tabwriter"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	"github.com/urfave/cli/v2"
 )
@@ -45,13 +46,13 @@ var rejectBlockCommand = &cli.Command{
 			BlockHash:           hash,
 			EnforcerWaitSeconds: uint32(cctx.Uint("enforcer-wait")),
 		}
-		resp, err := newClient(cctx).RejectBlock(cctx.Context, connect.NewRequest(req))
+		resp, err := newClient(cctx).RejectBlock(cctx.Context, req)
 		if err != nil {
 			return err
 		}
 
-		fmt.Printf("core tip: %d %s\n", resp.Msg.CoreHeight, resp.Msg.CoreTipHash)
-		switch resp.Msg.Outcome {
+		fmt.Printf("core tip: %d %s\n", resp.CoreHeight, resp.CoreTipHash)
+		switch resp.Outcome {
 		case pb.RejectOutcome_REJECT_OUTCOME_SWITCHED_BRANCH:
 			fmt.Println("chain:    followed another branch")
 		case pb.RejectOutcome_REJECT_OUTCOME_PARKED_ON_PARENT:
@@ -61,18 +62,18 @@ var rejectBlockCommand = &cli.Command{
 		default:
 			fmt.Println("chain:    unchanged")
 		}
-		if resp.Msg.EnforcerError != "" {
-			return fmt.Errorf("core moved but the enforcer did not follow: %s", resp.Msg.EnforcerError)
+		if resp.EnforcerError != "" {
+			return fmt.Errorf("core moved but the enforcer did not follow: %s", resp.EnforcerError)
 		}
-		if !resp.Msg.EnforcerChecked {
+		if !resp.EnforcerChecked {
 			fmt.Println("enforcer: not queried, it reads the chain on its next start")
 			return nil
 		}
-		if resp.Msg.EnforcerRebuilt {
+		if resp.EnforcerRebuilt {
 			fmt.Println("enforcer: validator chain deleted, rebuilds from the local core")
 			return nil
 		}
-		fmt.Printf("enforcer: on core's chain, tip %d\n", resp.Msg.EnforcerHeight)
+		fmt.Printf("enforcer: on core's chain, tip %d\n", resp.EnforcerHeight)
 		return nil
 	},
 }
@@ -99,21 +100,26 @@ var resetToBlockCommand = &cli.Command{
 			Target:              target,
 			EnforcerWaitSeconds: uint32(cctx.Uint("enforcer-wait")),
 		}
-		stream, err := newClient(cctx).ResetToBlock(cctx.Context, connect.NewRequest(req))
+		stream, err := newClient(cctx).ResetToBlock(cctx.Context, req)
 		if err != nil {
 			return err
 		}
 		defer func() { _ = stream.Close() }()
 
 		var last *pb.ResetToBlockResponse
-		for stream.Receive() {
-			msg := stream.Msg()
+		for {
+			msg2, err := stream.Receive()
+			if err != nil {
+				if errors.Is(err, io.EOF) {
+					break
+				}
+				return err
+			}
+			msg := msg2
 			last = msg
 			fmt.Printf("%-13s %s\n", resetPhaseLabel(msg.Phase), msg.Message)
 		}
-		if err := stream.Err(); err != nil {
-			return err
-		}
+
 		if last == nil {
 			return fmt.Errorf("the reset reported nothing")
 		}
@@ -171,24 +177,24 @@ var acceptBlockCommand = &cli.Command{
 			BlockHash:           hash,
 			EnforcerWaitSeconds: uint32(cctx.Uint("enforcer-wait")),
 		}
-		resp, err := newClient(cctx).AcceptBlock(cctx.Context, connect.NewRequest(req))
+		resp, err := newClient(cctx).AcceptBlock(cctx.Context, req)
 		if err != nil {
 			return err
 		}
 
-		fmt.Printf("core tip: %d %s\n", resp.Msg.CoreHeight, resp.Msg.CoreTipHash)
-		if resp.Msg.EnforcerError != "" {
-			return fmt.Errorf("core moved but the enforcer did not follow: %s", resp.Msg.EnforcerError)
+		fmt.Printf("core tip: %d %s\n", resp.CoreHeight, resp.CoreTipHash)
+		if resp.EnforcerError != "" {
+			return fmt.Errorf("core moved but the enforcer did not follow: %s", resp.EnforcerError)
 		}
-		if !resp.Msg.EnforcerChecked {
+		if !resp.EnforcerChecked {
 			fmt.Println("enforcer: not queried, it reads the chain on its next start")
 			return nil
 		}
-		if resp.Msg.EnforcerRebuilt {
+		if resp.EnforcerRebuilt {
 			fmt.Println("enforcer: validator chain deleted, rebuilds from the local core")
 			return nil
 		}
-		fmt.Printf("enforcer: on core's chain, tip %d\n", resp.Msg.EnforcerHeight)
+		fmt.Printf("enforcer: on core's chain, tip %d\n", resp.EnforcerHeight)
 		return nil
 	},
 }
@@ -277,13 +283,13 @@ var resetPreviewCommand = &cli.Command{
 			return err
 		}
 		client := newClient(cctx)
-		resp, err := client.GatherFilesToDelete(cctx.Context, connect.NewRequest(&pb.GatherFilesToDeleteRequest{
+		resp, err := client.GatherFilesToDelete(cctx.Context, &pb.GatherFilesToDeleteRequest{
 			Items: resetSpecs(cctx),
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		if len(resp.Msg.Files) == 0 {
+		if len(resp.Files) == 0 {
 			fmt.Println("nothing to delete")
 			return nil
 		}
@@ -291,7 +297,7 @@ var resetPreviewCommand = &cli.Command{
 		var totalBytes int64
 		tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
 		_, _ = fmt.Fprintln(tw, "CATEGORY\tSIZE\tPATH\tKIND")
-		for _, f := range resp.Msg.Files {
+		for _, f := range resp.Files {
 			kind := "file"
 			if f.IsDirectory {
 				kind = "dir"
@@ -302,7 +308,7 @@ var resetPreviewCommand = &cli.Command{
 		if err := tw.Flush(); err != nil {
 			return err
 		}
-		fmt.Printf("\n%d items, %s total\n", len(resp.Msg.Files), humanBytes(totalBytes))
+		fmt.Printf("\n%d items, %s total\n", len(resp.Files), humanBytes(totalBytes))
 		return nil
 	},
 }
@@ -326,27 +332,34 @@ var resetRunCommand = &cli.Command{
 		client := newClient(cctx)
 
 		// Gather the concrete paths, then hand them to the dumb deleter.
-		gathered, err := client.GatherFilesToDelete(cctx.Context, connect.NewRequest(&pb.GatherFilesToDeleteRequest{
+		gathered, err := client.GatherFilesToDelete(cctx.Context, &pb.GatherFilesToDeleteRequest{
 			Items: resetSpecs(cctx),
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		if len(gathered.Msg.Files) == 0 {
+		if len(gathered.Files) == 0 {
 			fmt.Println("nothing to delete")
 			return nil
 		}
 
 		// Hand the same selection to the deleter; it re-resolves paths
 		// server-side so only gather-reported files can be removed.
-		stream, err := client.DeleteFiles(cctx.Context, connect.NewRequest(&pb.DeleteFilesRequest{Items: resetSpecs(cctx)}))
+		stream, err := client.DeleteFiles(cctx.Context, &pb.DeleteFilesRequest{Items: resetSpecs(cctx)})
 		if err != nil {
 			return err
 		}
 
 		deleted, failed := 0, 0
-		for stream.Receive() {
-			msg := stream.Msg()
+		for {
+			msg2, err := stream.Receive()
+			if err != nil {
+				if errors.Is(err, io.EOF) {
+					break
+				}
+				return err
+			}
+			msg := msg2
 			if msg.Error == "" {
 				deleted++
 				fmt.Printf("  ok    %s\n", msg.Path)
@@ -355,9 +368,7 @@ var resetRunCommand = &cli.Command{
 				fmt.Printf("  FAIL  %s (%s)\n", msg.Path, msg.Error)
 			}
 		}
-		if err := stream.Err(); err != nil {
-			return err
-		}
+
 		fmt.Printf("\ndeleted %d, failed %d\n", deleted, failed)
 		if failed > 0 {
 			return fmt.Errorf("%d of %d deletions failed", failed, deleted+failed)
diff --git a/sidechain-orchestrator/commands/reset_test.go b/sidechain-orchestrator/commands/reset_test.go
index 8b13a1d60c..2068dafd98 100644
--- a/sidechain-orchestrator/commands/reset_test.go
+++ b/sidechain-orchestrator/commands/reset_test.go
@@ -1,13 +1,15 @@
 package commands
 
 import (
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"context"
 	"io"
+	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect"
 	"github.com/stretchr/testify/require"
@@ -19,11 +21,11 @@ type resetTestServer struct {
 	results []*pb.DeleteFilesResponse
 }
 
-func (s *resetTestServer) GatherFilesToDelete(context.Context, *connect.Request[pb.GatherFilesToDeleteRequest]) (*connect.Response[pb.GatherFilesToDeleteResponse], error) {
-	return connect.NewResponse(&pb.GatherFilesToDeleteResponse{Files: []*pb.ResetFileInfo{{Path: "/data/a"}, {Path: "/data/b"}}}), nil
+func (s *resetTestServer) GatherFilesToDelete(context.Context, *pb.GatherFilesToDeleteRequest) (*pb.GatherFilesToDeleteResponse, error) {
+	return &pb.GatherFilesToDeleteResponse{Files: []*pb.ResetFileInfo{{Path: "/data/a"}, {Path: "/data/b"}}}, nil
 }
 
-func (s *resetTestServer) DeleteFiles(_ context.Context, _ *connect.Request[pb.DeleteFilesRequest], stream *connect.ServerStream[pb.DeleteFilesResponse]) error {
+func (s *resetTestServer) DeleteFiles(_ context.Context, _ *pb.DeleteFilesRequest, stream rpc.OrchestratorServiceDeleteFilesServerStream) error {
 	for _, result := range s.results {
 		if err := stream.Send(result); err != nil {
 			return err
@@ -34,7 +36,10 @@ func (s *resetTestServer) DeleteFiles(_ context.Context, _ *connect.Request[pb.D
 
 func runResetForTest(t *testing.T, results ...*pb.DeleteFilesResponse) error {
 	t.Helper()
-	_, handler := rpc.NewOrchestratorServiceHandler(&resetTestServer{results: results})
+	rpcServer := connect.NewServer()
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, &resetTestServer{results: results})
+	handler := http.NewServeMux()
+	connecthttp.Mount(handler, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 	app := &cli.App{
diff --git a/sidechain-orchestrator/commands/start_scope_test.go b/sidechain-orchestrator/commands/start_scope_test.go
index a40442abc9..d38b937c2c 100644
--- a/sidechain-orchestrator/commands/start_scope_test.go
+++ b/sidechain-orchestrator/commands/start_scope_test.go
@@ -2,8 +2,8 @@ package commands
 
 import (
 	"context"
-	"errors"
 	"flag"
+	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
@@ -11,7 +11,8 @@ import (
 	"sync"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
 	"github.com/urfave/cli/v2"
@@ -82,7 +83,7 @@ func (f *fakeOrchestrator) runningNames() []string {
 	return names
 }
 
-func (f *fakeOrchestrator) ListBinaries(_ context.Context, _ *connect.Request[pb.ListBinariesRequest]) (*connect.Response[pb.ListBinariesResponse], error) {
+func (f *fakeOrchestrator) ListBinaries(_ context.Context, _ *pb.ListBinariesRequest) (*pb.ListBinariesResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -96,37 +97,37 @@ func (f *fakeOrchestrator) ListBinaries(_ context.Context, _ *connect.Request[pb
 			PortInUse:  !f.running[name] && f.portInUse[name],
 		})
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
-func (f *fakeOrchestrator) GetBinaryStatus(_ context.Context, req *connect.Request[pb.GetBinaryStatusRequest]) (*connect.Response[pb.GetBinaryStatusResponse], error) {
-	return connect.NewResponse(&pb.GetBinaryStatusResponse{
-		Status: &pb.BinaryStatusMsg{Name: req.Msg.Name, Downloaded: true, Downloadable: true},
-	}), nil
+func (f *fakeOrchestrator) GetBinaryStatus(_ context.Context, req *pb.GetBinaryStatusRequest) (*pb.GetBinaryStatusResponse, error) {
+	return &pb.GetBinaryStatusResponse{
+		Status: &pb.BinaryStatusMsg{Name: req.Name, Downloaded: true, Downloadable: true},
+	}, nil
 }
 
-func (f *fakeOrchestrator) StartWithL1(_ context.Context, req *connect.Request[pb.StartWithL1Request]) (*connect.Response[pb.StartWithL1Response], error) {
+func (f *fakeOrchestrator) StartWithL1(_ context.Context, req *pb.StartWithL1Request) (*pb.StartWithL1Response, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.running["bitcoind"] = true
 	f.running["enforcer"] = true
-	if f.opensWindow == req.Msg.Target {
-		f.windowOpen[req.Msg.Target] = true
+	if f.opensWindow == req.Target {
+		f.windowOpen[req.Target] = true
 	} else {
-		f.running[req.Msg.Target] = true
+		f.running[req.Target] = true
 	}
-	return connect.NewResponse(&pb.StartWithL1Response{}), nil
+	return &pb.StartWithL1Response{}, nil
 }
 
-func (f *fakeOrchestrator) StartBinary(_ context.Context, req *connect.Request[pb.StartBinaryRequest]) (*connect.Response[pb.StartBinaryResponse], error) {
+func (f *fakeOrchestrator) StartBinary(_ context.Context, req *pb.StartBinaryRequest) (*pb.StartBinaryResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	f.running[req.Msg.Name] = true
-	return connect.NewResponse(&pb.StartBinaryResponse{Pid: 1234}), nil
+	f.running[req.Name] = true
+	return &pb.StartBinaryResponse{Pid: 1234}, nil
 }
 
 // StreamLogs ends at once, which is the ctrl+c path the user hits.
-func (f *fakeOrchestrator) StreamLogs(_ context.Context, _ *connect.Request[pb.StreamLogsRequest], _ *connect.ServerStream[pb.StreamLogsResponse]) error {
+func (f *fakeOrchestrator) StreamLogs(_ context.Context, _ *pb.StreamLogsRequest, _ rpc.OrchestratorServiceStreamLogsServerStream) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	for _, name := range f.startsDuringStream {
@@ -138,19 +139,19 @@ func (f *fakeOrchestrator) StreamLogs(_ context.Context, _ *connect.Request[pb.S
 	return f.streamErr
 }
 
-func (f *fakeOrchestrator) StopBinary(_ context.Context, req *connect.Request[pb.StopBinaryRequest]) (*connect.Response[pb.StopBinaryResponse], error) {
+func (f *fakeOrchestrator) StopBinary(_ context.Context, req *pb.StopBinaryRequest) (*pb.StopBinaryResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	f.stopped = append(f.stopped, req.Msg.Name)
-	if f.stopFailures[req.Msg.Name] {
-		return nil, connect.NewError(connect.CodeInternal, errors.New("stop timed out"))
+	f.stopped = append(f.stopped, req.Name)
+	if f.stopFailures[req.Name] {
+		return nil, connect.NewError(connect.CodeInternal, "stop timed out")
 	}
-	delete(f.running, req.Msg.Name)
-	delete(f.windowOpen, req.Msg.Name)
-	return connect.NewResponse(&pb.StopBinaryResponse{}), nil
+	delete(f.running, req.Name)
+	delete(f.windowOpen, req.Name)
+	return &pb.StopBinaryResponse{}, nil
 }
 
-func (f *fakeOrchestrator) ShutdownAll(_ context.Context, _ *connect.Request[pb.ShutdownAllRequest], stream *connect.ServerStream[pb.ShutdownAllResponse]) error {
+func (f *fakeOrchestrator) ShutdownAll(_ context.Context, _ *pb.ShutdownAllRequest, stream rpc.OrchestratorServiceShutdownAllServerStream) error {
 	f.mu.Lock()
 	f.shutdownAlls++
 	f.mu.Unlock()
@@ -170,11 +171,17 @@ func newFakeOrchestrator(t *testing.T, alreadyRunning ...string) (*fakeOrchestra
 		fake.running[name] = true
 	}
 
-	_, handler := rpc.NewOrchestratorServiceHandler(fake)
+	rpcServer := connect.NewServer()
+
+	rpc.RegisterOrchestratorServiceHandler(rpcServer, fake)
+
+	handler := http.NewServeMux()
+
+	connecthttp.Mount(handler, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(handler)
 	t.Cleanup(server.Close)
 
-	return fake, rpc.NewOrchestratorServiceClient(server.Client(), server.URL)
+	return fake, rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 }
 
 func startContext(t *testing.T, argv ...string) *cli.Context {
@@ -423,10 +430,16 @@ func TestWipe(t *testing.T) {
 		require.NoError(t, os.WriteFile(walletPath, []byte("keys"), 0o600))
 		require.NoError(t, os.WriteFile(dataPath, []byte("chain"), 0o600))
 
-		_, handler := rpc.NewOrchestratorServiceHandler(api.NewHandler(orch))
+		rpcServer := connect.NewServer()
+
+		rpc.RegisterOrchestratorServiceHandler(rpcServer, api.NewHandler(orch))
+
+		handler := http.NewServeMux()
+
+		connecthttp.Mount(handler, rpcServer, connecthttp.WithReadMaxBytes(0))
 		server := httptest.NewServer(handler)
 		t.Cleanup(server.Close)
-		client := rpc.NewOrchestratorServiceClient(server.Client(), server.URL)
+		client := rpc.NewOrchestratorServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0))))
 
 		require.NoError(t, runWipe(wipeContext(t, "--include-wallets", "thunder"), client))
 
@@ -453,7 +466,7 @@ func TestWipe(t *testing.T) {
 
 func TestStartReportsALogStreamFailure(t *testing.T) {
 	fake, client := newFakeOrchestrator(t)
-	fake.streamErr = connect.NewError(connect.CodeNotFound, errors.New("no log for photon"))
+	fake.streamErr = connect.NewError(connect.CodeNotFound, "no log for photon")
 
 	require.ErrorContains(t, runStart(startContext(t, "photon"), client), "no log for photon")
 
diff --git a/sidechain-orchestrator/commands/thunder.go b/sidechain-orchestrator/commands/thunder.go
index f788b3dd89..eab537b657 100644
--- a/sidechain-orchestrator/commands/thunder.go
+++ b/sidechain-orchestrator/commands/thunder.go
@@ -4,7 +4,8 @@ import (
 	"fmt"
 	"net/http"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/urfave/cli/v2"
 
 	thunderpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/thunder/v1"
@@ -16,12 +17,13 @@ import (
 // runs no thunder node, so a command reads the wallet here rather than at a
 // node port.
 func newThunderService(cctx *cli.Context) thunderrpc.ThunderServiceClient {
-	return thunderrpc.NewThunderServiceClient(
+	return thunderrpc.NewThunderServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		fmt.Sprintf("http://%s", cctx.String("rpcserver")),
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir(cctx))),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), localauth.ClientInterceptor(cookieDir(cctx)),
+	))
 }
 
 var thunderAddressCommand = &cli.Command{
@@ -29,11 +31,11 @@ var thunderAddressCommand = &cli.Command{
 	Usage: "Show an address to receive on",
 	Action: func(cctx *cli.Context) error {
 		resp, err := newThunderService(cctx).GetNewAddress(
-			cctx.Context, connect.NewRequest(&thunderpb.GetNewAddressRequest{}))
+			cctx.Context, &thunderpb.GetNewAddressRequest{})
 		if err != nil {
 			return err
 		}
-		fmt.Println(resp.Msg.Address)
+		fmt.Println(resp.Address)
 		return nil
 	},
 }
@@ -44,17 +46,17 @@ var thunderTransactionsCommand = &cli.Command{
 	Usage:   "List the transactions that touched this wallet",
 	Action: func(cctx *cli.Context) error {
 		resp, err := newThunderService(cctx).ListWalletTransactions(
-			cctx.Context, connect.NewRequest(&thunderpb.ListWalletTransactionsRequest{}))
+			cctx.Context, &thunderpb.ListWalletTransactionsRequest{})
 		if err != nil {
 			return err
 		}
-		if len(resp.Msg.Transactions) == 0 {
+		if len(resp.Transactions) == 0 {
 			fmt.Println("this wallet holds no transactions")
 			return nil
 		}
-		for _, tx := range resp.Msg.Transactions {
+		for _, tx := range resp.Transactions {
 			fmt.Printf("%s  %s BTC  %s\n",
-				tx.Txid, satsToBtcInt(tx.ValueSats), txState(tx, resp.Msg.TipHeight))
+				tx.Txid, satsToBtcInt(tx.ValueSats), txState(tx, resp.TipHeight))
 		}
 		return nil
 	},
diff --git a/sidechain-orchestrator/commands/wallet.go b/sidechain-orchestrator/commands/wallet.go
index 702e3c050d..d0e3520a95 100644
--- a/sidechain-orchestrator/commands/wallet.go
+++ b/sidechain-orchestrator/commands/wallet.go
@@ -2,7 +2,9 @@ package commands
 
 import (
 	"encoding/hex"
+	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
 	"strconv"
@@ -10,7 +12,8 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/localauth"
@@ -24,12 +27,13 @@ const satsPerBTC = 100_000_000
 func newWalletClient(cctx *cli.Context) rpc.WalletManagerServiceClient {
 	addr := cctx.String("rpcserver")
 	url := fmt.Sprintf("http://%s", addr)
-	return rpc.NewWalletManagerServiceClient(
+	return rpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		url,
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(cookieDir(cctx))),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), localauth.ClientInterceptor(cookieDir(cctx)),
+	))
 }
 
 // resolveWalletID returns the positional wallet-id arg, falling back to the
@@ -39,14 +43,14 @@ func resolveWalletID(cctx *cli.Context, client rpc.WalletManagerServiceClient) (
 	if cctx.NArg() >= 1 {
 		return cctx.Args().First(), nil
 	}
-	resp, err := client.GetWalletStatus(cctx.Context, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+	resp, err := client.GetWalletStatus(cctx.Context, &pb.GetWalletStatusRequest{})
 	if err != nil {
 		return "", fmt.Errorf("get wallet status: %w", err)
 	}
-	if resp.Msg.State == pb.WalletState_WALLET_STATE_NO_WALLET || resp.Msg.ActiveWalletId == "" {
+	if resp.State == pb.WalletState_WALLET_STATE_NO_WALLET || resp.ActiveWalletId == "" {
 		return "", fmt.Errorf("no active wallet — pass a wallet id or run `wallet setactive <id>`")
 	}
-	return resp.Msg.ActiveWalletId, nil
+	return resp.ActiveWalletId, nil
 }
 
 // confirmOrAbort prompts on stdin unless `--yes` was passed. Returns an error
@@ -115,18 +119,18 @@ var walletBackupsCommand = &cli.Command{
 	Usage:   "List local wallet backups available for restore",
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		resp, err := client.ListWalletBackups(cctx.Context, connect.NewRequest(&pb.ListWalletBackupsRequest{}))
+		resp, err := client.ListWalletBackups(cctx.Context, &pb.ListWalletBackupsRequest{})
 		if err != nil {
 			return err
 		}
-		if len(resp.Msg.Backups) == 0 {
+		if len(resp.Backups) == 0 {
 			fmt.Println("no wallet backups")
 			return nil
 		}
 
 		tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
 		_, _ = fmt.Fprintln(tw, "ID\tCREATED\tENCRYPTED\tVALID\tWALLETS\tLATEST KNOWN BALANCE")
-		for _, backup := range resp.Msg.Backups {
+		for _, backup := range resp.Backups {
 			createdAt := "-"
 			if backup.CreatedAt != nil {
 				createdAt = backup.CreatedAt.AsTime().Local().Format("2006-01-02 15:04:05")
@@ -172,17 +176,23 @@ var walletRestoreCommand = &cli.Command{
 		}
 
 		client := newWalletClient(cctx)
-		stream, err := client.RestoreWalletBackupStream(cctx.Context, connect.NewRequest(&pb.RestoreWalletBackupRequest{
+		stream, err := client.RestoreWalletBackupStream(cctx.Context, &pb.RestoreWalletBackupRequest{
 			BackupId: backupID,
 			Password: cctx.String("password"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
 
 		stepNames := map[string]string{}
-		for stream.Receive() {
-			msg := stream.Msg()
+		var streamErr error
+		for {
+			msg2, err := stream.Receive()
+			if err != nil {
+				streamErr = err
+				break
+			}
+			msg := msg2
 			if len(msg.Steps) > 0 {
 				fmt.Println("restore plan:")
 				for _, step := range msg.Steps {
@@ -218,7 +228,10 @@ var walletRestoreCommand = &cli.Command{
 				}
 			}
 		}
-		return stream.Err()
+		if errors.Is(streamErr, io.EOF) {
+			streamErr = nil
+		}
+		return streamErr
 	},
 }
 
@@ -227,12 +240,12 @@ var walletStatusCommand = &cli.Command{
 	Usage: "Show wallet status",
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		resp, err := client.GetWalletStatus(cctx.Context, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		resp, err := client.GetWalletStatus(cctx.Context, &pb.GetWalletStatusRequest{})
 		if err != nil {
 			return err
 		}
 
-		s := resp.Msg
+		s := resp
 		if s.State == pb.WalletState_WALLET_STATE_NO_WALLET {
 			fmt.Println("no wallet is created yet. would you like to create a wallet now? [Y/n]")
 			if confirmYes() {
@@ -319,16 +332,16 @@ var walletCreateCommand = &cli.Command{
 			if name == "" {
 				name = "Bitcoin Core Wallet"
 			}
-			resp, err := client.GenerateWallet(cctx.Context, connect.NewRequest(&pb.GenerateWalletRequest{
+			resp, err := client.GenerateWallet(cctx.Context, &pb.GenerateWalletRequest{
 				Name:           name,
 				CustomMnemonic: cctx.String("mnemonic"),
 				Passphrase:     cctx.String("passphrase"),
-			}))
+			})
 			if err != nil {
 				return err
 			}
-			fmt.Printf("wallet created: %s\n", resp.Msg.WalletId)
-			fmt.Printf("\n⚠️  BACK UP YOUR MNEMONIC:\n\n  %s\n\n", resp.Msg.Mnemonic)
+			fmt.Printf("wallet created: %s\n", resp.WalletId)
+			fmt.Printf("\n⚠️  BACK UP YOUR MNEMONIC:\n\n  %s\n\n", resp.Mnemonic)
 			return nil
 		case "electrum":
 			if cctx.String("passphrase") != "" {
@@ -338,16 +351,16 @@ var walletCreateCommand = &cli.Command{
 			if name == "" {
 				name = "Electrum Wallet"
 			}
-			resp, err := client.CreateElectrumWallet(cctx.Context, connect.NewRequest(&pb.CreateElectrumWalletRequest{
+			resp, err := client.CreateElectrumWallet(cctx.Context, &pb.CreateElectrumWalletRequest{
 				Name:           name,
 				CustomMnemonic: cctx.String("mnemonic"),
 				ScriptType:     cctx.String("script-type"),
-			}))
+			})
 			if err != nil {
 				return err
 			}
-			fmt.Printf("electrum wallet created: %s\n", resp.Msg.WalletId)
-			fmt.Printf("\n⚠️  Reveal + back up the seed with: wallet seed %s\n\n", resp.Msg.WalletId)
+			fmt.Printf("electrum wallet created: %s\n", resp.WalletId)
+			fmt.Printf("\n⚠️  Reveal + back up the seed with: wallet seed %s\n\n", resp.WalletId)
 			return nil
 		default:
 			return fmt.Errorf("unknown wallet type %q (want core or electrum)", cctx.String("type"))
@@ -367,17 +380,17 @@ var walletListCommand = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		resp, err := client.ListWallets(cctx.Context, connect.NewRequest(&pb.ListWalletsRequest{}))
+		resp, err := client.ListWallets(cctx.Context, &pb.ListWalletsRequest{})
 		if err != nil {
 			return err
 		}
 
-		if len(resp.Msg.Wallets) == 0 {
+		if len(resp.Wallets) == 0 {
 			fmt.Println("no wallets")
 			return nil
 		}
 
-		activeID := resp.Msg.ActiveWalletId
+		activeID := resp.ActiveWalletId
 		tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
 		verbose := cctx.Bool("verbose")
 		if verbose {
@@ -385,7 +398,7 @@ var walletListCommand = &cli.Command{
 		} else {
 			_, _ = fmt.Fprintln(tw, "ACTIVE\tID\tNAME\tTYPE\tCREATED\tBIP47")
 		}
-		for _, w := range resp.Msg.Wallets {
+		for _, w := range resp.Wallets {
 			marker := " "
 			if w.Id == activeID {
 				marker = "*"
@@ -418,9 +431,9 @@ var walletSetActiveCommand = &cli.Command{
 		}
 
 		client := newWalletClient(cctx)
-		_, err := client.SwitchWallet(cctx.Context, connect.NewRequest(&pb.SwitchWalletRequest{
+		_, err := client.SwitchWallet(cctx.Context, &pb.SwitchWalletRequest{
 			WalletId: cctx.Args().First(),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -448,7 +461,7 @@ var walletDeleteCommand = &cli.Command{
 			if !confirmYes() {
 				return fmt.Errorf("aborted")
 			}
-			_, err := client.DeleteAllWallets(cctx.Context, connect.NewRequest(&pb.DeleteAllWalletsRequest{}))
+			_, err := client.DeleteAllWallets(cctx.Context, &pb.DeleteAllWalletsRequest{})
 			if err != nil {
 				return err
 			}
@@ -461,9 +474,9 @@ var walletDeleteCommand = &cli.Command{
 		}
 
 		walletID := cctx.Args().First()
-		_, err := client.DeleteWallet(cctx.Context, connect.NewRequest(&pb.DeleteWalletRequest{
+		_, err := client.DeleteWallet(cctx.Context, &pb.DeleteWalletRequest{
 			WalletId: walletID,
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -478,7 +491,7 @@ var walletLockCommand = &cli.Command{
 	Usage: "Lock the wallet",
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		_, err := client.LockWallet(cctx.Context, connect.NewRequest(&pb.LockWalletRequest{}))
+		_, err := client.LockWallet(cctx.Context, &pb.LockWalletRequest{})
 		if err != nil {
 			return err
 		}
@@ -499,9 +512,9 @@ var walletUnlockCommand = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		_, err := client.UnlockWallet(cctx.Context, connect.NewRequest(&pb.UnlockWalletRequest{
+		_, err := client.UnlockWallet(cctx.Context, &pb.UnlockWalletRequest{
 			Password: cctx.String("password"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -522,9 +535,9 @@ var walletEncryptCommand = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		_, err := client.EncryptWallet(cctx.Context, connect.NewRequest(&pb.EncryptWalletRequest{
+		_, err := client.EncryptWallet(cctx.Context, &pb.EncryptWalletRequest{
 			Password: cctx.String("password"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -546,10 +559,10 @@ var walletChangePasswordCommand = &cli.Command{
 			return err
 		}
 		client := newWalletClient(cctx)
-		_, err := client.ChangePassword(cctx.Context, connect.NewRequest(&pb.ChangePasswordRequest{
+		_, err := client.ChangePassword(cctx.Context, &pb.ChangePasswordRequest{
 			OldPassword: cctx.String("old"),
 			NewPassword: cctx.String("new"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -570,9 +583,9 @@ var walletRemoveEncryptionCommand = &cli.Command{
 			return err
 		}
 		client := newWalletClient(cctx)
-		_, err := client.RemoveEncryption(cctx.Context, connect.NewRequest(&pb.RemoveEncryptionRequest{
+		_, err := client.RemoveEncryption(cctx.Context, &pb.RemoveEncryptionRequest{
 			Password: cctx.String("password"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -594,11 +607,11 @@ var walletRenameCommand = &cli.Command{
 			return fmt.Errorf("usage: drivechain-cli wallet rename <wallet-id> --name NAME [--gradient JSON]")
 		}
 		client := newWalletClient(cctx)
-		_, err := client.UpdateWalletMetadata(cctx.Context, connect.NewRequest(&pb.UpdateWalletMetadataRequest{
+		_, err := client.UpdateWalletMetadata(cctx.Context, &pb.UpdateWalletMetadataRequest{
 			WalletId:     cctx.Args().First(),
 			Name:         cctx.String("name"),
 			GradientJson: cctx.String("gradient"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
@@ -621,17 +634,17 @@ var walletSeedCommand = &cli.Command{
 		}
 
 		client := newWalletClient(cctx)
-		resp, err := client.GetWalletSeed(cctx.Context, connect.NewRequest(&pb.GetWalletSeedRequest{
+		resp, err := client.GetWalletSeed(cctx.Context, &pb.GetWalletSeedRequest{
 			WalletId: walletID,
-		}))
+		})
 		if err != nil {
 			return err
 		}
 
 		fmt.Print("⚠️  SENSITIVE — do not share!\n\n")
-		fmt.Printf("seed:     %s\n", resp.Msg.SeedHex)
-		if resp.Msg.Mnemonic != "" {
-			fmt.Printf("mnemonic: %s\n", resp.Msg.Mnemonic)
+		fmt.Printf("seed:     %s\n", resp.SeedHex)
+		if resp.Mnemonic != "" {
+			fmt.Printf("mnemonic: %s\n", resp.Mnemonic)
 		}
 		return nil
 	},
@@ -647,12 +660,12 @@ var walletBalanceCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		resp, err := client.GetBalance(cctx.Context, connect.NewRequest(&pb.GetBalanceRequest{WalletId: walletID}))
+		resp, err := client.GetBalance(cctx.Context, &pb.GetBalanceRequest{WalletId: walletID})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("confirmed:   %s BTC (%.0f sats)\n", satsToBtc(resp.Msg.ConfirmedSats), resp.Msg.ConfirmedSats)
-		fmt.Printf("unconfirmed: %s BTC (%.0f sats)\n", satsToBtc(resp.Msg.UnconfirmedSats), resp.Msg.UnconfirmedSats)
+		fmt.Printf("confirmed:   %s BTC (%.0f sats)\n", satsToBtc(resp.ConfirmedSats), resp.ConfirmedSats)
+		fmt.Printf("unconfirmed: %s BTC (%.0f sats)\n", satsToBtc(resp.UnconfirmedSats), resp.UnconfirmedSats)
 		return nil
 	},
 }
@@ -667,11 +680,11 @@ var walletNewAddressCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		resp, err := client.GetNewAddress(cctx.Context, connect.NewRequest(&pb.GetNewAddressRequest{WalletId: walletID}))
+		resp, err := client.GetNewAddress(cctx.Context, &pb.GetNewAddressRequest{WalletId: walletID})
 		if err != nil {
 			return err
 		}
-		fmt.Println(resp.Msg.Address)
+		fmt.Println(resp.Address)
 		return nil
 	},
 }
@@ -686,17 +699,17 @@ var walletAddressesCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		resp, err := client.ListReceiveAddresses(cctx.Context, connect.NewRequest(&pb.ListReceiveAddressesRequest{WalletId: walletID}))
+		resp, err := client.ListReceiveAddresses(cctx.Context, &pb.ListReceiveAddressesRequest{WalletId: walletID})
 		if err != nil {
 			return err
 		}
-		if len(resp.Msg.Addresses) == 0 {
+		if len(resp.Addresses) == 0 {
 			fmt.Println("no receive addresses")
 			return nil
 		}
 		tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
 		_, _ = fmt.Fprintln(tw, "ADDRESS\tRECEIVED (BTC)\tTX COUNT\tLABEL")
-		for _, a := range resp.Msg.Addresses {
+		for _, a := range resp.Addresses {
 			label := a.Label
 			if label == "" {
 				label = "-"
@@ -721,20 +734,20 @@ var walletTransactionsCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		resp, err := client.ListTransactions(cctx.Context, connect.NewRequest(&pb.ListTransactionsRequest{
+		resp, err := client.ListTransactions(cctx.Context, &pb.ListTransactionsRequest{
 			WalletId: walletID,
 			Count:    int32(cctx.Int("count")),
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		if len(resp.Msg.Transactions) == 0 {
+		if len(resp.Transactions) == 0 {
 			fmt.Println("no transactions")
 			return nil
 		}
 		tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
 		_, _ = fmt.Fprintln(tw, "TIME\tCATEGORY\tAMOUNT (BTC)\tCONF\tTXID")
-		for _, t := range resp.Msg.Transactions {
+		for _, t := range resp.Transactions {
 			ts := "-"
 			if t.Time != 0 {
 				ts = time.Unix(t.Time, 0).Format("2006-01-02 15:04")
@@ -759,17 +772,17 @@ var walletUnspentCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		resp, err := client.ListUnspent(cctx.Context, connect.NewRequest(&pb.ListUnspentRequest{WalletId: walletID}))
+		resp, err := client.ListUnspent(cctx.Context, &pb.ListUnspentRequest{WalletId: walletID})
 		if err != nil {
 			return err
 		}
-		if len(resp.Msg.Utxos) == 0 {
+		if len(resp.Utxos) == 0 {
 			fmt.Println("no unspent outputs")
 			return nil
 		}
 		tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
 		_, _ = fmt.Fprintln(tw, "OUTPOINT\tADDRESS\tBTC\tCONF\tLABEL")
-		for _, u := range resp.Msg.Utxos {
+		for _, u := range resp.Utxos {
 			label := u.Label
 			if label == "" {
 				label = "-"
@@ -820,18 +833,18 @@ var walletSendCommand = &cli.Command{
 			return err
 		}
 
-		resp, err := client.SendTransaction(cctx.Context, connect.NewRequest(&pb.SendTransactionRequest{
+		resp, err := client.SendTransaction(cctx.Context, &pb.SendTransactionRequest{
 			WalletId:              walletID,
 			Destinations:          destinations,
 			FeeRateSatPerVbyte:    cctx.Int64("fee-rate"),
 			FixedFeeSats:          cctx.Int64("fixed-fee-sats"),
 			SubtractFeeFromAmount: cctx.Bool("subtract-fee"),
 			OpReturnHex:           opReturnHex,
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("sent: %s\n", resp.Msg.Txid)
+		fmt.Printf("sent: %s\n", resp.Txid)
 		return nil
 	},
 }
@@ -860,14 +873,14 @@ var walletTxCommand = &cli.Command{
 			txid = cctx.Args().Get(1)
 		}
 
-		resp, err := client.GetTransactionDetails(cctx.Context, connect.NewRequest(&pb.GetTransactionDetailsRequest{
+		resp, err := client.GetTransactionDetails(cctx.Context, &pb.GetTransactionDetailsRequest{
 			WalletId: walletID,
 			Txid:     txid,
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		m := resp.Msg
+		m := resp
 		fmt.Printf("txid:           %s\n", m.Transaction.Txid)
 		if err := writeTransactionWarning(os.Stdout, m.Transaction.WarningMessage); err != nil {
 			return err
@@ -939,16 +952,16 @@ var walletBumpFeeCommand = &cli.Command{
 		}
 
 		if cctx.Bool("preview") {
-			resp, err := client.PreviewBumpFee(cctx.Context, connect.NewRequest(&pb.PreviewBumpFeeRequest{
+			resp, err := client.PreviewBumpFee(cctx.Context, &pb.PreviewBumpFeeRequest{
 				WalletId:    walletID,
 				Txid:        txid,
 				NewFeeRate:  cctx.Int64("fee-rate"),
 				FeeFromVout: feeFromVout,
-			}))
+			})
 			if err != nil {
 				return err
 			}
-			msg := resp.Msg
+			msg := resp
 			fmt.Printf("inputs: %d, size: %d vB\n", msg.InputCount, msg.VsizeVbytes)
 			fmt.Printf("fee now: %d sats (%.2f sat/vB), suggested rate: %d sat/vB\n",
 				msg.OldFeeSats, msg.OldFeeRateSatVb, msg.SuggestedFeeRate)
@@ -967,17 +980,17 @@ var walletBumpFeeCommand = &cli.Command{
 			return nil
 		}
 
-		resp, err := client.BumpFee(cctx.Context, connect.NewRequest(&pb.BumpFeeRequest{
+		resp, err := client.BumpFee(cctx.Context, &pb.BumpFeeRequest{
 			WalletId:    walletID,
 			Txid:        txid,
 			NewFeeRate:  cctx.Int64("fee-rate"),
 			FeeFromVout: feeFromVout,
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("replaced txid: %s\n", resp.Msg.NewTxid)
-		printBumpFeePlan(resp.Msg.Plan)
+		fmt.Printf("replaced txid: %s\n", resp.NewTxid)
+		printBumpFeePlan(resp.Plan)
 		return nil
 	},
 }
@@ -1012,15 +1025,15 @@ var walletDeriveCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		resp, err := client.DeriveAddresses(cctx.Context, connect.NewRequest(&pb.DeriveAddressesRequest{
+		resp, err := client.DeriveAddresses(cctx.Context, &pb.DeriveAddressesRequest{
 			WalletId:   walletID,
 			StartIndex: int32(cctx.Int("start")),
 			Count:      int32(cctx.Int("count")),
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		for i, a := range resp.Msg.Addresses {
+		for i, a := range resp.Addresses {
 			fmt.Printf("%d\t%s\n", int(cctx.Int("start"))+i, a)
 		}
 		return nil
@@ -1037,15 +1050,15 @@ var walletWatchOnlyCreateCommand = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		resp, err := client.CreateWatchOnlyWallet(cctx.Context, connect.NewRequest(&pb.CreateWatchOnlyWalletRequest{
+		resp, err := client.CreateWatchOnlyWallet(cctx.Context, &pb.CreateWatchOnlyWalletRequest{
 			Name:             cctx.String("name"),
 			XpubOrDescriptor: cctx.String("xpub-or-descriptor"),
 			GradientJson:     cctx.String("gradient"),
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("watch-only wallet created: %s\n", resp.Msg.WalletId)
+		fmt.Printf("watch-only wallet created: %s\n", resp.WalletId)
 		return nil
 	},
 }
@@ -1060,13 +1073,13 @@ var walletCoreCreateCommand = &cli.Command{
 		if err != nil {
 			return err
 		}
-		resp, err := client.CreateBitcoinCoreWallet(cctx.Context, connect.NewRequest(&pb.CreateBitcoinCoreWalletRequest{
+		resp, err := client.CreateBitcoinCoreWallet(cctx.Context, &pb.CreateBitcoinCoreWalletRequest{
 			WalletId: walletID,
-		}))
+		})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("core wallet ready: %s\n", resp.Msg.CoreWalletName)
+		fmt.Printf("core wallet ready: %s\n", resp.CoreWalletName)
 		return nil
 	},
 }
@@ -1076,11 +1089,11 @@ var walletEnsureCoreCommand = &cli.Command{
 	Usage: "Create missing Bitcoin Core wallets for every entry in wallet.json",
 	Action: func(cctx *cli.Context) error {
 		client := newWalletClient(cctx)
-		resp, err := client.EnsureCoreWallets(cctx.Context, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+		resp, err := client.EnsureCoreWallets(cctx.Context, &pb.EnsureCoreWalletsRequest{})
 		if err != nil {
 			return err
 		}
-		fmt.Printf("synced %d wallet(s)\n", resp.Msg.SyncedCount)
+		fmt.Printf("synced %d wallet(s)\n", resp.SyncedCount)
 		return nil
 	},
 }
diff --git a/sidechain-orchestrator/commands/wallet_burn_ecx.go b/sidechain-orchestrator/commands/wallet_burn_ecx.go
index 920bb72992..25c8d2a5fb 100644
--- a/sidechain-orchestrator/commands/wallet_burn_ecx.go
+++ b/sidechain-orchestrator/commands/wallet_burn_ecx.go
@@ -11,7 +11,8 @@ import (
 	"strconv"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config/netcatalog"
 	confpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	confrpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect"
@@ -41,12 +42,13 @@ func newWalletBurnECXCommand(burnAddress string, minimumSats int64) *cli.Command
 			&cli.StringSliceFlag{Name: "signed-psbt", Usage: "combine a cosigner PSBT file with --psbt-in; repeat for each cosigner"},
 		},
 		Action: func(cctx *cli.Context) error {
-			conf := confrpc.NewBitcoinConfServiceClient(
+			conf := confrpc.NewBitcoinConfServiceClient(connect.NewClient(connecthttp.NewTransport(
 				http.DefaultClient,
 				"http://"+cctx.String("rpcserver"),
-				connect.WithGRPC(),
-				connect.WithInterceptors(localauth.Interceptor(cookieDir(cctx))),
-			)
+				connecthttp.WithReadMaxBytes(0),
+				connecthttp.WithGRPC(),
+			), localauth.ClientInterceptor(cookieDir(cctx)),
+			))
 			return runWalletBurnECX(cctx, newWalletClient(cctx), conf, burnAddress, minimumSats)
 		},
 	}
@@ -62,13 +64,13 @@ type burnWalletState struct {
 }
 
 func (s *burnWalletState) check(cctx *cli.Context, client rpc.WalletManagerServiceClient, conf confrpc.BitcoinConfServiceClient) error {
-	networks, err := conf.ListNetworks(cctx.Context, connect.NewRequest(&confpb.ListNetworksRequest{}))
+	networks, err := conf.ListNetworks(cctx.Context, &confpb.ListNetworksRequest{})
 	if err != nil {
 		return fmt.Errorf("read the network: %w", err)
 	}
 	var current wallet.ECXBurnNetwork
 	var lockTime uint32
-	for _, network := range networks.Msg.Networks {
+	for _, network := range networks.Networks {
 		if network.IsCurrent {
 			if network.Network == "ecash" {
 				current = wallet.ECXBurnNetworkByID(network.Id)
@@ -88,11 +90,11 @@ func (s *burnWalletState) check(cctx *cli.Context, client rpc.WalletManagerServi
 	if s.network != current {
 		return fmt.Errorf("the network changed; create the burn again")
 	}
-	status, err := client.GetWalletStatus(cctx.Context, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+	status, err := client.GetWalletStatus(cctx.Context, &pb.GetWalletStatusRequest{})
 	if err != nil {
 		return fmt.Errorf("read the wallet status: %w", err)
 	}
-	switch status.Msg.State {
+	switch status.State {
 	case pb.WalletState_WALLET_STATE_NO_WALLET:
 		return fmt.Errorf("select a wallet to burn coins")
 	case pb.WalletState_WALLET_STATE_LOCKED:
@@ -100,20 +102,20 @@ func (s *burnWalletState) check(cctx *cli.Context, client rpc.WalletManagerServi
 	}
 	if s.active {
 		if s.walletID == "" {
-			s.walletID = status.Msg.ActiveWalletId
+			s.walletID = status.ActiveWalletId
 		}
-		if s.walletID == "" || status.Msg.ActiveWalletId != s.walletID {
+		if s.walletID == "" || status.ActiveWalletId != s.walletID {
 			return fmt.Errorf("the active wallet changed; create the burn again")
 		}
 	}
-	wallets, err := client.ListWallets(cctx.Context, connect.NewRequest(&pb.ListWalletsRequest{}))
+	wallets, err := client.ListWallets(cctx.Context, &pb.ListWalletsRequest{})
 	if err != nil {
 		return fmt.Errorf("read the wallets: %w", err)
 	}
-	if s.active && wallets.Msg.ActiveWalletId != s.walletID {
+	if s.active && wallets.ActiveWalletId != s.walletID {
 		return fmt.Errorf("the active wallet changed; create the burn again")
 	}
-	for _, wallet := range wallets.Msg.Wallets {
+	for _, wallet := range wallets.Wallets {
 		if wallet.Id != s.walletID {
 			continue
 		}
@@ -171,16 +173,16 @@ func runWalletBurnECX(cctx *cli.Context, client rpc.WalletManagerServiceClient,
 	if err := state.check(cctx, client, conf); err != nil {
 		return err
 	}
-	derived, err := client.DeriveAddresses(cctx.Context, connect.NewRequest(&pb.DeriveAddressesRequest{
+	derived, err := client.DeriveAddresses(cctx.Context, &pb.DeriveAddressesRequest{
 		WalletId: state.walletID, StartIndex: 0, Count: 1,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("derive the first wallet address: %w", err)
 	}
-	if len(derived.Msg.Addresses) != 1 || derived.Msg.Addresses[0] == "" {
+	if len(derived.Addresses) != 1 || derived.Addresses[0] == "" {
 		return fmt.Errorf("the wallet returned no first address")
 	}
-	address := derived.Msg.Addresses[0]
+	address := derived.Addresses[0]
 	dataScript, err := txscript.NewScriptBuilder().AddOp(txscript.OP_RETURN).AddData([]byte(address)).Script()
 	if err != nil {
 		return fmt.Errorf("create the address script: %w", err)
@@ -195,16 +197,16 @@ func runWalletBurnECX(cctx *cli.Context, client rpc.WalletManagerServiceClient,
 			return err
 		}
 	} else {
-		created, err := client.CreatePsbt(cctx.Context, connect.NewRequest(&pb.CreatePsbtRequest{
+		created, err := client.CreatePsbt(cctx.Context, &pb.CreatePsbtRequest{
 			WalletId:           state.walletID,
 			Destinations:       map[string]int64{burnAddress: amount},
 			FeeRateSatPerVbyte: cctx.Int64("fee-rate"),
 			OpReturnHex:        hex.EncodeToString([]byte(address)),
-		}))
+		})
 		if err != nil {
 			return fmt.Errorf("create the burn transaction: %w", err)
 		}
-		packet = created.Msg.PsbtBase64
+		packet = created.PsbtBase64
 	}
 	if err := state.check(cctx, client, conf); err != nil {
 		return err
@@ -218,27 +220,27 @@ func runWalletBurnECX(cctx *cli.Context, client rpc.WalletManagerServiceClient,
 			}
 			packets = append(packets, signed)
 		}
-		combined, err := client.CombinePsbt(cctx.Context, connect.NewRequest(&pb.CombinePsbtRequest{PsbtBase64: packets}))
+		combined, err := client.CombinePsbt(cctx.Context, &pb.CombinePsbtRequest{PsbtBase64: packets})
 		if err != nil {
 			return fmt.Errorf("combine the burn signatures: %w", err)
 		}
 		if err := state.check(cctx, client, conf); err != nil {
 			return err
 		}
-		packet = combined.Msg.PsbtBase64
+		packet = combined.PsbtBase64
 	}
 	if inputPath != "" {
 		if err := wallet.CheckPSBTInputs(packet); err != nil {
 			return err
 		}
 	}
-	decoded, err := client.DecodeTransaction(cctx.Context, connect.NewRequest(&pb.DecodeTransactionRequest{
+	decoded, err := client.DecodeTransaction(cctx.Context, &pb.DecodeTransactionRequest{
 		WalletId: state.walletID, Input: packet, CheckOwnership: true,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("read the burn transaction: %w", err)
 	}
-	if err := checkBurnPreview(decoded.Msg, state.lockTime, amount, burnScript, dataScript); err != nil {
+	if err := checkBurnPreview(decoded, state.lockTime, amount, burnScript, dataScript); err != nil {
 		return err
 	}
 	if err := state.check(cctx, client, conf); err != nil {
@@ -246,25 +248,25 @@ func runWalletBurnECX(cctx *cli.Context, client rpc.WalletManagerServiceClient,
 	}
 	ready := true
 	if state.multisig {
-		status, err := client.MultisigPsbtStatus(cctx.Context, connect.NewRequest(&pb.MultisigPsbtStatusRequest{
+		status, err := client.MultisigPsbtStatus(cctx.Context, &pb.MultisigPsbtStatusRequest{
 			WalletId: state.walletID, PsbtBase64: packet,
-		}))
+		})
 		if err != nil {
 			return fmt.Errorf("read the burn signatures: %w", err)
 		}
 		if err := state.check(cctx, client, conf); err != nil {
 			return err
 		}
-		ready = status.Msg.Finalizable
+		ready = status.Finalizable
 	}
 	creditSats := state.network.CreditSats(amount)
 	preview := fmt.Sprintf("Burn Transaction\nWallet: %s\n%s burn: %s coins (%d satoshis)\nTo BitcoinEater: %s\nThis transaction burns %s coins.\nOP_RETURN: 0 satoshis\nECX address: %s\nThe address used is the first address of this wallet.\nYou will receive 1/%d of the amount you burn as real ECX at this address.\nThe credit rounds up to a whole ECX satoshi.\nReal ECX credit: %s ECX\nNetwork fee: %s %s coins (%d satoshis)\nTotal from %s: %s coins\nYou cannot reverse this burn\n",
 		state.walletID, state.network.Name, formatBurnCoins(amount, 8), amount, burnAddress, state.network.Name, address, state.network.CreditDivisor, formatBurnCoins(creditSats, 8),
-		formatBurnCoins(decoded.Msg.FeeSats, 8), state.network.Name, decoded.Msg.FeeSats, state.network.Name, formatBurnCoins(amount+decoded.Msg.FeeSats, 8))
+		formatBurnCoins(decoded.FeeSats, 8), state.network.Name, decoded.FeeSats, state.network.Name, formatBurnCoins(amount+decoded.FeeSats, 8))
 	if _, err := io.WriteString(cctx.App.Writer, preview); err != nil {
 		return fmt.Errorf("write the burn preview: %w", err)
 	}
-	if err := writeTransactionWarning(cctx.App.Writer, decoded.Msg.WarningMessage); err != nil {
+	if err := writeTransactionWarning(cctx.App.Writer, decoded.WarningMessage); err != nil {
 		return err
 	}
 	if !ready {
@@ -304,34 +306,34 @@ func runWalletBurnECX(cctx *cli.Context, client rpc.WalletManagerServiceClient,
 		return err
 	}
 	if inputPath == "" {
-		signed, err := client.SignPsbt(cctx.Context, connect.NewRequest(&pb.SignPsbtRequest{
+		signed, err := client.SignPsbt(cctx.Context, &pb.SignPsbtRequest{
 			WalletId: state.walletID, PsbtBase64: packet,
-		}))
+		})
 		if err != nil {
 			return fmt.Errorf("sign the burn transaction: %w", err)
 		}
 		if err := state.check(cctx, client, conf); err != nil {
 			return err
 		}
-		packet = signed.Msg.PsbtBase64
+		packet = signed.PsbtBase64
 	}
-	final, err := client.FinalizePsbt(cctx.Context, connect.NewRequest(&pb.FinalizePsbtRequest{PsbtBase64: packet}))
+	final, err := client.FinalizePsbt(cctx.Context, &pb.FinalizePsbtRequest{PsbtBase64: packet})
 	if err != nil {
 		return fmt.Errorf("finalize the burn transaction: %w", err)
 	}
 	if err := state.check(cctx, client, conf); err != nil {
 		return err
 	}
-	sent, err := client.BroadcastTransaction(cctx.Context, connect.NewRequest(&pb.BroadcastTransactionRequest{
-		WalletId: state.walletID, TxHex: final.Msg.RawTxHex,
-	}))
+	sent, err := client.BroadcastTransaction(cctx.Context, &pb.BroadcastTransactionRequest{
+		WalletId: state.walletID, TxHex: final.RawTxHex,
+	})
 	if err != nil {
 		return fmt.Errorf("broadcast the burn transaction: %w", err)
 	}
 	receipt := fmt.Sprintf("Burn sent: %s\nECX credit pending: %s ECX\nECX address: %s\nYour real ECX credit remains pending.\n",
-		sent.Msg.Txid, formatBurnCoins(creditSats, 8), address)
+		sent.Txid, formatBurnCoins(creditSats, 8), address)
 	if _, err := io.WriteString(cctx.App.Writer, receipt); err != nil {
-		return fmt.Errorf("write the receipt for %s: %w", sent.Msg.Txid, err)
+		return fmt.Errorf("write the receipt for %s: %w", sent.Txid, err)
 	}
 	return nil
 }
diff --git a/sidechain-orchestrator/commands/wallet_burn_ecx_test.go b/sidechain-orchestrator/commands/wallet_burn_ecx_test.go
index 83d2d0edf6..edb9931ee5 100644
--- a/sidechain-orchestrator/commands/wallet_burn_ecx_test.go
+++ b/sidechain-orchestrator/commands/wallet_burn_ecx_test.go
@@ -14,7 +14,8 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config/netcatalog"
 	confpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
 	confrpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect"
@@ -60,7 +61,7 @@ type burnTestDaemon struct {
 func (d *burnTestDaemon) step(name string) error {
 	d.calls = append(d.calls, name)
 	if d.fail == name {
-		return connect.NewError(connect.CodeUnavailable, errors.New("RPC failed"))
+		return connect.NewError(connect.CodeUnavailable, "RPC failed")
 	}
 	if change := d.after[name]; change != nil {
 		change()
@@ -69,39 +70,39 @@ func (d *burnTestDaemon) step(name string) error {
 	return nil
 }
 
-func (d *burnTestDaemon) ListNetworks(context.Context, *connect.Request[confpb.ListNetworksRequest]) (*connect.Response[confpb.ListNetworksResponse], error) {
+func (d *burnTestDaemon) ListNetworks(context.Context, *confpb.ListNetworksRequest) (*confpb.ListNetworksResponse, error) {
 	if err := d.step("network"); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&confpb.ListNetworksResponse{Networks: []*confpb.NetworkOption{
+	return &confpb.ListNetworksResponse{Networks: []*confpb.NetworkOption{
 		{Id: d.network, Network: "ecash", IsCurrent: true},
-	}}), nil
+	}}, nil
 }
 
-func (d *burnTestDaemon) GetWalletStatus(context.Context, *connect.Request[pb.GetWalletStatusRequest]) (*connect.Response[pb.GetWalletStatusResponse], error) {
+func (d *burnTestDaemon) GetWalletStatus(context.Context, *pb.GetWalletStatusRequest) (*pb.GetWalletStatusResponse, error) {
 	if err := d.step("status"); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(d.status), nil
+	return d.status, nil
 }
 
-func (d *burnTestDaemon) ListWallets(context.Context, *connect.Request[pb.ListWalletsRequest]) (*connect.Response[pb.ListWalletsResponse], error) {
+func (d *burnTestDaemon) ListWallets(context.Context, *pb.ListWalletsRequest) (*pb.ListWalletsResponse, error) {
 	if err := d.step("wallets"); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(d.wallets), nil
+	return d.wallets, nil
 }
 
-func (d *burnTestDaemon) DeriveAddresses(_ context.Context, req *connect.Request[pb.DeriveAddressesRequest]) (*connect.Response[pb.DeriveAddressesResponse], error) {
-	d.derived = proto.Clone(req.Msg).(*pb.DeriveAddressesRequest)
+func (d *burnTestDaemon) DeriveAddresses(_ context.Context, req *pb.DeriveAddressesRequest) (*pb.DeriveAddressesResponse, error) {
+	d.derived = proto.Clone(req).(*pb.DeriveAddressesRequest)
 	if err := d.step("derive"); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.DeriveAddressesResponse{Addresses: d.addresses}), nil
+	return &pb.DeriveAddressesResponse{Addresses: d.addresses}, nil
 }
 
-func (d *burnTestDaemon) CreatePsbt(_ context.Context, req *connect.Request[pb.CreatePsbtRequest]) (*connect.Response[pb.CreatePsbtResponse], error) {
-	d.created = proto.Clone(req.Msg).(*pb.CreatePsbtRequest)
+func (d *burnTestDaemon) CreatePsbt(_ context.Context, req *pb.CreatePsbtRequest) (*pb.CreatePsbtResponse, error) {
+	d.created = proto.Clone(req).(*pb.CreatePsbtRequest)
 	if err := d.step("create"); err != nil {
 		return nil, err
 	}
@@ -109,27 +110,27 @@ func (d *burnTestDaemon) CreatePsbt(_ context.Context, req *connect.Request[pb.C
 	if packet == "" {
 		packet = "unsigned-psbt"
 	}
-	return connect.NewResponse(&pb.CreatePsbtResponse{PsbtBase64: packet}), nil
+	return &pb.CreatePsbtResponse{PsbtBase64: packet}, nil
 }
 
-func (d *burnTestDaemon) CombinePsbt(_ context.Context, req *connect.Request[pb.CombinePsbtRequest]) (*connect.Response[pb.CombinePsbtResponse], error) {
-	d.combined = proto.Clone(req.Msg).(*pb.CombinePsbtRequest)
+func (d *burnTestDaemon) CombinePsbt(_ context.Context, req *pb.CombinePsbtRequest) (*pb.CombinePsbtResponse, error) {
+	d.combined = proto.Clone(req).(*pb.CombinePsbtRequest)
 	if err := d.step("combine"); err != nil {
 		return nil, err
 	}
 	packet := d.combinedPSBT
 	if packet == "" {
 		var err error
-		packet, err = (&wallet.ElectrumBackend{}).CombinePSBT(req.Msg.PsbtBase64)
+		packet, err = (&wallet.ElectrumBackend{}).CombinePSBT(req.PsbtBase64)
 		if err != nil {
-			return nil, err
+			return nil, connect.NewError(connect.CodeInternal, err.Error()).WithCause(err)
 		}
 	}
-	return connect.NewResponse(&pb.CombinePsbtResponse{PsbtBase64: packet}), nil
+	return &pb.CombinePsbtResponse{PsbtBase64: packet}, nil
 }
 
-func (d *burnTestDaemon) MultisigPsbtStatus(_ context.Context, req *connect.Request[pb.MultisigPsbtStatusRequest]) (*connect.Response[pb.MultisigPsbtStatusResponse], error) {
-	d.signatureRequest = proto.Clone(req.Msg).(*pb.MultisigPsbtStatusRequest)
+func (d *burnTestDaemon) MultisigPsbtStatus(_ context.Context, req *pb.MultisigPsbtStatusRequest) (*pb.MultisigPsbtStatusResponse, error) {
+	d.signatureRequest = proto.Clone(req).(*pb.MultisigPsbtStatusRequest)
 	if err := d.step("signatures"); err != nil {
 		return nil, err
 	}
@@ -137,19 +138,19 @@ func (d *burnTestDaemon) MultisigPsbtStatus(_ context.Context, req *connect.Requ
 	if status == nil {
 		status = &pb.MultisigPsbtStatusResponse{Threshold: 2}
 	}
-	return connect.NewResponse(status), nil
+	return status, nil
 }
 
-func (d *burnTestDaemon) DecodeTransaction(_ context.Context, req *connect.Request[pb.DecodeTransactionRequest]) (*connect.Response[pb.DecodeTransactionResponse], error) {
-	d.decoded = proto.Clone(req.Msg).(*pb.DecodeTransactionRequest)
+func (d *burnTestDaemon) DecodeTransaction(_ context.Context, req *pb.DecodeTransactionRequest) (*pb.DecodeTransactionResponse, error) {
+	d.decoded = proto.Clone(req).(*pb.DecodeTransactionRequest)
 	if err := d.step("decode"); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(d.preview), nil
+	return d.preview, nil
 }
 
-func (d *burnTestDaemon) SignPsbt(_ context.Context, req *connect.Request[pb.SignPsbtRequest]) (*connect.Response[pb.SignPsbtResponse], error) {
-	d.signed = proto.Clone(req.Msg).(*pb.SignPsbtRequest)
+func (d *burnTestDaemon) SignPsbt(_ context.Context, req *pb.SignPsbtRequest) (*pb.SignPsbtResponse, error) {
+	d.signed = proto.Clone(req).(*pb.SignPsbtRequest)
 	if err := d.step("sign"); err != nil {
 		return nil, err
 	}
@@ -157,23 +158,23 @@ func (d *burnTestDaemon) SignPsbt(_ context.Context, req *connect.Request[pb.Sig
 	if packet == "" {
 		packet = "signed-psbt"
 	}
-	return connect.NewResponse(&pb.SignPsbtResponse{PsbtBase64: packet}), nil
+	return &pb.SignPsbtResponse{PsbtBase64: packet}, nil
 }
 
-func (d *burnTestDaemon) FinalizePsbt(_ context.Context, req *connect.Request[pb.FinalizePsbtRequest]) (*connect.Response[pb.FinalizePsbtResponse], error) {
-	d.finalized = proto.Clone(req.Msg).(*pb.FinalizePsbtRequest)
+func (d *burnTestDaemon) FinalizePsbt(_ context.Context, req *pb.FinalizePsbtRequest) (*pb.FinalizePsbtResponse, error) {
+	d.finalized = proto.Clone(req).(*pb.FinalizePsbtRequest)
 	if err := d.step("finalize"); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.FinalizePsbtResponse{RawTxHex: "final-transaction"}), nil
+	return &pb.FinalizePsbtResponse{RawTxHex: "final-transaction"}, nil
 }
 
-func (d *burnTestDaemon) BroadcastTransaction(_ context.Context, req *connect.Request[pb.BroadcastTransactionRequest]) (*connect.Response[pb.BroadcastTransactionResponse], error) {
-	d.broadcast = proto.Clone(req.Msg).(*pb.BroadcastTransactionRequest)
+func (d *burnTestDaemon) BroadcastTransaction(_ context.Context, req *pb.BroadcastTransactionRequest) (*pb.BroadcastTransactionResponse, error) {
+	d.broadcast = proto.Clone(req).(*pb.BroadcastTransactionRequest)
 	if err := d.step("broadcast"); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.BroadcastTransactionResponse{Txid: "burn-txid"}), nil
+	return &pb.BroadcastTransactionResponse{Txid: "burn-txid"}, nil
 }
 
 type burnTestFlow struct {
@@ -217,10 +218,10 @@ func newBurnTestFlow(t *testing.T, args ...string) *burnTestFlow {
 		after: map[string]func(){},
 	}
 	mux := http.NewServeMux()
-	path, handler := rpc.NewWalletManagerServiceHandler(daemon)
-	mux.Handle(path, handler)
-	path, handler = confrpc.NewBitcoinConfServiceHandler(daemon)
-	mux.Handle(path, handler)
+	rpcServer := connect.NewServer()
+	rpc.RegisterWalletManagerServiceHandler(rpcServer, daemon)
+	confrpc.RegisterBitcoinConfServiceHandler(rpcServer, daemon)
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
 	set := flag.NewFlagSet("burn-ecx", flag.ContinueOnError)
@@ -234,8 +235,8 @@ func newBurnTestFlow(t *testing.T, args ...string) *burnTestFlow {
 	ctx.Context = context.Background()
 	return &burnTestFlow{
 		ctx: ctx, daemon: daemon, output: output,
-		client: rpc.NewWalletManagerServiceClient(server.Client(), server.URL),
-		conf:   confrpc.NewBitcoinConfServiceClient(server.Client(), server.URL),
+		client: rpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0)))),
+		conf:   confrpc.NewBitcoinConfServiceClient(connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0)))),
 	}
 }
 
diff --git a/sidechain-orchestrator/commands/wallet_sign_psbt.go b/sidechain-orchestrator/commands/wallet_sign_psbt.go
index 9e8545d417..f5c09537f9 100644
--- a/sidechain-orchestrator/commands/wallet_sign_psbt.go
+++ b/sidechain-orchestrator/commands/wallet_sign_psbt.go
@@ -8,7 +8,6 @@ import (
 	"os"
 	"strings"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
@@ -54,12 +53,12 @@ func runWalletSignPSBT(cctx *cli.Context, client rpc.WalletManagerServiceClient)
 	if err != nil {
 		return err
 	}
-	wallets, err := client.ListWallets(cctx.Context, connect.NewRequest(&pb.ListWalletsRequest{}))
+	wallets, err := client.ListWallets(cctx.Context, &pb.ListWalletsRequest{})
 	if err != nil {
 		return fmt.Errorf("read the wallets: %w", err)
 	}
 	var selected *pb.WalletMetadata
-	for _, wallet := range wallets.Msg.Wallets {
+	for _, wallet := range wallets.Wallets {
 		if wallet.Id == walletID {
 			selected = wallet
 			break
@@ -75,17 +74,17 @@ func runWalletSignPSBT(cctx *cli.Context, client rpc.WalletManagerServiceClient)
 		(selected.WatchOnly || selected.HardwareDeviceType != "" || selected.HardwareFingerprint != "") {
 		return fmt.Errorf("use a Bitcoin Core wallet with local private keys to sign this PSBT")
 	}
-	decoded, err := client.DecodeTransaction(cctx.Context, connect.NewRequest(&pb.DecodeTransactionRequest{
+	decoded, err := client.DecodeTransaction(cctx.Context, &pb.DecodeTransactionRequest{
 		WalletId: walletID, Input: packet,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("read the PSBT transaction: %w", err)
 	}
-	if !decoded.Msg.IsPsbt || !decoded.Msg.HasFee || decoded.Msg.FeeSats < 0 {
+	if !decoded.IsPsbt || !decoded.HasFee || decoded.FeeSats < 0 {
 		return fmt.Errorf("the PSBT has no exact network fee")
 	}
 	preview := fmt.Sprintf("Sign PSBT\nWallet: %s\n", walletID)
-	for _, output := range decoded.Msg.Outputs {
+	for _, output := range decoded.Outputs {
 		preview += fmt.Sprintf("Output %d: %d satoshis\n", output.Index, output.ValueSats)
 		if output.Address != "" {
 			preview += fmt.Sprintf("  Address: %s\n", output.Address)
@@ -109,11 +108,11 @@ func runWalletSignPSBT(cctx *cli.Context, client rpc.WalletManagerServiceClient)
 			preview += fmt.Sprintf("  Script: %s\n", output.ScriptPubkeyAsm)
 		}
 	}
-	preview += fmt.Sprintf("Network fee: %d satoshis\n", decoded.Msg.FeeSats)
+	preview += fmt.Sprintf("Network fee: %d satoshis\n", decoded.FeeSats)
 	if _, err := io.WriteString(cctx.App.Writer, preview); err != nil {
 		return fmt.Errorf("write the PSBT preview: %w", err)
 	}
-	if err := writeTransactionWarning(cctx.App.Writer, decoded.Msg.WarningMessage); err != nil {
+	if err := writeTransactionWarning(cctx.App.Writer, decoded.WarningMessage); err != nil {
 		return err
 	}
 	if !cctx.Bool("yes") {
@@ -129,13 +128,13 @@ func runWalletSignPSBT(cctx *cli.Context, client rpc.WalletManagerServiceClient)
 			return fmt.Errorf("you did not approve the signatures")
 		}
 	}
-	signed, err := client.SignPsbt(cctx.Context, connect.NewRequest(&pb.SignPsbtRequest{
+	signed, err := client.SignPsbt(cctx.Context, &pb.SignPsbtRequest{
 		WalletId: walletID, PsbtBase64: packet,
-	}))
+	})
 	if err != nil {
 		return fmt.Errorf("sign the PSBT: %w", err)
 	}
-	if err := writePSBTFile(outputPath, signed.Msg.PsbtBase64); err != nil {
+	if err := writePSBTFile(outputPath, signed.PsbtBase64); err != nil {
 		return err
 	}
 	if _, err := fmt.Fprintf(cctx.App.Writer, "PSBT file: %s\nThe command did not broadcast the transaction.\n", outputPath); err != nil {
diff --git a/sidechain-orchestrator/commands/wallet_status_test.go b/sidechain-orchestrator/commands/wallet_status_test.go
index 02bbf54fa2..15facbdd9c 100644
--- a/sidechain-orchestrator/commands/wallet_status_test.go
+++ b/sidechain-orchestrator/commands/wallet_status_test.go
@@ -1,6 +1,8 @@
 package commands
 
 import (
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"context"
 	"flag"
 	"io"
@@ -10,7 +12,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect"
 	"github.com/stretchr/testify/require"
@@ -22,20 +23,21 @@ type statusTestDaemon struct {
 	generated *pb.GenerateWalletRequest
 }
 
-func (d *statusTestDaemon) GetWalletStatus(context.Context, *connect.Request[pb.GetWalletStatusRequest]) (*connect.Response[pb.GetWalletStatusResponse], error) {
-	return connect.NewResponse(&pb.GetWalletStatusResponse{State: pb.WalletState_WALLET_STATE_NO_WALLET}), nil
+func (d *statusTestDaemon) GetWalletStatus(context.Context, *pb.GetWalletStatusRequest) (*pb.GetWalletStatusResponse, error) {
+	return &pb.GetWalletStatusResponse{State: pb.WalletState_WALLET_STATE_NO_WALLET}, nil
 }
 
-func (d *statusTestDaemon) GenerateWallet(_ context.Context, req *connect.Request[pb.GenerateWalletRequest]) (*connect.Response[pb.GenerateWalletResponse], error) {
-	d.generated = req.Msg
-	return connect.NewResponse(&pb.GenerateWalletResponse{WalletId: "new-wallet"}), nil
+func (d *statusTestDaemon) GenerateWallet(_ context.Context, req *pb.GenerateWalletRequest) (*pb.GenerateWalletResponse, error) {
+	d.generated = req
+	return &pb.GenerateWalletResponse{WalletId: "new-wallet"}, nil
 }
 
 func TestWalletStatusCreatesCoreWalletWhenNoneExists(t *testing.T) {
 	daemon := &statusTestDaemon{}
 	mux := http.NewServeMux()
-	path, handler := rpc.NewWalletManagerServiceHandler(daemon)
-	mux.Handle(path, handler)
+	rpcServer := connect.NewServer()
+	rpc.RegisterWalletManagerServiceHandler(rpcServer, daemon)
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewServer(mux)
 	t.Cleanup(server.Close)
 
diff --git a/sidechain-orchestrator/engines/bmm_engine.go b/sidechain-orchestrator/engines/bmm_engine.go
index 7cbe35a677..0e88c5db4b 100644
--- a/sidechain-orchestrator/engines/bmm_engine.go
+++ b/sidechain-orchestrator/engines/bmm_engine.go
@@ -7,7 +7,7 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/engines/bmmstate"
@@ -81,10 +81,10 @@ type BmmBackend interface {
 	// Mined reports whether a block carries txid, one that MempoolTxids named.
 	// It reads a live source.
 	Mined(ctx context.Context, txid string) (bool, error)
-	CreateBid(context.Context, *connect.Request[bmmpb.CreateBidRequest]) (*connect.Response[bmmpb.CreateBidResponse], error)
-	ConnectBid(context.Context, *connect.Request[bmmpb.ConnectBidRequest]) (*connect.Response[bmmpb.ConnectBidResponse], error)
-	ListBids(context.Context, *connect.Request[bmmpb.ListBidsRequest]) (*connect.Response[bmmpb.ListBidsResponse], error)
-	PrepareBMM(context.Context, *connect.Request[bmmpb.PrepareBMMRequest]) (*connect.Response[bmmpb.PrepareBMMResponse], error)
+	CreateBid(context.Context, *bmmpb.CreateBidRequest) (*bmmpb.CreateBidResponse, error)
+	ConnectBid(context.Context, *bmmpb.ConnectBidRequest) (*bmmpb.ConnectBidResponse, error)
+	ListBids(context.Context, *bmmpb.ListBidsRequest) (*bmmpb.ListBidsResponse, error)
+	PrepareBMM(context.Context, *bmmpb.PrepareBMMRequest) (*bmmpb.PrepareBMMResponse, error)
 	// Commitment reports the sidechain block hash a mainchain block committed
 	// to for this sidechain, empty when it carried none.
 	Commitment(ctx context.Context, sidechain pb.BinaryType, mainBlockHash string) (string, error)
@@ -260,7 +260,7 @@ func (e *BmmEngine) prepareCoins(ctx context.Context) bool {
 	if len(targets) == 0 {
 		return false
 	}
-	resp, err := e.backend.PrepareBMM(ctx, connect.NewRequest(&bmmpb.PrepareBMMRequest{Targets: targets}))
+	resp, err := e.backend.PrepareBMM(ctx, &bmmpb.PrepareBMMRequest{Targets: targets})
 	if err != nil {
 		// A wallet that cannot make the coins still bids: every round that finds
 		// no coin of its own says so on the round itself.
@@ -268,7 +268,7 @@ func (e *BmmEngine) prepareCoins(ctx context.Context) bool {
 		return false
 	}
 	ready := true
-	for _, w := range resp.Msg.Wallets {
+	for _, w := range resp.Wallets {
 		if w.UsableCoins < w.WantedCoins {
 			// A split the mempool drops leaves the wallet short again, so the tip
 			// counts once more.
@@ -898,18 +898,18 @@ func (e *BmmEngine) retryTip(sidechain pb.BinaryType, tip string) {
 // snapshotOthers records the competing bids. Once the round is decided these
 // are unrecoverable, so this is the only chance to see them.
 func (e *BmmEngine) snapshotOthers(ctx context.Context, sidechain pb.BinaryType, tip string) []bmmstate.Bid {
-	resp, err := e.backend.ListBids(ctx, connect.NewRequest(&bmmpb.ListBidsRequest{
+	resp, err := e.backend.ListBids(ctx, &bmmpb.ListBidsRequest{
 		Sidechain:    sidechain,
 		PrevMainHash: tip,
-	}))
+	})
 	if err != nil {
 		e.log.Debug().Err(err).Stringer("sidechain", sidechain).Msg("read competing bids")
 		return nil
 	}
 
 	ours := e.ourTxids(sidechain)
-	out := make([]bmmstate.Bid, 0, len(resp.Msg.Bids))
-	for _, b := range resp.Msg.Bids {
+	out := make([]bmmstate.Bid, 0, len(resp.Bids))
+	for _, b := range resp.Bids {
 		if ours[b.Txid] {
 			continue
 		}
@@ -949,7 +949,7 @@ func (e *BmmEngine) placeBid(
 	if e.networkMoved() {
 		return errNetworkMoved
 	}
-	resp, err := e.backend.CreateBid(ctx, connect.NewRequest(&bmmpb.CreateBidRequest{
+	resp, err := e.backend.CreateBid(ctx, &bmmpb.CreateBidRequest{
 		Sidechain:          sidechain,
 		WalletId:           walletID,
 		BidSats:            bidSats,
@@ -958,7 +958,7 @@ func (e *BmmEngine) placeBid(
 		ReplaceTxid:        replaceTxid,
 		ExpectPrevMainHash: round.PrevMainHash,
 		CapToBlockWorth:    capToBlockWorth,
-	}))
+	})
 
 	e.mu.Lock()
 	defer e.mu.Unlock()
@@ -976,29 +976,29 @@ func (e *BmmEngine) placeBid(
 	if replaceTxid != "" {
 		for i := range round.OurBids {
 			if round.OurBids[i].Txid == replaceTxid {
-				round.OurBids[i].ReplacedByTxid = resp.Msg.BmmTxid
+				round.OurBids[i].ReplacedByTxid = resp.BmmTxid
 				round.OurBids[i].State = BidReplaced
 			}
 		}
 	}
 
-	round.BlockWorthSats = resp.Msg.FeesSats
-	if resp.Msg.BidSats > 0 {
-		bidSats = resp.Msg.BidSats
+	round.BlockWorthSats = resp.FeesSats
+	if resp.BidSats > 0 {
+		bidSats = resp.BidSats
 	}
 	round.OurBids = append(round.OurBids, bmmstate.Bid{
-		Txid:         resp.Msg.BmmTxid,
-		CriticalHash: resp.Msg.CriticalHash,
-		PrevMainHash: resp.Msg.PrevMainHash,
+		Txid:         resp.BmmTxid,
+		CriticalHash: resp.CriticalHash,
+		PrevMainHash: resp.PrevMainHash,
 		BidSats:      bidSats,
 		IsOurs:       true,
 		State:        BidLive,
-		BlockJSON:    resp.Msg.BlockJson,
+		BlockJSON:    resp.BlockJson,
 		WalletID:     walletID,
 	})
 
-	e.log.Info().Stringer("sidechain", sidechain).Str("txid", resp.Msg.BmmTxid).
-		Int64("bid_sats", bidSats).Int64("block_worth_sats", resp.Msg.FeesSats).Msg("bmm bid broadcast")
+	e.log.Info().Stringer("sidechain", sidechain).Str("txid", resp.BmmTxid).
+		Int64("bid_sats", bidSats).Int64("block_worth_sats", resp.FeesSats).Msg("bmm bid broadcast")
 	return nil
 }
 
@@ -1429,12 +1429,12 @@ func (e *BmmEngine) connectWon(
 	if live == nil {
 		return stepRetry
 	}
-	resp, err := e.backend.ConnectBid(ctx, connect.NewRequest(&bmmpb.ConnectBidRequest{
+	resp, err := e.backend.ConnectBid(ctx, &bmmpb.ConnectBidRequest{
 		Sidechain:     sidechain,
 		CriticalHash:  live.CriticalHash,
 		BlockJson:     live.BlockJSON,
 		MainBlockHash: round.IncludedInBlock,
-	}))
+	})
 	if err != nil {
 		if connect.CodeOf(err) == connect.CodeInvalidArgument {
 			e.log.Warn().Err(err).Stringer("sidechain", sidechain).
@@ -1445,14 +1445,14 @@ func (e *BmmEngine) connectWon(
 			Str("critical_hash", live.CriticalHash).Msg("connect won block")
 		return stepRetry
 	}
-	if !resp.Msg.Connected && !resp.Msg.Held {
-		if resp.Msg.MainBlockHash == "" {
+	if !resp.Connected && !resp.Held {
+		if resp.MainBlockHash == "" {
 			e.log.Debug().Stringer("sidechain", sidechain).Str("critical_hash", live.CriticalHash).
 				Msg("the sidechain has not seen the bid included yet")
 			return stepRetry
 		}
 		e.log.Warn().Stringer("sidechain", sidechain).Str("critical_hash", live.CriticalHash).
-			Str("main_block", resp.Msg.MainBlockHash).Msg("the sidechain did not connect the won block")
+			Str("main_block", resp.MainBlockHash).Msg("the sidechain did not connect the won block")
 		return stepRetire
 	}
 	live.State = BidConnected
@@ -1460,8 +1460,8 @@ func (e *BmmEngine) connectWon(
 	round.WinnerCriticalHash = live.CriticalHash
 	round.WinnerTxid = live.Txid
 	round.WinnerBidSats = live.BidSats
-	if resp.Msg.MainBlockHash != "" {
-		round.IncludedInBlock = resp.Msg.MainBlockHash
+	if resp.MainBlockHash != "" {
+		round.IncludedInBlock = resp.MainBlockHash
 	}
 	return stepDone
 }
diff --git a/sidechain-orchestrator/engines/bmm_engine_test.go b/sidechain-orchestrator/engines/bmm_engine_test.go
index 010d1c2c76..9479447ea3 100644
--- a/sidechain-orchestrator/engines/bmm_engine_test.go
+++ b/sidechain-orchestrator/engines/bmm_engine_test.go
@@ -10,7 +10,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/rs/zerolog"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
@@ -64,85 +64,85 @@ type fakeBackend struct {
 }
 
 func (f *fakeBackend) CreateBid(
-	_ context.Context, req *connect.Request[bmmpb.CreateBidRequest],
-) (*connect.Response[bmmpb.CreateBidResponse], error) {
+	_ context.Context, req *bmmpb.CreateBidRequest,
+) (*bmmpb.CreateBidResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	if f.bidErr != nil {
 		return nil, f.bidErr
 	}
 	f.bids++
-	f.lastReplace = req.Msg.ReplaceTxid
-	f.lastBidSats = req.Msg.BidSats
-	bid := req.Msg.BidSats
+	f.lastReplace = req.ReplaceTxid
+	f.lastBidSats = req.BidSats
+	bid := req.BidSats
 	// A rate-sized bid costs whatever the wallet builds. The real handler
 	// reads that back off the chain, so the fake reports it too.
-	if bid == 0 && req.Msg.FeeRateSatVb > 0 {
-		bid = int64(math.Ceil(req.Msg.FeeRateSatVb * fakeBidVsize))
+	if bid == 0 && req.FeeRateSatVb > 0 {
+		bid = int64(math.Ceil(req.FeeRateSatVb * fakeBidVsize))
 	}
-	if req.Msg.CapToBlockWorth && f.feesSats > 0 && bid > f.feesSats {
+	if req.CapToBlockWorth && f.feesSats > 0 && bid > f.feesSats {
 		bid = f.feesSats
 	}
-	if req.Msg.MaxBidSats > 0 && bid > req.Msg.MaxBidSats {
-		bid = req.Msg.MaxBidSats
+	if req.MaxBidSats > 0 && bid > req.MaxBidSats {
+		bid = req.MaxBidSats
 	}
 	f.lastBidSats = bid
-	f.lastExpectTip = req.Msg.ExpectPrevMainHash
-	f.lastWalletID = req.Msg.WalletId
-	f.lastFeeRate = req.Msg.FeeRateSatVb
-	return connect.NewResponse(&bmmpb.CreateBidResponse{
+	f.lastExpectTip = req.ExpectPrevMainHash
+	f.lastWalletID = req.WalletId
+	f.lastFeeRate = req.FeeRateSatVb
+	return &bmmpb.CreateBidResponse{
 		CriticalHash: "critical",
 		BmmTxid:      "txid-" + string(rune('0'+f.bids)),
 		FeesSats:     f.feesSats,
 		BlockJson:    "side:" + f.sideTip,
-		PrevMainHash: req.Msg.ExpectPrevMainHash,
+		PrevMainHash: req.ExpectPrevMainHash,
 		BidSats:      bid,
-	}), nil
+	}, nil
 }
 
 func (f *fakeBackend) ConnectBid(
-	_ context.Context, req *connect.Request[bmmpb.ConnectBidRequest],
-) (*connect.Response[bmmpb.ConnectBidResponse], error) {
+	_ context.Context, req *bmmpb.ConnectBidRequest,
+) (*bmmpb.ConnectBidResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.connects++
-	f.lastMainBlockHash = req.Msg.MainBlockHash
+	f.lastMainBlockHash = req.MainBlockHash
 	if f.connectErr != nil {
 		return nil, f.connectErr
 	}
 	// The handler names no block while the sidechain reports no inclusion for
 	// the critical hash.
 	if f.noInclusion {
-		return connect.NewResponse(&bmmpb.ConnectBidResponse{}), nil
+		return &bmmpb.ConnectBidResponse{}, nil
 	}
 	// The handler echoes the block it connected on, resolving it itself only
 	// when the caller named none.
-	main := req.Msg.MainBlockHash
+	main := req.MainBlockHash
 	if main == "" {
 		main = "mainblock"
 	}
-	return connect.NewResponse(&bmmpb.ConnectBidResponse{
+	return &bmmpb.ConnectBidResponse{
 		Connected:     f.connected,
 		MainBlockHash: main,
 		Held:          f.held,
-	}), nil
+	}, nil
 }
 
 // ListBids answers for one parent block, as the enforcer does.
 func (f *fakeBackend) ListBids(
-	_ context.Context, req *connect.Request[bmmpb.ListBidsRequest],
-) (*connect.Response[bmmpb.ListBidsResponse], error) {
+	_ context.Context, req *bmmpb.ListBidsRequest,
+) (*bmmpb.ListBidsResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	bids := make([]*bmmpb.Bid, 0, len(f.others))
 	for _, bid := range f.others {
-		if req.Msg.PrevMainHash != "" && bid.PrevMainHash != "" &&
-			bid.PrevMainHash != req.Msg.PrevMainHash {
+		if req.PrevMainHash != "" && bid.PrevMainHash != "" &&
+			bid.PrevMainHash != req.PrevMainHash {
 			continue
 		}
 		bids = append(bids, bid)
 	}
-	return connect.NewResponse(&bmmpb.ListBidsResponse{Bids: bids}), nil
+	return &bmmpb.ListBidsResponse{Bids: bids}, nil
 }
 
 func (f *fakeBackend) MempoolTxids(_ context.Context, walletIDs []string) (map[string]bool, error) {
@@ -167,28 +167,28 @@ func (f *fakeBackend) Mined(_ context.Context, txid string) (bool, error) {
 }
 
 func (f *fakeBackend) PrepareBMM(
-	_ context.Context, req *connect.Request[bmmpb.PrepareBMMRequest],
-) (*connect.Response[bmmpb.PrepareBMMResponse], error) {
+	_ context.Context, req *bmmpb.PrepareBMMRequest,
+) (*bmmpb.PrepareBMMResponse, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.prepares++
-	f.lastPrepare = req.Msg
+	f.lastPrepare = req
 	if f.prepareErr != nil {
 		return nil, f.prepareErr
 	}
-	wanted := int32(len(req.Msg.Targets))
+	wanted := int32(len(req.Targets))
 	usable := wanted
 	if f.shortCoins {
 		usable = wanted - 1
 	}
-	return connect.NewResponse(&bmmpb.PrepareBMMResponse{
+	return &bmmpb.PrepareBMMResponse{
 		Wallets: []*bmmpb.PrepareBMMWallet{{
-			WalletId:    req.Msg.Targets[0].WalletId,
+			WalletId:    req.Targets[0].WalletId,
 			UsableCoins: usable,
 			WantedCoins: wanted,
 			SplitTxid:   f.splitTxid,
 		}},
-	}), nil
+	}, nil
 }
 
 func (f *fakeBackend) Commitment(_ context.Context, _ pb.BinaryType, main string) (string, error) {
@@ -1154,7 +1154,7 @@ func TestBmmEngineDoesNotSettleAnOpenRoundOnStop(t *testing.T) {
 // a round every time the enforcer catches up mid-tick.
 func TestBmmEngineRetriesAfterAPreconditionRefusal(t *testing.T) {
 	engine, backend, _, _ := newEngine(t)
-	backend.bidErr = connect.NewError(connect.CodeFailedPrecondition, errors.New("enforcer is still syncing"))
+	backend.bidErr = connect.NewError(connect.CodeFailedPrecondition, "enforcer is still syncing")
 	require.NoError(t, engine.Start(context.Background(), testSidechain, "", 10_000, false))
 
 	ctx := context.Background()
@@ -1554,7 +1554,7 @@ func TestBmmEngineRetriesWhenTheHeldCheckFails(t *testing.T) {
 func TestBmmEngineRetiresABlockTheSidechainCannotDecode(t *testing.T) {
 	engine, backend, _, _ := newEngine(t)
 	backend.connectErr = connect.NewError(connect.CodeInvalidArgument,
-		errors.New("connect block: rpc error -32602: Invalid params"))
+		"connect block: rpc error -32602: Invalid params")
 
 	round := unconnectedRound("undecodable-round", 996770)
 	engine.mu.Lock()
@@ -2097,7 +2097,7 @@ func TestBmmEngineRetriesARefusedFeeRebuildOnlyWhenTheFeesRiseAgain(t *testing.T
 	require.Equal(t, 1, backend.bids)
 
 	backend.feesSats = 13_500
-	backend.bidErr = connect.NewError(connect.CodeFailedPrecondition, errors.New("over the ceiling"))
+	backend.bidErr = connect.NewError(connect.CodeFailedPrecondition, "over the ceiling")
 	engine.tick(ctx)
 	engine.tick(ctx)
 
diff --git a/sidechain-orchestrator/gen/bbc/v1/bbcv1connect/bbc.connect.go b/sidechain-orchestrator/gen/bbc/v1/bbcv1connect/bbc.connect.go
index 3454512df8..0284a2e982 100644
--- a/sidechain-orchestrator/gen/bbc/v1/bbcv1connect/bbc.connect.go
+++ b/sidechain-orchestrator/gen/bbc/v1/bbcv1connect/bbc.connect.go
@@ -5,413 +5,456 @@
 package bbcv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bbc/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BbcServiceName is the fully-qualified name of the BbcService service.
 	BbcServiceName = "bbc.v1.BbcService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BbcServiceGetBlockCountProcedure is the fully-qualified name of the BbcService's GetBlockCount
-	// RPC.
+	// BbcServiceGetBlockCountProcedure is the procedure name of the BbcService's GetBlockCount RPC.
 	BbcServiceGetBlockCountProcedure = "/bbc.v1.BbcService/GetBlockCount"
-	// BbcServiceGetBlockchainInfoProcedure is the fully-qualified name of the BbcService's
-	// GetBlockchainInfo RPC.
+	// BbcServiceGetBlockchainInfoProcedure is the procedure name of the BbcService's GetBlockchainInfo
+	// RPC.
 	BbcServiceGetBlockchainInfoProcedure = "/bbc.v1.BbcService/GetBlockchainInfo"
-	// BbcServiceGetSidechainInfoProcedure is the fully-qualified name of the BbcService's
-	// GetSidechainInfo RPC.
+	// BbcServiceGetSidechainInfoProcedure is the procedure name of the BbcService's GetSidechainInfo
+	// RPC.
 	BbcServiceGetSidechainInfoProcedure = "/bbc.v1.BbcService/GetSidechainInfo"
-	// BbcServiceGetMainchainTipProcedure is the fully-qualified name of the BbcService's
-	// GetMainchainTip RPC.
+	// BbcServiceGetMainchainTipProcedure is the procedure name of the BbcService's GetMainchainTip RPC.
 	BbcServiceGetMainchainTipProcedure = "/bbc.v1.BbcService/GetMainchainTip"
-	// BbcServiceGetBmmCommitmentProcedure is the fully-qualified name of the BbcService's
-	// GetBmmCommitment RPC.
-	BbcServiceGetBmmCommitmentProcedure = "/bbc.v1.BbcService/GetBmmCommitment"
-	// BbcServiceGetNewAddressProcedure is the fully-qualified name of the BbcService's GetNewAddress
+	// BbcServiceGetBmmCommitmentProcedure is the procedure name of the BbcService's GetBmmCommitment
 	// RPC.
+	BbcServiceGetBmmCommitmentProcedure = "/bbc.v1.BbcService/GetBmmCommitment"
+	// BbcServiceGetNewAddressProcedure is the procedure name of the BbcService's GetNewAddress RPC.
 	BbcServiceGetNewAddressProcedure = "/bbc.v1.BbcService/GetNewAddress"
-	// BbcServiceSendProcedure is the fully-qualified name of the BbcService's Send RPC.
+	// BbcServiceSendProcedure is the procedure name of the BbcService's Send RPC.
 	BbcServiceSendProcedure = "/bbc.v1.BbcService/Send"
-	// BbcServiceEstimateFeeProcedure is the fully-qualified name of the BbcService's EstimateFee RPC.
+	// BbcServiceEstimateFeeProcedure is the procedure name of the BbcService's EstimateFee RPC.
 	BbcServiceEstimateFeeProcedure = "/bbc.v1.BbcService/EstimateFee"
-	// BbcServiceListUtxosProcedure is the fully-qualified name of the BbcService's ListUtxos RPC.
+	// BbcServiceListUtxosProcedure is the procedure name of the BbcService's ListUtxos RPC.
 	BbcServiceListUtxosProcedure = "/bbc.v1.BbcService/ListUtxos"
-	// BbcServiceListTransactionsProcedure is the fully-qualified name of the BbcService's
-	// ListTransactions RPC.
+	// BbcServiceListTransactionsProcedure is the procedure name of the BbcService's ListTransactions
+	// RPC.
 	BbcServiceListTransactionsProcedure = "/bbc.v1.BbcService/ListTransactions"
-	// BbcServiceStopProcedure is the fully-qualified name of the BbcService's Stop RPC.
+	// BbcServiceStopProcedure is the procedure name of the BbcService's Stop RPC.
 	BbcServiceStopProcedure = "/bbc.v1.BbcService/Stop"
 )
 
+var (
+	bbcServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("GetBlockCount"),
+			Procedure:  BbcServiceGetBlockCountProcedure,
+		}
+	})
+	bbcServiceGetBlockchainInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("GetBlockchainInfo"),
+			Procedure:  BbcServiceGetBlockchainInfoProcedure,
+		}
+	})
+	bbcServiceGetSidechainInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("GetSidechainInfo"),
+			Procedure:  BbcServiceGetSidechainInfoProcedure,
+		}
+	})
+	bbcServiceGetMainchainTipSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("GetMainchainTip"),
+			Procedure:  BbcServiceGetMainchainTipProcedure,
+		}
+	})
+	bbcServiceGetBmmCommitmentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("GetBmmCommitment"),
+			Procedure:  BbcServiceGetBmmCommitmentProcedure,
+		}
+	})
+	bbcServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("GetNewAddress"),
+			Procedure:  BbcServiceGetNewAddressProcedure,
+		}
+	})
+	bbcServiceSendSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("Send"),
+			Procedure:  BbcServiceSendProcedure,
+		}
+	})
+	bbcServiceEstimateFeeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("EstimateFee"),
+			Procedure:  BbcServiceEstimateFeeProcedure,
+		}
+	})
+	bbcServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("ListUtxos"),
+			Procedure:  BbcServiceListUtxosProcedure,
+		}
+	})
+	bbcServiceListTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("ListTransactions"),
+			Procedure:  BbcServiceListTransactionsProcedure,
+		}
+	})
+	bbcServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods().ByName("Stop"),
+			Procedure:  BbcServiceStopProcedure,
+		}
+	})
+)
+
 // BbcServiceClient is a client for the bbc.v1.BbcService service.
 type BbcServiceClient interface {
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Get the node's chain state.
-	GetBlockchainInfo(context.Context, *connect.Request[v1.GetBlockchainInfoRequest]) (*connect.Response[v1.GetBlockchainInfoResponse], error)
-	// Report whether the node has caught up with the mainchain.
-	GetSidechainInfo(context.Context, *connect.Request[v1.GetSidechainInfoRequest]) (*connect.Response[v1.GetSidechainInfoResponse], error)
-	// Get the mainchain block hash the node is following.
-	GetMainchainTip(context.Context, *connect.Request[v1.GetMainchainTipRequest]) (*connect.Response[v1.GetMainchainTipResponse], error)
-	// Get the sidechain block a mainchain block commits to, empty when none.
-	GetBmmCommitment(context.Context, *connect.Request[v1.GetBmmCommitmentRequest]) (*connect.Response[v1.GetBmmCommitmentResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Send to a sidechain address.
-	Send(context.Context, *connect.Request[v1.SendRequest]) (*connect.Response[v1.SendResponse], error)
-	// Estimate the fee rate in sats per kvB.
-	EstimateFee(context.Context, *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error)
-	// List wallet UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// List wallet transactions, most recent first.
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	// Stop the node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-}
-
-// NewBbcServiceClient constructs a client for the bbc.v1.BbcService service. By default, it uses
-// the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBbcServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BbcServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	bbcServiceMethods := v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods()
-	return &bbcServiceClient{
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+BbcServiceGetBlockCountProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockchainInfo: connect.NewClient[v1.GetBlockchainInfoRequest, v1.GetBlockchainInfoResponse](
-			httpClient,
-			baseURL+BbcServiceGetBlockchainInfoProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("GetBlockchainInfo")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainInfo: connect.NewClient[v1.GetSidechainInfoRequest, v1.GetSidechainInfoResponse](
-			httpClient,
-			baseURL+BbcServiceGetSidechainInfoProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("GetSidechainInfo")),
-			connect.WithClientOptions(opts...),
-		),
-		getMainchainTip: connect.NewClient[v1.GetMainchainTipRequest, v1.GetMainchainTipResponse](
-			httpClient,
-			baseURL+BbcServiceGetMainchainTipProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("GetMainchainTip")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmCommitment: connect.NewClient[v1.GetBmmCommitmentRequest, v1.GetBmmCommitmentResponse](
-			httpClient,
-			baseURL+BbcServiceGetBmmCommitmentProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("GetBmmCommitment")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+BbcServiceGetNewAddressProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		send: connect.NewClient[v1.SendRequest, v1.SendResponse](
-			httpClient,
-			baseURL+BbcServiceSendProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("Send")),
-			connect.WithClientOptions(opts...),
-		),
-		estimateFee: connect.NewClient[v1.EstimateFeeRequest, v1.EstimateFeeResponse](
-			httpClient,
-			baseURL+BbcServiceEstimateFeeProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("EstimateFee")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+BbcServiceListUtxosProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listTransactions: connect.NewClient[v1.ListTransactionsRequest, v1.ListTransactionsResponse](
-			httpClient,
-			baseURL+BbcServiceListTransactionsProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("ListTransactions")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+BbcServiceStopProcedure,
-			connect.WithSchema(bbcServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// bbcServiceClient implements BbcServiceClient.
-type bbcServiceClient struct {
-	getBlockCount     *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	getBlockchainInfo *connect.Client[v1.GetBlockchainInfoRequest, v1.GetBlockchainInfoResponse]
-	getSidechainInfo  *connect.Client[v1.GetSidechainInfoRequest, v1.GetSidechainInfoResponse]
-	getMainchainTip   *connect.Client[v1.GetMainchainTipRequest, v1.GetMainchainTipResponse]
-	getBmmCommitment  *connect.Client[v1.GetBmmCommitmentRequest, v1.GetBmmCommitmentResponse]
-	getNewAddress     *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	send              *connect.Client[v1.SendRequest, v1.SendResponse]
-	estimateFee       *connect.Client[v1.EstimateFeeRequest, v1.EstimateFeeResponse]
-	listUtxos         *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	listTransactions  *connect.Client[v1.ListTransactionsRequest, v1.ListTransactionsResponse]
-	stop              *connect.Client[v1.StopRequest, v1.StopResponse]
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	GetBlockchainInfo(context.Context, *v1.GetBlockchainInfoRequest) (*v1.GetBlockchainInfoResponse, error)
+	GetSidechainInfo(context.Context, *v1.GetSidechainInfoRequest) (*v1.GetSidechainInfoResponse, error)
+	GetMainchainTip(context.Context, *v1.GetMainchainTipRequest) (*v1.GetMainchainTipResponse, error)
+	GetBmmCommitment(context.Context, *v1.GetBmmCommitmentRequest) (*v1.GetBmmCommitmentResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Send(context.Context, *v1.SendRequest) (*v1.SendResponse, error)
+	EstimateFee(context.Context, *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
 }
 
-// GetBlockCount calls bbc.v1.BbcService.GetBlockCount.
-func (c *bbcServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// NewBbcServiceClient constructs a client for the bbc.v1.BbcService service. Multiple service
+// clients may share a single connect.Client.
+func NewBbcServiceClient(client *connect.Client) BbcServiceClient {
+	return &bbcServiceClient{client: client}
 }
 
-// GetBlockchainInfo calls bbc.v1.BbcService.GetBlockchainInfo.
-func (c *bbcServiceClient) GetBlockchainInfo(ctx context.Context, req *connect.Request[v1.GetBlockchainInfoRequest]) (*connect.Response[v1.GetBlockchainInfoResponse], error) {
-	return c.getBlockchainInfo.CallUnary(ctx, req)
+// BbcServiceHandler is an implementation of the bbc.v1.BbcService service.
+type BbcServiceHandler interface {
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	GetBlockchainInfo(context.Context, *v1.GetBlockchainInfoRequest) (*v1.GetBlockchainInfoResponse, error)
+	GetSidechainInfo(context.Context, *v1.GetSidechainInfoRequest) (*v1.GetSidechainInfoResponse, error)
+	GetMainchainTip(context.Context, *v1.GetMainchainTipRequest) (*v1.GetMainchainTipResponse, error)
+	GetBmmCommitment(context.Context, *v1.GetBmmCommitmentRequest) (*v1.GetBmmCommitmentResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Send(context.Context, *v1.SendRequest) (*v1.SendResponse, error)
+	EstimateFee(context.Context, *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
 }
 
-// GetSidechainInfo calls bbc.v1.BbcService.GetSidechainInfo.
-func (c *bbcServiceClient) GetSidechainInfo(ctx context.Context, req *connect.Request[v1.GetSidechainInfoRequest]) (*connect.Response[v1.GetSidechainInfoResponse], error) {
-	return c.getSidechainInfo.CallUnary(ctx, req)
+// RegisterBbcServiceHandler registers svc as the bbc.v1.BbcService implementation on server.
+func RegisterBbcServiceHandler(server *connect.Server, svc BbcServiceHandler) {
+	adapter := bbcServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: bbcServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: bbcServiceGetBlockchainInfoSpec(), Handler: adapter.getBlockchainInfo},
+		connect.Method{Spec: bbcServiceGetSidechainInfoSpec(), Handler: adapter.getSidechainInfo},
+		connect.Method{Spec: bbcServiceGetMainchainTipSpec(), Handler: adapter.getMainchainTip},
+		connect.Method{Spec: bbcServiceGetBmmCommitmentSpec(), Handler: adapter.getBmmCommitment},
+		connect.Method{Spec: bbcServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: bbcServiceSendSpec(), Handler: adapter.send},
+		connect.Method{Spec: bbcServiceEstimateFeeSpec(), Handler: adapter.estimateFee},
+		connect.Method{Spec: bbcServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: bbcServiceListTransactionsSpec(), Handler: adapter.listTransactions},
+		connect.Method{Spec: bbcServiceStopSpec(), Handler: adapter.stop},
+	)
 }
 
-// GetMainchainTip calls bbc.v1.BbcService.GetMainchainTip.
-func (c *bbcServiceClient) GetMainchainTip(ctx context.Context, req *connect.Request[v1.GetMainchainTipRequest]) (*connect.Response[v1.GetMainchainTipResponse], error) {
-	return c.getMainchainTip.CallUnary(ctx, req)
+// UnimplementedBbcServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBbcServiceHandler struct{}
+
+func (UnimplementedBbcServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.GetBlockCount is not implemented")
 }
 
-// GetBmmCommitment calls bbc.v1.BbcService.GetBmmCommitment.
-func (c *bbcServiceClient) GetBmmCommitment(ctx context.Context, req *connect.Request[v1.GetBmmCommitmentRequest]) (*connect.Response[v1.GetBmmCommitmentResponse], error) {
-	return c.getBmmCommitment.CallUnary(ctx, req)
+func (UnimplementedBbcServiceHandler) GetBlockchainInfo(context.Context, *v1.GetBlockchainInfoRequest) (*v1.GetBlockchainInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.GetBlockchainInfo is not implemented")
 }
 
-// GetNewAddress calls bbc.v1.BbcService.GetNewAddress.
-func (c *bbcServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedBbcServiceHandler) GetSidechainInfo(context.Context, *v1.GetSidechainInfoRequest) (*v1.GetSidechainInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.GetSidechainInfo is not implemented")
 }
 
-// Send calls bbc.v1.BbcService.Send.
-func (c *bbcServiceClient) Send(ctx context.Context, req *connect.Request[v1.SendRequest]) (*connect.Response[v1.SendResponse], error) {
-	return c.send.CallUnary(ctx, req)
+func (UnimplementedBbcServiceHandler) GetMainchainTip(context.Context, *v1.GetMainchainTipRequest) (*v1.GetMainchainTipResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.GetMainchainTip is not implemented")
 }
 
-// EstimateFee calls bbc.v1.BbcService.EstimateFee.
-func (c *bbcServiceClient) EstimateFee(ctx context.Context, req *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error) {
-	return c.estimateFee.CallUnary(ctx, req)
+func (UnimplementedBbcServiceHandler) GetBmmCommitment(context.Context, *v1.GetBmmCommitmentRequest) (*v1.GetBmmCommitmentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.GetBmmCommitment is not implemented")
 }
 
-// ListUtxos calls bbc.v1.BbcService.ListUtxos.
-func (c *bbcServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedBbcServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.GetNewAddress is not implemented")
 }
 
-// ListTransactions calls bbc.v1.BbcService.ListTransactions.
-func (c *bbcServiceClient) ListTransactions(ctx context.Context, req *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return c.listTransactions.CallUnary(ctx, req)
+func (UnimplementedBbcServiceHandler) Send(context.Context, *v1.SendRequest) (*v1.SendResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.Send is not implemented")
 }
 
-// Stop calls bbc.v1.BbcService.Stop.
-func (c *bbcServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedBbcServiceHandler) EstimateFee(context.Context, *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.EstimateFee is not implemented")
 }
 
-// BbcServiceHandler is an implementation of the bbc.v1.BbcService service.
-type BbcServiceHandler interface {
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Get the node's chain state.
-	GetBlockchainInfo(context.Context, *connect.Request[v1.GetBlockchainInfoRequest]) (*connect.Response[v1.GetBlockchainInfoResponse], error)
-	// Report whether the node has caught up with the mainchain.
-	GetSidechainInfo(context.Context, *connect.Request[v1.GetSidechainInfoRequest]) (*connect.Response[v1.GetSidechainInfoResponse], error)
-	// Get the mainchain block hash the node is following.
-	GetMainchainTip(context.Context, *connect.Request[v1.GetMainchainTipRequest]) (*connect.Response[v1.GetMainchainTipResponse], error)
-	// Get the sidechain block a mainchain block commits to, empty when none.
-	GetBmmCommitment(context.Context, *connect.Request[v1.GetBmmCommitmentRequest]) (*connect.Response[v1.GetBmmCommitmentResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Send to a sidechain address.
-	Send(context.Context, *connect.Request[v1.SendRequest]) (*connect.Response[v1.SendResponse], error)
-	// Estimate the fee rate in sats per kvB.
-	EstimateFee(context.Context, *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error)
-	// List wallet UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// List wallet transactions, most recent first.
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	// Stop the node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-}
-
-// NewBbcServiceHandler builds an HTTP handler from the service implementation. It returns the path
-// on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBbcServiceHandler(svc BbcServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	bbcServiceMethods := v1.File_bbc_v1_bbc_proto.Services().ByName("BbcService").Methods()
-	bbcServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		BbcServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(bbcServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceGetBlockchainInfoHandler := connect.NewUnaryHandler(
-		BbcServiceGetBlockchainInfoProcedure,
-		svc.GetBlockchainInfo,
-		connect.WithSchema(bbcServiceMethods.ByName("GetBlockchainInfo")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceGetSidechainInfoHandler := connect.NewUnaryHandler(
-		BbcServiceGetSidechainInfoProcedure,
-		svc.GetSidechainInfo,
-		connect.WithSchema(bbcServiceMethods.ByName("GetSidechainInfo")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceGetMainchainTipHandler := connect.NewUnaryHandler(
-		BbcServiceGetMainchainTipProcedure,
-		svc.GetMainchainTip,
-		connect.WithSchema(bbcServiceMethods.ByName("GetMainchainTip")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceGetBmmCommitmentHandler := connect.NewUnaryHandler(
-		BbcServiceGetBmmCommitmentProcedure,
-		svc.GetBmmCommitment,
-		connect.WithSchema(bbcServiceMethods.ByName("GetBmmCommitment")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		BbcServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(bbcServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceSendHandler := connect.NewUnaryHandler(
-		BbcServiceSendProcedure,
-		svc.Send,
-		connect.WithSchema(bbcServiceMethods.ByName("Send")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceEstimateFeeHandler := connect.NewUnaryHandler(
-		BbcServiceEstimateFeeProcedure,
-		svc.EstimateFee,
-		connect.WithSchema(bbcServiceMethods.ByName("EstimateFee")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceListUtxosHandler := connect.NewUnaryHandler(
-		BbcServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(bbcServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceListTransactionsHandler := connect.NewUnaryHandler(
-		BbcServiceListTransactionsProcedure,
-		svc.ListTransactions,
-		connect.WithSchema(bbcServiceMethods.ByName("ListTransactions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bbcServiceStopHandler := connect.NewUnaryHandler(
-		BbcServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(bbcServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/bbc.v1.BbcService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BbcServiceGetBlockCountProcedure:
-			bbcServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case BbcServiceGetBlockchainInfoProcedure:
-			bbcServiceGetBlockchainInfoHandler.ServeHTTP(w, r)
-		case BbcServiceGetSidechainInfoProcedure:
-			bbcServiceGetSidechainInfoHandler.ServeHTTP(w, r)
-		case BbcServiceGetMainchainTipProcedure:
-			bbcServiceGetMainchainTipHandler.ServeHTTP(w, r)
-		case BbcServiceGetBmmCommitmentProcedure:
-			bbcServiceGetBmmCommitmentHandler.ServeHTTP(w, r)
-		case BbcServiceGetNewAddressProcedure:
-			bbcServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case BbcServiceSendProcedure:
-			bbcServiceSendHandler.ServeHTTP(w, r)
-		case BbcServiceEstimateFeeProcedure:
-			bbcServiceEstimateFeeHandler.ServeHTTP(w, r)
-		case BbcServiceListUtxosProcedure:
-			bbcServiceListUtxosHandler.ServeHTTP(w, r)
-		case BbcServiceListTransactionsProcedure:
-			bbcServiceListTransactionsHandler.ServeHTTP(w, r)
-		case BbcServiceStopProcedure:
-			bbcServiceStopHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedBbcServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.ListUtxos is not implemented")
 }
 
-// UnimplementedBbcServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBbcServiceHandler struct{}
+func (UnimplementedBbcServiceHandler) ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.ListTransactions is not implemented")
+}
 
-func (UnimplementedBbcServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.GetBlockCount is not implemented"))
+func (UnimplementedBbcServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bbc.v1.BbcService.Stop is not implemented")
 }
 
-func (UnimplementedBbcServiceHandler) GetBlockchainInfo(context.Context, *connect.Request[v1.GetBlockchainInfoRequest]) (*connect.Response[v1.GetBlockchainInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.GetBlockchainInfo is not implemented"))
+type bbcServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedBbcServiceHandler) GetSidechainInfo(context.Context, *connect.Request[v1.GetSidechainInfoRequest]) (*connect.Response[v1.GetSidechainInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.GetSidechainInfo is not implemented"))
+func (c *bbcServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, bbcServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBbcServiceHandler) GetMainchainTip(context.Context, *connect.Request[v1.GetMainchainTipRequest]) (*connect.Response[v1.GetMainchainTipResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.GetMainchainTip is not implemented"))
+func (c *bbcServiceClient) GetBlockchainInfo(ctx context.Context, req *v1.GetBlockchainInfoRequest) (*v1.GetBlockchainInfoResponse, error) {
+	var res v1.GetBlockchainInfoResponse
+	if err := c.client.CallUnary(ctx, bbcServiceGetBlockchainInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bbcServiceClient) GetSidechainInfo(ctx context.Context, req *v1.GetSidechainInfoRequest) (*v1.GetSidechainInfoResponse, error) {
+	var res v1.GetSidechainInfoResponse
+	if err := c.client.CallUnary(ctx, bbcServiceGetSidechainInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bbcServiceClient) GetMainchainTip(ctx context.Context, req *v1.GetMainchainTipRequest) (*v1.GetMainchainTipResponse, error) {
+	var res v1.GetMainchainTipResponse
+	if err := c.client.CallUnary(ctx, bbcServiceGetMainchainTipSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bbcServiceClient) GetBmmCommitment(ctx context.Context, req *v1.GetBmmCommitmentRequest) (*v1.GetBmmCommitmentResponse, error) {
+	var res v1.GetBmmCommitmentResponse
+	if err := c.client.CallUnary(ctx, bbcServiceGetBmmCommitmentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bbcServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, bbcServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bbcServiceClient) Send(ctx context.Context, req *v1.SendRequest) (*v1.SendResponse, error) {
+	var res v1.SendResponse
+	if err := c.client.CallUnary(ctx, bbcServiceSendSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBbcServiceHandler) GetBmmCommitment(context.Context, *connect.Request[v1.GetBmmCommitmentRequest]) (*connect.Response[v1.GetBmmCommitmentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.GetBmmCommitment is not implemented"))
+func (c *bbcServiceClient) EstimateFee(ctx context.Context, req *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error) {
+	var res v1.EstimateFeeResponse
+	if err := c.client.CallUnary(ctx, bbcServiceEstimateFeeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBbcServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.GetNewAddress is not implemented"))
+func (c *bbcServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, bbcServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBbcServiceHandler) Send(context.Context, *connect.Request[v1.SendRequest]) (*connect.Response[v1.SendResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.Send is not implemented"))
+func (c *bbcServiceClient) ListTransactions(ctx context.Context, req *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	var res v1.ListTransactionsResponse
+	if err := c.client.CallUnary(ctx, bbcServiceListTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBbcServiceHandler) EstimateFee(context.Context, *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.EstimateFee is not implemented"))
+func (c *bbcServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, bbcServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBbcServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.ListUtxos is not implemented"))
+type bbcServiceHandler struct{ svc BbcServiceHandler }
+
+func (h bbcServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBbcServiceHandler) ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.ListTransactions is not implemented"))
+func (h bbcServiceHandler) getBlockchainInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockchainInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockchainInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBbcServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bbc.v1.BbcService.Stop is not implemented"))
+func (h bbcServiceHandler) getSidechainInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) getMainchainTip(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetMainchainTipRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetMainchainTip(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) getBmmCommitment(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmCommitmentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmCommitment(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) send(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SendRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Send(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) estimateFee(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EstimateFeeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EstimateFee(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) listTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bbcServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/bitassets/v1/bitassetsv1connect/bitassets.connect.go b/sidechain-orchestrator/gen/bitassets/v1/bitassetsv1connect/bitassets.connect.go
index d4d2cc4877..823d9a5cb2 100644
--- a/sidechain-orchestrator/gen/bitassets/v1/bitassetsv1connect/bitassets.connect.go
+++ b/sidechain-orchestrator/gen/bitassets/v1/bitassetsv1connect/bitassets.connect.go
@@ -5,1563 +5,1822 @@
 package bitassetsv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitassets/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BitAssetsServiceName is the fully-qualified name of the BitAssetsService service.
 	BitAssetsServiceName = "bitassets.v1.BitAssetsService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BitAssetsServiceGetBalanceProcedure is the fully-qualified name of the BitAssetsService's
-	// GetBalance RPC.
+	// BitAssetsServiceGetBalanceProcedure is the procedure name of the BitAssetsService's GetBalance
+	// RPC.
 	BitAssetsServiceGetBalanceProcedure = "/bitassets.v1.BitAssetsService/GetBalance"
-	// BitAssetsServiceGetBlockCountProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetBlockCountProcedure is the procedure name of the BitAssetsService's
 	// GetBlockCount RPC.
 	BitAssetsServiceGetBlockCountProcedure = "/bitassets.v1.BitAssetsService/GetBlockCount"
-	// BitAssetsServiceStopProcedure is the fully-qualified name of the BitAssetsService's Stop RPC.
+	// BitAssetsServiceStopProcedure is the procedure name of the BitAssetsService's Stop RPC.
 	BitAssetsServiceStopProcedure = "/bitassets.v1.BitAssetsService/Stop"
-	// BitAssetsServiceGetNewAddressProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetNewAddressProcedure is the procedure name of the BitAssetsService's
 	// GetNewAddress RPC.
 	BitAssetsServiceGetNewAddressProcedure = "/bitassets.v1.BitAssetsService/GetNewAddress"
-	// BitAssetsServiceWithdrawProcedure is the fully-qualified name of the BitAssetsService's Withdraw
-	// RPC.
+	// BitAssetsServiceWithdrawProcedure is the procedure name of the BitAssetsService's Withdraw RPC.
 	BitAssetsServiceWithdrawProcedure = "/bitassets.v1.BitAssetsService/Withdraw"
-	// BitAssetsServiceTransferProcedure is the fully-qualified name of the BitAssetsService's Transfer
-	// RPC.
+	// BitAssetsServiceTransferProcedure is the procedure name of the BitAssetsService's Transfer RPC.
 	BitAssetsServiceTransferProcedure = "/bitassets.v1.BitAssetsService/Transfer"
-	// BitAssetsServiceGetSidechainWealthProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetSidechainWealthProcedure is the procedure name of the BitAssetsService's
 	// GetSidechainWealth RPC.
 	BitAssetsServiceGetSidechainWealthProcedure = "/bitassets.v1.BitAssetsService/GetSidechainWealth"
-	// BitAssetsServiceCreateDepositProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceCreateDepositProcedure is the procedure name of the BitAssetsService's
 	// CreateDeposit RPC.
 	BitAssetsServiceCreateDepositProcedure = "/bitassets.v1.BitAssetsService/CreateDeposit"
-	// BitAssetsServiceGetPendingWithdrawalBundleProcedure is the fully-qualified name of the
+	// BitAssetsServiceGetPendingWithdrawalBundleProcedure is the procedure name of the
 	// BitAssetsService's GetPendingWithdrawalBundle RPC.
 	BitAssetsServiceGetPendingWithdrawalBundleProcedure = "/bitassets.v1.BitAssetsService/GetPendingWithdrawalBundle"
-	// BitAssetsServiceConnectPeerProcedure is the fully-qualified name of the BitAssetsService's
-	// ConnectPeer RPC.
+	// BitAssetsServiceConnectPeerProcedure is the procedure name of the BitAssetsService's ConnectPeer
+	// RPC.
 	BitAssetsServiceConnectPeerProcedure = "/bitassets.v1.BitAssetsService/ConnectPeer"
-	// BitAssetsServiceForgetPeerProcedure is the fully-qualified name of the BitAssetsService's
-	// ForgetPeer RPC.
+	// BitAssetsServiceForgetPeerProcedure is the procedure name of the BitAssetsService's ForgetPeer
+	// RPC.
 	BitAssetsServiceForgetPeerProcedure = "/bitassets.v1.BitAssetsService/ForgetPeer"
-	// BitAssetsServiceListPeersProcedure is the fully-qualified name of the BitAssetsService's
-	// ListPeers RPC.
+	// BitAssetsServiceListPeersProcedure is the procedure name of the BitAssetsService's ListPeers RPC.
 	BitAssetsServiceListPeersProcedure = "/bitassets.v1.BitAssetsService/ListPeers"
-	// BitAssetsServiceMineProcedure is the fully-qualified name of the BitAssetsService's Mine RPC.
+	// BitAssetsServiceMineProcedure is the procedure name of the BitAssetsService's Mine RPC.
 	BitAssetsServiceMineProcedure = "/bitassets.v1.BitAssetsService/Mine"
-	// BitAssetsServiceGetBlockProcedure is the fully-qualified name of the BitAssetsService's GetBlock
-	// RPC.
+	// BitAssetsServiceGetBlockProcedure is the procedure name of the BitAssetsService's GetBlock RPC.
 	BitAssetsServiceGetBlockProcedure = "/bitassets.v1.BitAssetsService/GetBlock"
-	// BitAssetsServiceGetBestMainchainBlockHashProcedure is the fully-qualified name of the
+	// BitAssetsServiceGetBestMainchainBlockHashProcedure is the procedure name of the
 	// BitAssetsService's GetBestMainchainBlockHash RPC.
 	BitAssetsServiceGetBestMainchainBlockHashProcedure = "/bitassets.v1.BitAssetsService/GetBestMainchainBlockHash"
-	// BitAssetsServiceGetBestSidechainBlockHashProcedure is the fully-qualified name of the
+	// BitAssetsServiceGetBestSidechainBlockHashProcedure is the procedure name of the
 	// BitAssetsService's GetBestSidechainBlockHash RPC.
 	BitAssetsServiceGetBestSidechainBlockHashProcedure = "/bitassets.v1.BitAssetsService/GetBestSidechainBlockHash"
-	// BitAssetsServiceGetBmmInclusionsProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetBmmInclusionsProcedure is the procedure name of the BitAssetsService's
 	// GetBmmInclusions RPC.
 	BitAssetsServiceGetBmmInclusionsProcedure = "/bitassets.v1.BitAssetsService/GetBmmInclusions"
-	// BitAssetsServiceGetWalletUtxosProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetWalletUtxosProcedure is the procedure name of the BitAssetsService's
 	// GetWalletUtxos RPC.
 	BitAssetsServiceGetWalletUtxosProcedure = "/bitassets.v1.BitAssetsService/GetWalletUtxos"
-	// BitAssetsServiceListUtxosProcedure is the fully-qualified name of the BitAssetsService's
-	// ListUtxos RPC.
+	// BitAssetsServiceListUtxosProcedure is the procedure name of the BitAssetsService's ListUtxos RPC.
 	BitAssetsServiceListUtxosProcedure = "/bitassets.v1.BitAssetsService/ListUtxos"
-	// BitAssetsServiceRemoveFromMempoolProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceRemoveFromMempoolProcedure is the procedure name of the BitAssetsService's
 	// RemoveFromMempool RPC.
 	BitAssetsServiceRemoveFromMempoolProcedure = "/bitassets.v1.BitAssetsService/RemoveFromMempool"
-	// BitAssetsServiceGetLatestFailedWithdrawalBundleHeightProcedure is the fully-qualified name of the
+	// BitAssetsServiceGetLatestFailedWithdrawalBundleHeightProcedure is the procedure name of the
 	// BitAssetsService's GetLatestFailedWithdrawalBundleHeight RPC.
 	BitAssetsServiceGetLatestFailedWithdrawalBundleHeightProcedure = "/bitassets.v1.BitAssetsService/GetLatestFailedWithdrawalBundleHeight"
-	// BitAssetsServiceGenerateMnemonicProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGenerateMnemonicProcedure is the procedure name of the BitAssetsService's
 	// GenerateMnemonic RPC.
 	BitAssetsServiceGenerateMnemonicProcedure = "/bitassets.v1.BitAssetsService/GenerateMnemonic"
-	// BitAssetsServiceSetSeedFromMnemonicProcedure is the fully-qualified name of the
-	// BitAssetsService's SetSeedFromMnemonic RPC.
+	// BitAssetsServiceSetSeedFromMnemonicProcedure is the procedure name of the BitAssetsService's
+	// SetSeedFromMnemonic RPC.
 	BitAssetsServiceSetSeedFromMnemonicProcedure = "/bitassets.v1.BitAssetsService/SetSeedFromMnemonic"
-	// BitAssetsServiceCallRawProcedure is the fully-qualified name of the BitAssetsService's CallRaw
-	// RPC.
+	// BitAssetsServiceCallRawProcedure is the procedure name of the BitAssetsService's CallRaw RPC.
 	BitAssetsServiceCallRawProcedure = "/bitassets.v1.BitAssetsService/CallRaw"
-	// BitAssetsServiceGetBitAssetDataProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetBitAssetDataProcedure is the procedure name of the BitAssetsService's
 	// GetBitAssetData RPC.
 	BitAssetsServiceGetBitAssetDataProcedure = "/bitassets.v1.BitAssetsService/GetBitAssetData"
-	// BitAssetsServiceListBitAssetsProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceListBitAssetsProcedure is the procedure name of the BitAssetsService's
 	// ListBitAssets RPC.
 	BitAssetsServiceListBitAssetsProcedure = "/bitassets.v1.BitAssetsService/ListBitAssets"
-	// BitAssetsServiceRegisterBitAssetProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceRegisterBitAssetProcedure is the procedure name of the BitAssetsService's
 	// RegisterBitAsset RPC.
 	BitAssetsServiceRegisterBitAssetProcedure = "/bitassets.v1.BitAssetsService/RegisterBitAsset"
-	// BitAssetsServiceReserveBitAssetProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceReserveBitAssetProcedure is the procedure name of the BitAssetsService's
 	// ReserveBitAsset RPC.
 	BitAssetsServiceReserveBitAssetProcedure = "/bitassets.v1.BitAssetsService/ReserveBitAsset"
-	// BitAssetsServiceTransferBitAssetProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceTransferBitAssetProcedure is the procedure name of the BitAssetsService's
 	// TransferBitAsset RPC.
 	BitAssetsServiceTransferBitAssetProcedure = "/bitassets.v1.BitAssetsService/TransferBitAsset"
-	// BitAssetsServiceGetNewEncryptionKeyProcedure is the fully-qualified name of the
-	// BitAssetsService's GetNewEncryptionKey RPC.
+	// BitAssetsServiceGetNewEncryptionKeyProcedure is the procedure name of the BitAssetsService's
+	// GetNewEncryptionKey RPC.
 	BitAssetsServiceGetNewEncryptionKeyProcedure = "/bitassets.v1.BitAssetsService/GetNewEncryptionKey"
-	// BitAssetsServiceGetNewVerifyingKeyProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetNewVerifyingKeyProcedure is the procedure name of the BitAssetsService's
 	// GetNewVerifyingKey RPC.
 	BitAssetsServiceGetNewVerifyingKeyProcedure = "/bitassets.v1.BitAssetsService/GetNewVerifyingKey"
-	// BitAssetsServiceDecryptMsgProcedure is the fully-qualified name of the BitAssetsService's
-	// DecryptMsg RPC.
+	// BitAssetsServiceDecryptMsgProcedure is the procedure name of the BitAssetsService's DecryptMsg
+	// RPC.
 	BitAssetsServiceDecryptMsgProcedure = "/bitassets.v1.BitAssetsService/DecryptMsg"
-	// BitAssetsServiceEncryptMsgProcedure is the fully-qualified name of the BitAssetsService's
-	// EncryptMsg RPC.
+	// BitAssetsServiceEncryptMsgProcedure is the procedure name of the BitAssetsService's EncryptMsg
+	// RPC.
 	BitAssetsServiceEncryptMsgProcedure = "/bitassets.v1.BitAssetsService/EncryptMsg"
-	// BitAssetsServiceSignArbitraryMsgProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceSignArbitraryMsgProcedure is the procedure name of the BitAssetsService's
 	// SignArbitraryMsg RPC.
 	BitAssetsServiceSignArbitraryMsgProcedure = "/bitassets.v1.BitAssetsService/SignArbitraryMsg"
-	// BitAssetsServiceSignArbitraryMsgAsAddrProcedure is the fully-qualified name of the
-	// BitAssetsService's SignArbitraryMsgAsAddr RPC.
+	// BitAssetsServiceSignArbitraryMsgAsAddrProcedure is the procedure name of the BitAssetsService's
+	// SignArbitraryMsgAsAddr RPC.
 	BitAssetsServiceSignArbitraryMsgAsAddrProcedure = "/bitassets.v1.BitAssetsService/SignArbitraryMsgAsAddr"
-	// BitAssetsServiceVerifySignatureProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceVerifySignatureProcedure is the procedure name of the BitAssetsService's
 	// VerifySignature RPC.
 	BitAssetsServiceVerifySignatureProcedure = "/bitassets.v1.BitAssetsService/VerifySignature"
-	// BitAssetsServiceGetWalletAddressesProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetWalletAddressesProcedure is the procedure name of the BitAssetsService's
 	// GetWalletAddresses RPC.
 	BitAssetsServiceGetWalletAddressesProcedure = "/bitassets.v1.BitAssetsService/GetWalletAddresses"
-	// BitAssetsServiceMyUnconfirmedUtxosProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceMyUnconfirmedUtxosProcedure is the procedure name of the BitAssetsService's
 	// MyUnconfirmedUtxos RPC.
 	BitAssetsServiceMyUnconfirmedUtxosProcedure = "/bitassets.v1.BitAssetsService/MyUnconfirmedUtxos"
-	// BitAssetsServiceOpenapiSchemaProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceOpenapiSchemaProcedure is the procedure name of the BitAssetsService's
 	// OpenapiSchema RPC.
 	BitAssetsServiceOpenapiSchemaProcedure = "/bitassets.v1.BitAssetsService/OpenapiSchema"
-	// BitAssetsServiceAmmBurnProcedure is the fully-qualified name of the BitAssetsService's AmmBurn
-	// RPC.
+	// BitAssetsServiceAmmBurnProcedure is the procedure name of the BitAssetsService's AmmBurn RPC.
 	BitAssetsServiceAmmBurnProcedure = "/bitassets.v1.BitAssetsService/AmmBurn"
-	// BitAssetsServiceAmmMintProcedure is the fully-qualified name of the BitAssetsService's AmmMint
-	// RPC.
+	// BitAssetsServiceAmmMintProcedure is the procedure name of the BitAssetsService's AmmMint RPC.
 	BitAssetsServiceAmmMintProcedure = "/bitassets.v1.BitAssetsService/AmmMint"
-	// BitAssetsServiceAmmSwapProcedure is the fully-qualified name of the BitAssetsService's AmmSwap
-	// RPC.
+	// BitAssetsServiceAmmSwapProcedure is the procedure name of the BitAssetsService's AmmSwap RPC.
 	BitAssetsServiceAmmSwapProcedure = "/bitassets.v1.BitAssetsService/AmmSwap"
-	// BitAssetsServiceGetAmmPoolStateProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceGetAmmPoolStateProcedure is the procedure name of the BitAssetsService's
 	// GetAmmPoolState RPC.
 	BitAssetsServiceGetAmmPoolStateProcedure = "/bitassets.v1.BitAssetsService/GetAmmPoolState"
-	// BitAssetsServiceGetAmmPriceProcedure is the fully-qualified name of the BitAssetsService's
-	// GetAmmPrice RPC.
+	// BitAssetsServiceGetAmmPriceProcedure is the procedure name of the BitAssetsService's GetAmmPrice
+	// RPC.
 	BitAssetsServiceGetAmmPriceProcedure = "/bitassets.v1.BitAssetsService/GetAmmPrice"
-	// BitAssetsServiceDutchAuctionBidProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceDutchAuctionBidProcedure is the procedure name of the BitAssetsService's
 	// DutchAuctionBid RPC.
 	BitAssetsServiceDutchAuctionBidProcedure = "/bitassets.v1.BitAssetsService/DutchAuctionBid"
-	// BitAssetsServiceDutchAuctionCollectProcedure is the fully-qualified name of the
-	// BitAssetsService's DutchAuctionCollect RPC.
+	// BitAssetsServiceDutchAuctionCollectProcedure is the procedure name of the BitAssetsService's
+	// DutchAuctionCollect RPC.
 	BitAssetsServiceDutchAuctionCollectProcedure = "/bitassets.v1.BitAssetsService/DutchAuctionCollect"
-	// BitAssetsServiceDutchAuctionCreateProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceDutchAuctionCreateProcedure is the procedure name of the BitAssetsService's
 	// DutchAuctionCreate RPC.
 	BitAssetsServiceDutchAuctionCreateProcedure = "/bitassets.v1.BitAssetsService/DutchAuctionCreate"
-	// BitAssetsServiceDutchAuctionsProcedure is the fully-qualified name of the BitAssetsService's
+	// BitAssetsServiceDutchAuctionsProcedure is the procedure name of the BitAssetsService's
 	// DutchAuctions RPC.
 	BitAssetsServiceDutchAuctionsProcedure = "/bitassets.v1.BitAssetsService/DutchAuctions"
 )
 
+var (
+	bitAssetsServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetBalance"),
+			Procedure:  BitAssetsServiceGetBalanceProcedure,
+		}
+	})
+	bitAssetsServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetBlockCount"),
+			Procedure:  BitAssetsServiceGetBlockCountProcedure,
+		}
+	})
+	bitAssetsServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("Stop"),
+			Procedure:  BitAssetsServiceStopProcedure,
+		}
+	})
+	bitAssetsServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetNewAddress"),
+			Procedure:  BitAssetsServiceGetNewAddressProcedure,
+		}
+	})
+	bitAssetsServiceWithdrawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("Withdraw"),
+			Procedure:  BitAssetsServiceWithdrawProcedure,
+		}
+	})
+	bitAssetsServiceTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("Transfer"),
+			Procedure:  BitAssetsServiceTransferProcedure,
+		}
+	})
+	bitAssetsServiceGetSidechainWealthSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetSidechainWealth"),
+			Procedure:  BitAssetsServiceGetSidechainWealthProcedure,
+		}
+	})
+	bitAssetsServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("CreateDeposit"),
+			Procedure:  BitAssetsServiceCreateDepositProcedure,
+		}
+	})
+	bitAssetsServiceGetPendingWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetPendingWithdrawalBundle"),
+			Procedure:  BitAssetsServiceGetPendingWithdrawalBundleProcedure,
+		}
+	})
+	bitAssetsServiceConnectPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("ConnectPeer"),
+			Procedure:  BitAssetsServiceConnectPeerProcedure,
+		}
+	})
+	bitAssetsServiceForgetPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("ForgetPeer"),
+			Procedure:  BitAssetsServiceForgetPeerProcedure,
+		}
+	})
+	bitAssetsServiceListPeersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("ListPeers"),
+			Procedure:  BitAssetsServiceListPeersProcedure,
+		}
+	})
+	bitAssetsServiceMineSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("Mine"),
+			Procedure:  BitAssetsServiceMineProcedure,
+		}
+	})
+	bitAssetsServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetBlock"),
+			Procedure:  BitAssetsServiceGetBlockProcedure,
+		}
+	})
+	bitAssetsServiceGetBestMainchainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetBestMainchainBlockHash"),
+			Procedure:  BitAssetsServiceGetBestMainchainBlockHashProcedure,
+		}
+	})
+	bitAssetsServiceGetBestSidechainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetBestSidechainBlockHash"),
+			Procedure:  BitAssetsServiceGetBestSidechainBlockHashProcedure,
+		}
+	})
+	bitAssetsServiceGetBmmInclusionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetBmmInclusions"),
+			Procedure:  BitAssetsServiceGetBmmInclusionsProcedure,
+		}
+	})
+	bitAssetsServiceGetWalletUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetWalletUtxos"),
+			Procedure:  BitAssetsServiceGetWalletUtxosProcedure,
+		}
+	})
+	bitAssetsServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("ListUtxos"),
+			Procedure:  BitAssetsServiceListUtxosProcedure,
+		}
+	})
+	bitAssetsServiceRemoveFromMempoolSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("RemoveFromMempool"),
+			Procedure:  BitAssetsServiceRemoveFromMempoolProcedure,
+		}
+	})
+	bitAssetsServiceGetLatestFailedWithdrawalBundleHeightSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetLatestFailedWithdrawalBundleHeight"),
+			Procedure:  BitAssetsServiceGetLatestFailedWithdrawalBundleHeightProcedure,
+		}
+	})
+	bitAssetsServiceGenerateMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GenerateMnemonic"),
+			Procedure:  BitAssetsServiceGenerateMnemonicProcedure,
+		}
+	})
+	bitAssetsServiceSetSeedFromMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("SetSeedFromMnemonic"),
+			Procedure:  BitAssetsServiceSetSeedFromMnemonicProcedure,
+		}
+	})
+	bitAssetsServiceCallRawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("CallRaw"),
+			Procedure:  BitAssetsServiceCallRawProcedure,
+		}
+	})
+	bitAssetsServiceGetBitAssetDataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetBitAssetData"),
+			Procedure:  BitAssetsServiceGetBitAssetDataProcedure,
+		}
+	})
+	bitAssetsServiceListBitAssetsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("ListBitAssets"),
+			Procedure:  BitAssetsServiceListBitAssetsProcedure,
+		}
+	})
+	bitAssetsServiceRegisterBitAssetSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("RegisterBitAsset"),
+			Procedure:  BitAssetsServiceRegisterBitAssetProcedure,
+		}
+	})
+	bitAssetsServiceReserveBitAssetSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("ReserveBitAsset"),
+			Procedure:  BitAssetsServiceReserveBitAssetProcedure,
+		}
+	})
+	bitAssetsServiceTransferBitAssetSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("TransferBitAsset"),
+			Procedure:  BitAssetsServiceTransferBitAssetProcedure,
+		}
+	})
+	bitAssetsServiceGetNewEncryptionKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetNewEncryptionKey"),
+			Procedure:  BitAssetsServiceGetNewEncryptionKeyProcedure,
+		}
+	})
+	bitAssetsServiceGetNewVerifyingKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetNewVerifyingKey"),
+			Procedure:  BitAssetsServiceGetNewVerifyingKeyProcedure,
+		}
+	})
+	bitAssetsServiceDecryptMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("DecryptMsg"),
+			Procedure:  BitAssetsServiceDecryptMsgProcedure,
+		}
+	})
+	bitAssetsServiceEncryptMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("EncryptMsg"),
+			Procedure:  BitAssetsServiceEncryptMsgProcedure,
+		}
+	})
+	bitAssetsServiceSignArbitraryMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("SignArbitraryMsg"),
+			Procedure:  BitAssetsServiceSignArbitraryMsgProcedure,
+		}
+	})
+	bitAssetsServiceSignArbitraryMsgAsAddrSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("SignArbitraryMsgAsAddr"),
+			Procedure:  BitAssetsServiceSignArbitraryMsgAsAddrProcedure,
+		}
+	})
+	bitAssetsServiceVerifySignatureSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("VerifySignature"),
+			Procedure:  BitAssetsServiceVerifySignatureProcedure,
+		}
+	})
+	bitAssetsServiceGetWalletAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetWalletAddresses"),
+			Procedure:  BitAssetsServiceGetWalletAddressesProcedure,
+		}
+	})
+	bitAssetsServiceMyUnconfirmedUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("MyUnconfirmedUtxos"),
+			Procedure:  BitAssetsServiceMyUnconfirmedUtxosProcedure,
+		}
+	})
+	bitAssetsServiceOpenapiSchemaSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("OpenapiSchema"),
+			Procedure:  BitAssetsServiceOpenapiSchemaProcedure,
+		}
+	})
+	bitAssetsServiceAmmBurnSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("AmmBurn"),
+			Procedure:  BitAssetsServiceAmmBurnProcedure,
+		}
+	})
+	bitAssetsServiceAmmMintSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("AmmMint"),
+			Procedure:  BitAssetsServiceAmmMintProcedure,
+		}
+	})
+	bitAssetsServiceAmmSwapSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("AmmSwap"),
+			Procedure:  BitAssetsServiceAmmSwapProcedure,
+		}
+	})
+	bitAssetsServiceGetAmmPoolStateSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetAmmPoolState"),
+			Procedure:  BitAssetsServiceGetAmmPoolStateProcedure,
+		}
+	})
+	bitAssetsServiceGetAmmPriceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("GetAmmPrice"),
+			Procedure:  BitAssetsServiceGetAmmPriceProcedure,
+		}
+	})
+	bitAssetsServiceDutchAuctionBidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("DutchAuctionBid"),
+			Procedure:  BitAssetsServiceDutchAuctionBidProcedure,
+		}
+	})
+	bitAssetsServiceDutchAuctionCollectSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("DutchAuctionCollect"),
+			Procedure:  BitAssetsServiceDutchAuctionCollectProcedure,
+		}
+	})
+	bitAssetsServiceDutchAuctionCreateSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("DutchAuctionCreate"),
+			Procedure:  BitAssetsServiceDutchAuctionCreateProcedure,
+		}
+	})
+	bitAssetsServiceDutchAuctionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods().ByName("DutchAuctions"),
+			Procedure:  BitAssetsServiceDutchAuctionsProcedure,
+		}
+	})
+)
+
 // BitAssetsServiceClient is a client for the bitassets.v1.BitAssetsService service.
 type BitAssetsServiceClient interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the bitassets node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// Forget a peer.
-	ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get BitAsset data by asset ID.
-	GetBitAssetData(context.Context, *connect.Request[v1.GetBitAssetDataRequest]) (*connect.Response[v1.GetBitAssetDataResponse], error)
-	// List all BitAssets.
-	ListBitAssets(context.Context, *connect.Request[v1.ListBitAssetsRequest]) (*connect.Response[v1.ListBitAssetsResponse], error)
-	// Register a BitAsset.
-	RegisterBitAsset(context.Context, *connect.Request[v1.RegisterBitAssetRequest]) (*connect.Response[v1.RegisterBitAssetResponse], error)
-	// Reserve a BitAsset.
-	ReserveBitAsset(context.Context, *connect.Request[v1.ReserveBitAssetRequest]) (*connect.Response[v1.ReserveBitAssetResponse], error)
-	// Transfer a BitAsset token.
-	TransferBitAsset(context.Context, *connect.Request[v1.TransferBitAssetRequest]) (*connect.Response[v1.TransferBitAssetResponse], error)
-	// Get a new encryption key.
-	GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error)
-	// Get a new verifying key.
-	GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error)
-	// Decrypt a message.
-	DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error)
-	// Encrypt a message.
-	EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error)
-	// Sign an arbitrary message with the specified verifying key.
-	SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error)
-	// Sign an arbitrary message as a specific address.
-	SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error)
-	// Verify a signature.
-	VerifySignature(context.Context, *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// List unconfirmed owned UTXOs.
-	MyUnconfirmedUtxos(context.Context, *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error)
-	// Get OpenAPI schema.
-	OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error)
-	// Burn an AMM position.
-	AmmBurn(context.Context, *connect.Request[v1.AmmBurnRequest]) (*connect.Response[v1.AmmBurnResponse], error)
-	// Mint an AMM position.
-	AmmMint(context.Context, *connect.Request[v1.AmmMintRequest]) (*connect.Response[v1.AmmMintResponse], error)
-	// AMM swap.
-	AmmSwap(context.Context, *connect.Request[v1.AmmSwapRequest]) (*connect.Response[v1.AmmSwapResponse], error)
-	// Get the state of the specified AMM pool.
-	GetAmmPoolState(context.Context, *connect.Request[v1.GetAmmPoolStateRequest]) (*connect.Response[v1.GetAmmPoolStateResponse], error)
-	// Get the current price for the specified pair.
-	GetAmmPrice(context.Context, *connect.Request[v1.GetAmmPriceRequest]) (*connect.Response[v1.GetAmmPriceResponse], error)
-	// Bid on a dutch auction.
-	DutchAuctionBid(context.Context, *connect.Request[v1.DutchAuctionBidRequest]) (*connect.Response[v1.DutchAuctionBidResponse], error)
-	// Collect from a dutch auction.
-	DutchAuctionCollect(context.Context, *connect.Request[v1.DutchAuctionCollectRequest]) (*connect.Response[v1.DutchAuctionCollectResponse], error)
-	// Create a dutch auction.
-	DutchAuctionCreate(context.Context, *connect.Request[v1.DutchAuctionCreateRequest]) (*connect.Response[v1.DutchAuctionCreateResponse], error)
-	// List all dutch auctions.
-	DutchAuctions(context.Context, *connect.Request[v1.DutchAuctionsRequest]) (*connect.Response[v1.DutchAuctionsResponse], error)
-}
-
-// NewBitAssetsServiceClient constructs a client for the bitassets.v1.BitAssetsService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBitAssetsServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BitAssetsServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	bitAssetsServiceMethods := v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods()
-	return &bitAssetsServiceClient{
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetBalanceProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetBlockCountProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+BitAssetsServiceStopProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetNewAddressProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		withdraw: connect.NewClient[v1.WithdrawRequest, v1.WithdrawResponse](
-			httpClient,
-			baseURL+BitAssetsServiceWithdrawProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("Withdraw")),
-			connect.WithClientOptions(opts...),
-		),
-		transfer: connect.NewClient[v1.TransferRequest, v1.TransferResponse](
-			httpClient,
-			baseURL+BitAssetsServiceTransferProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("Transfer")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainWealth: connect.NewClient[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetSidechainWealthProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetSidechainWealth")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+BitAssetsServiceCreateDepositProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingWithdrawalBundle: connect.NewClient[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetPendingWithdrawalBundleProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetPendingWithdrawalBundle")),
-			connect.WithClientOptions(opts...),
-		),
-		connectPeer: connect.NewClient[v1.ConnectPeerRequest, v1.ConnectPeerResponse](
-			httpClient,
-			baseURL+BitAssetsServiceConnectPeerProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("ConnectPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		forgetPeer: connect.NewClient[v1.ForgetPeerRequest, v1.ForgetPeerResponse](
-			httpClient,
-			baseURL+BitAssetsServiceForgetPeerProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("ForgetPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		listPeers: connect.NewClient[v1.ListPeersRequest, v1.ListPeersResponse](
-			httpClient,
-			baseURL+BitAssetsServiceListPeersProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("ListPeers")),
-			connect.WithClientOptions(opts...),
-		),
-		mine: connect.NewClient[v1.MineRequest, v1.MineResponse](
-			httpClient,
-			baseURL+BitAssetsServiceMineProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("Mine")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetBlockProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestMainchainBlockHash: connect.NewClient[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetBestMainchainBlockHashProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetBestMainchainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestSidechainBlockHash: connect.NewClient[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetBestSidechainBlockHashProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetBestSidechainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmInclusions: connect.NewClient[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetBmmInclusionsProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetBmmInclusions")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletUtxos: connect.NewClient[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetWalletUtxosProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetWalletUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+BitAssetsServiceListUtxosProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		removeFromMempool: connect.NewClient[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse](
-			httpClient,
-			baseURL+BitAssetsServiceRemoveFromMempoolProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("RemoveFromMempool")),
-			connect.WithClientOptions(opts...),
-		),
-		getLatestFailedWithdrawalBundleHeight: connect.NewClient[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-			connect.WithClientOptions(opts...),
-		),
-		generateMnemonic: connect.NewClient[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGenerateMnemonicProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GenerateMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		setSeedFromMnemonic: connect.NewClient[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse](
-			httpClient,
-			baseURL+BitAssetsServiceSetSeedFromMnemonicProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("SetSeedFromMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		callRaw: connect.NewClient[v1.CallRawRequest, v1.CallRawResponse](
-			httpClient,
-			baseURL+BitAssetsServiceCallRawProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("CallRaw")),
-			connect.WithClientOptions(opts...),
-		),
-		getBitAssetData: connect.NewClient[v1.GetBitAssetDataRequest, v1.GetBitAssetDataResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetBitAssetDataProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetBitAssetData")),
-			connect.WithClientOptions(opts...),
-		),
-		listBitAssets: connect.NewClient[v1.ListBitAssetsRequest, v1.ListBitAssetsResponse](
-			httpClient,
-			baseURL+BitAssetsServiceListBitAssetsProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("ListBitAssets")),
-			connect.WithClientOptions(opts...),
-		),
-		registerBitAsset: connect.NewClient[v1.RegisterBitAssetRequest, v1.RegisterBitAssetResponse](
-			httpClient,
-			baseURL+BitAssetsServiceRegisterBitAssetProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("RegisterBitAsset")),
-			connect.WithClientOptions(opts...),
-		),
-		reserveBitAsset: connect.NewClient[v1.ReserveBitAssetRequest, v1.ReserveBitAssetResponse](
-			httpClient,
-			baseURL+BitAssetsServiceReserveBitAssetProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("ReserveBitAsset")),
-			connect.WithClientOptions(opts...),
-		),
-		transferBitAsset: connect.NewClient[v1.TransferBitAssetRequest, v1.TransferBitAssetResponse](
-			httpClient,
-			baseURL+BitAssetsServiceTransferBitAssetProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("TransferBitAsset")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewEncryptionKey: connect.NewClient[v1.GetNewEncryptionKeyRequest, v1.GetNewEncryptionKeyResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetNewEncryptionKeyProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetNewEncryptionKey")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewVerifyingKey: connect.NewClient[v1.GetNewVerifyingKeyRequest, v1.GetNewVerifyingKeyResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetNewVerifyingKeyProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetNewVerifyingKey")),
-			connect.WithClientOptions(opts...),
-		),
-		decryptMsg: connect.NewClient[v1.DecryptMsgRequest, v1.DecryptMsgResponse](
-			httpClient,
-			baseURL+BitAssetsServiceDecryptMsgProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("DecryptMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		encryptMsg: connect.NewClient[v1.EncryptMsgRequest, v1.EncryptMsgResponse](
-			httpClient,
-			baseURL+BitAssetsServiceEncryptMsgProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("EncryptMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		signArbitraryMsg: connect.NewClient[v1.SignArbitraryMsgRequest, v1.SignArbitraryMsgResponse](
-			httpClient,
-			baseURL+BitAssetsServiceSignArbitraryMsgProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("SignArbitraryMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		signArbitraryMsgAsAddr: connect.NewClient[v1.SignArbitraryMsgAsAddrRequest, v1.SignArbitraryMsgAsAddrResponse](
-			httpClient,
-			baseURL+BitAssetsServiceSignArbitraryMsgAsAddrProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("SignArbitraryMsgAsAddr")),
-			connect.WithClientOptions(opts...),
-		),
-		verifySignature: connect.NewClient[v1.VerifySignatureRequest, v1.VerifySignatureResponse](
-			httpClient,
-			baseURL+BitAssetsServiceVerifySignatureProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("VerifySignature")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletAddresses: connect.NewClient[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetWalletAddressesProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetWalletAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		myUnconfirmedUtxos: connect.NewClient[v1.MyUnconfirmedUtxosRequest, v1.MyUnconfirmedUtxosResponse](
-			httpClient,
-			baseURL+BitAssetsServiceMyUnconfirmedUtxosProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("MyUnconfirmedUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		openapiSchema: connect.NewClient[v1.OpenapiSchemaRequest, v1.OpenapiSchemaResponse](
-			httpClient,
-			baseURL+BitAssetsServiceOpenapiSchemaProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("OpenapiSchema")),
-			connect.WithClientOptions(opts...),
-		),
-		ammBurn: connect.NewClient[v1.AmmBurnRequest, v1.AmmBurnResponse](
-			httpClient,
-			baseURL+BitAssetsServiceAmmBurnProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("AmmBurn")),
-			connect.WithClientOptions(opts...),
-		),
-		ammMint: connect.NewClient[v1.AmmMintRequest, v1.AmmMintResponse](
-			httpClient,
-			baseURL+BitAssetsServiceAmmMintProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("AmmMint")),
-			connect.WithClientOptions(opts...),
-		),
-		ammSwap: connect.NewClient[v1.AmmSwapRequest, v1.AmmSwapResponse](
-			httpClient,
-			baseURL+BitAssetsServiceAmmSwapProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("AmmSwap")),
-			connect.WithClientOptions(opts...),
-		),
-		getAmmPoolState: connect.NewClient[v1.GetAmmPoolStateRequest, v1.GetAmmPoolStateResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetAmmPoolStateProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetAmmPoolState")),
-			connect.WithClientOptions(opts...),
-		),
-		getAmmPrice: connect.NewClient[v1.GetAmmPriceRequest, v1.GetAmmPriceResponse](
-			httpClient,
-			baseURL+BitAssetsServiceGetAmmPriceProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("GetAmmPrice")),
-			connect.WithClientOptions(opts...),
-		),
-		dutchAuctionBid: connect.NewClient[v1.DutchAuctionBidRequest, v1.DutchAuctionBidResponse](
-			httpClient,
-			baseURL+BitAssetsServiceDutchAuctionBidProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctionBid")),
-			connect.WithClientOptions(opts...),
-		),
-		dutchAuctionCollect: connect.NewClient[v1.DutchAuctionCollectRequest, v1.DutchAuctionCollectResponse](
-			httpClient,
-			baseURL+BitAssetsServiceDutchAuctionCollectProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctionCollect")),
-			connect.WithClientOptions(opts...),
-		),
-		dutchAuctionCreate: connect.NewClient[v1.DutchAuctionCreateRequest, v1.DutchAuctionCreateResponse](
-			httpClient,
-			baseURL+BitAssetsServiceDutchAuctionCreateProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctionCreate")),
-			connect.WithClientOptions(opts...),
-		),
-		dutchAuctions: connect.NewClient[v1.DutchAuctionsRequest, v1.DutchAuctionsResponse](
-			httpClient,
-			baseURL+BitAssetsServiceDutchAuctionsProcedure,
-			connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctions")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// bitAssetsServiceClient implements BitAssetsServiceClient.
-type bitAssetsServiceClient struct {
-	getBalance                            *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getBlockCount                         *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	stop                                  *connect.Client[v1.StopRequest, v1.StopResponse]
-	getNewAddress                         *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	withdraw                              *connect.Client[v1.WithdrawRequest, v1.WithdrawResponse]
-	transfer                              *connect.Client[v1.TransferRequest, v1.TransferResponse]
-	getSidechainWealth                    *connect.Client[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse]
-	createDeposit                         *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	getPendingWithdrawalBundle            *connect.Client[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse]
-	connectPeer                           *connect.Client[v1.ConnectPeerRequest, v1.ConnectPeerResponse]
-	forgetPeer                            *connect.Client[v1.ForgetPeerRequest, v1.ForgetPeerResponse]
-	listPeers                             *connect.Client[v1.ListPeersRequest, v1.ListPeersResponse]
-	mine                                  *connect.Client[v1.MineRequest, v1.MineResponse]
-	getBlock                              *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	getBestMainchainBlockHash             *connect.Client[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse]
-	getBestSidechainBlockHash             *connect.Client[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse]
-	getBmmInclusions                      *connect.Client[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse]
-	getWalletUtxos                        *connect.Client[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse]
-	listUtxos                             *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	removeFromMempool                     *connect.Client[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse]
-	getLatestFailedWithdrawalBundleHeight *connect.Client[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse]
-	generateMnemonic                      *connect.Client[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse]
-	setSeedFromMnemonic                   *connect.Client[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse]
-	callRaw                               *connect.Client[v1.CallRawRequest, v1.CallRawResponse]
-	getBitAssetData                       *connect.Client[v1.GetBitAssetDataRequest, v1.GetBitAssetDataResponse]
-	listBitAssets                         *connect.Client[v1.ListBitAssetsRequest, v1.ListBitAssetsResponse]
-	registerBitAsset                      *connect.Client[v1.RegisterBitAssetRequest, v1.RegisterBitAssetResponse]
-	reserveBitAsset                       *connect.Client[v1.ReserveBitAssetRequest, v1.ReserveBitAssetResponse]
-	transferBitAsset                      *connect.Client[v1.TransferBitAssetRequest, v1.TransferBitAssetResponse]
-	getNewEncryptionKey                   *connect.Client[v1.GetNewEncryptionKeyRequest, v1.GetNewEncryptionKeyResponse]
-	getNewVerifyingKey                    *connect.Client[v1.GetNewVerifyingKeyRequest, v1.GetNewVerifyingKeyResponse]
-	decryptMsg                            *connect.Client[v1.DecryptMsgRequest, v1.DecryptMsgResponse]
-	encryptMsg                            *connect.Client[v1.EncryptMsgRequest, v1.EncryptMsgResponse]
-	signArbitraryMsg                      *connect.Client[v1.SignArbitraryMsgRequest, v1.SignArbitraryMsgResponse]
-	signArbitraryMsgAsAddr                *connect.Client[v1.SignArbitraryMsgAsAddrRequest, v1.SignArbitraryMsgAsAddrResponse]
-	verifySignature                       *connect.Client[v1.VerifySignatureRequest, v1.VerifySignatureResponse]
-	getWalletAddresses                    *connect.Client[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse]
-	myUnconfirmedUtxos                    *connect.Client[v1.MyUnconfirmedUtxosRequest, v1.MyUnconfirmedUtxosResponse]
-	openapiSchema                         *connect.Client[v1.OpenapiSchemaRequest, v1.OpenapiSchemaResponse]
-	ammBurn                               *connect.Client[v1.AmmBurnRequest, v1.AmmBurnResponse]
-	ammMint                               *connect.Client[v1.AmmMintRequest, v1.AmmMintResponse]
-	ammSwap                               *connect.Client[v1.AmmSwapRequest, v1.AmmSwapResponse]
-	getAmmPoolState                       *connect.Client[v1.GetAmmPoolStateRequest, v1.GetAmmPoolStateResponse]
-	getAmmPrice                           *connect.Client[v1.GetAmmPriceRequest, v1.GetAmmPriceResponse]
-	dutchAuctionBid                       *connect.Client[v1.DutchAuctionBidRequest, v1.DutchAuctionBidResponse]
-	dutchAuctionCollect                   *connect.Client[v1.DutchAuctionCollectRequest, v1.DutchAuctionCollectResponse]
-	dutchAuctionCreate                    *connect.Client[v1.DutchAuctionCreateRequest, v1.DutchAuctionCreateResponse]
-	dutchAuctions                         *connect.Client[v1.DutchAuctionsRequest, v1.DutchAuctionsResponse]
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetBitAssetData(context.Context, *v1.GetBitAssetDataRequest) (*v1.GetBitAssetDataResponse, error)
+	ListBitAssets(context.Context, *v1.ListBitAssetsRequest) (*v1.ListBitAssetsResponse, error)
+	RegisterBitAsset(context.Context, *v1.RegisterBitAssetRequest) (*v1.RegisterBitAssetResponse, error)
+	ReserveBitAsset(context.Context, *v1.ReserveBitAssetRequest) (*v1.ReserveBitAssetResponse, error)
+	TransferBitAsset(context.Context, *v1.TransferBitAssetRequest) (*v1.TransferBitAssetResponse, error)
+	GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error)
+	GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error)
+	DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error)
+	EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error)
+	SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error)
+	SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error)
+	VerifySignature(context.Context, *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	MyUnconfirmedUtxos(context.Context, *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error)
+	OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error)
+	AmmBurn(context.Context, *v1.AmmBurnRequest) (*v1.AmmBurnResponse, error)
+	AmmMint(context.Context, *v1.AmmMintRequest) (*v1.AmmMintResponse, error)
+	AmmSwap(context.Context, *v1.AmmSwapRequest) (*v1.AmmSwapResponse, error)
+	GetAmmPoolState(context.Context, *v1.GetAmmPoolStateRequest) (*v1.GetAmmPoolStateResponse, error)
+	GetAmmPrice(context.Context, *v1.GetAmmPriceRequest) (*v1.GetAmmPriceResponse, error)
+	DutchAuctionBid(context.Context, *v1.DutchAuctionBidRequest) (*v1.DutchAuctionBidResponse, error)
+	DutchAuctionCollect(context.Context, *v1.DutchAuctionCollectRequest) (*v1.DutchAuctionCollectResponse, error)
+	DutchAuctionCreate(context.Context, *v1.DutchAuctionCreateRequest) (*v1.DutchAuctionCreateResponse, error)
+	DutchAuctions(context.Context, *v1.DutchAuctionsRequest) (*v1.DutchAuctionsResponse, error)
+}
+
+// NewBitAssetsServiceClient constructs a client for the bitassets.v1.BitAssetsService service.
+// Multiple service clients may share a single connect.Client.
+func NewBitAssetsServiceClient(client *connect.Client) BitAssetsServiceClient {
+	return &bitAssetsServiceClient{client: client}
 }
 
-// GetBalance calls bitassets.v1.BitAssetsService.GetBalance.
-func (c *bitAssetsServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// BitAssetsServiceHandler is an implementation of the bitassets.v1.BitAssetsService service.
+type BitAssetsServiceHandler interface {
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetBitAssetData(context.Context, *v1.GetBitAssetDataRequest) (*v1.GetBitAssetDataResponse, error)
+	ListBitAssets(context.Context, *v1.ListBitAssetsRequest) (*v1.ListBitAssetsResponse, error)
+	RegisterBitAsset(context.Context, *v1.RegisterBitAssetRequest) (*v1.RegisterBitAssetResponse, error)
+	ReserveBitAsset(context.Context, *v1.ReserveBitAssetRequest) (*v1.ReserveBitAssetResponse, error)
+	TransferBitAsset(context.Context, *v1.TransferBitAssetRequest) (*v1.TransferBitAssetResponse, error)
+	GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error)
+	GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error)
+	DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error)
+	EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error)
+	SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error)
+	SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error)
+	VerifySignature(context.Context, *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	MyUnconfirmedUtxos(context.Context, *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error)
+	OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error)
+	AmmBurn(context.Context, *v1.AmmBurnRequest) (*v1.AmmBurnResponse, error)
+	AmmMint(context.Context, *v1.AmmMintRequest) (*v1.AmmMintResponse, error)
+	AmmSwap(context.Context, *v1.AmmSwapRequest) (*v1.AmmSwapResponse, error)
+	GetAmmPoolState(context.Context, *v1.GetAmmPoolStateRequest) (*v1.GetAmmPoolStateResponse, error)
+	GetAmmPrice(context.Context, *v1.GetAmmPriceRequest) (*v1.GetAmmPriceResponse, error)
+	DutchAuctionBid(context.Context, *v1.DutchAuctionBidRequest) (*v1.DutchAuctionBidResponse, error)
+	DutchAuctionCollect(context.Context, *v1.DutchAuctionCollectRequest) (*v1.DutchAuctionCollectResponse, error)
+	DutchAuctionCreate(context.Context, *v1.DutchAuctionCreateRequest) (*v1.DutchAuctionCreateResponse, error)
+	DutchAuctions(context.Context, *v1.DutchAuctionsRequest) (*v1.DutchAuctionsResponse, error)
+}
+
+// RegisterBitAssetsServiceHandler registers svc as the bitassets.v1.BitAssetsService implementation
+// on server.
+func RegisterBitAssetsServiceHandler(server *connect.Server, svc BitAssetsServiceHandler) {
+	adapter := bitAssetsServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: bitAssetsServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: bitAssetsServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: bitAssetsServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: bitAssetsServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: bitAssetsServiceWithdrawSpec(), Handler: adapter.withdraw},
+		connect.Method{Spec: bitAssetsServiceTransferSpec(), Handler: adapter.transfer},
+		connect.Method{Spec: bitAssetsServiceGetSidechainWealthSpec(), Handler: adapter.getSidechainWealth},
+		connect.Method{Spec: bitAssetsServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: bitAssetsServiceGetPendingWithdrawalBundleSpec(), Handler: adapter.getPendingWithdrawalBundle},
+		connect.Method{Spec: bitAssetsServiceConnectPeerSpec(), Handler: adapter.connectPeer},
+		connect.Method{Spec: bitAssetsServiceForgetPeerSpec(), Handler: adapter.forgetPeer},
+		connect.Method{Spec: bitAssetsServiceListPeersSpec(), Handler: adapter.listPeers},
+		connect.Method{Spec: bitAssetsServiceMineSpec(), Handler: adapter.mine},
+		connect.Method{Spec: bitAssetsServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: bitAssetsServiceGetBestMainchainBlockHashSpec(), Handler: adapter.getBestMainchainBlockHash},
+		connect.Method{Spec: bitAssetsServiceGetBestSidechainBlockHashSpec(), Handler: adapter.getBestSidechainBlockHash},
+		connect.Method{Spec: bitAssetsServiceGetBmmInclusionsSpec(), Handler: adapter.getBmmInclusions},
+		connect.Method{Spec: bitAssetsServiceGetWalletUtxosSpec(), Handler: adapter.getWalletUtxos},
+		connect.Method{Spec: bitAssetsServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: bitAssetsServiceRemoveFromMempoolSpec(), Handler: adapter.removeFromMempool},
+		connect.Method{Spec: bitAssetsServiceGetLatestFailedWithdrawalBundleHeightSpec(), Handler: adapter.getLatestFailedWithdrawalBundleHeight},
+		connect.Method{Spec: bitAssetsServiceGenerateMnemonicSpec(), Handler: adapter.generateMnemonic},
+		connect.Method{Spec: bitAssetsServiceSetSeedFromMnemonicSpec(), Handler: adapter.setSeedFromMnemonic},
+		connect.Method{Spec: bitAssetsServiceCallRawSpec(), Handler: adapter.callRaw},
+		connect.Method{Spec: bitAssetsServiceGetBitAssetDataSpec(), Handler: adapter.getBitAssetData},
+		connect.Method{Spec: bitAssetsServiceListBitAssetsSpec(), Handler: adapter.listBitAssets},
+		connect.Method{Spec: bitAssetsServiceRegisterBitAssetSpec(), Handler: adapter.registerBitAsset},
+		connect.Method{Spec: bitAssetsServiceReserveBitAssetSpec(), Handler: adapter.reserveBitAsset},
+		connect.Method{Spec: bitAssetsServiceTransferBitAssetSpec(), Handler: adapter.transferBitAsset},
+		connect.Method{Spec: bitAssetsServiceGetNewEncryptionKeySpec(), Handler: adapter.getNewEncryptionKey},
+		connect.Method{Spec: bitAssetsServiceGetNewVerifyingKeySpec(), Handler: adapter.getNewVerifyingKey},
+		connect.Method{Spec: bitAssetsServiceDecryptMsgSpec(), Handler: adapter.decryptMsg},
+		connect.Method{Spec: bitAssetsServiceEncryptMsgSpec(), Handler: adapter.encryptMsg},
+		connect.Method{Spec: bitAssetsServiceSignArbitraryMsgSpec(), Handler: adapter.signArbitraryMsg},
+		connect.Method{Spec: bitAssetsServiceSignArbitraryMsgAsAddrSpec(), Handler: adapter.signArbitraryMsgAsAddr},
+		connect.Method{Spec: bitAssetsServiceVerifySignatureSpec(), Handler: adapter.verifySignature},
+		connect.Method{Spec: bitAssetsServiceGetWalletAddressesSpec(), Handler: adapter.getWalletAddresses},
+		connect.Method{Spec: bitAssetsServiceMyUnconfirmedUtxosSpec(), Handler: adapter.myUnconfirmedUtxos},
+		connect.Method{Spec: bitAssetsServiceOpenapiSchemaSpec(), Handler: adapter.openapiSchema},
+		connect.Method{Spec: bitAssetsServiceAmmBurnSpec(), Handler: adapter.ammBurn},
+		connect.Method{Spec: bitAssetsServiceAmmMintSpec(), Handler: adapter.ammMint},
+		connect.Method{Spec: bitAssetsServiceAmmSwapSpec(), Handler: adapter.ammSwap},
+		connect.Method{Spec: bitAssetsServiceGetAmmPoolStateSpec(), Handler: adapter.getAmmPoolState},
+		connect.Method{Spec: bitAssetsServiceGetAmmPriceSpec(), Handler: adapter.getAmmPrice},
+		connect.Method{Spec: bitAssetsServiceDutchAuctionBidSpec(), Handler: adapter.dutchAuctionBid},
+		connect.Method{Spec: bitAssetsServiceDutchAuctionCollectSpec(), Handler: adapter.dutchAuctionCollect},
+		connect.Method{Spec: bitAssetsServiceDutchAuctionCreateSpec(), Handler: adapter.dutchAuctionCreate},
+		connect.Method{Spec: bitAssetsServiceDutchAuctionsSpec(), Handler: adapter.dutchAuctions},
+	)
 }
 
-// GetBlockCount calls bitassets.v1.BitAssetsService.GetBlockCount.
-func (c *bitAssetsServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// UnimplementedBitAssetsServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBitAssetsServiceHandler struct{}
+
+func (UnimplementedBitAssetsServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetBalance is not implemented")
 }
 
-// Stop calls bitassets.v1.BitAssetsService.Stop.
-func (c *bitAssetsServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetBlockCount is not implemented")
 }
 
-// GetNewAddress calls bitassets.v1.BitAssetsService.GetNewAddress.
-func (c *bitAssetsServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.Stop is not implemented")
 }
 
-// Withdraw calls bitassets.v1.BitAssetsService.Withdraw.
-func (c *bitAssetsServiceClient) Withdraw(ctx context.Context, req *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return c.withdraw.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetNewAddress is not implemented")
 }
 
-// Transfer calls bitassets.v1.BitAssetsService.Transfer.
-func (c *bitAssetsServiceClient) Transfer(ctx context.Context, req *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return c.transfer.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.Withdraw is not implemented")
 }
 
-// GetSidechainWealth calls bitassets.v1.BitAssetsService.GetSidechainWealth.
-func (c *bitAssetsServiceClient) GetSidechainWealth(ctx context.Context, req *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return c.getSidechainWealth.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.Transfer is not implemented")
 }
 
-// CreateDeposit calls bitassets.v1.BitAssetsService.CreateDeposit.
-func (c *bitAssetsServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetSidechainWealth is not implemented")
 }
 
-// GetPendingWithdrawalBundle calls bitassets.v1.BitAssetsService.GetPendingWithdrawalBundle.
-func (c *bitAssetsServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return c.getPendingWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.CreateDeposit is not implemented")
 }
 
-// ConnectPeer calls bitassets.v1.BitAssetsService.ConnectPeer.
-func (c *bitAssetsServiceClient) ConnectPeer(ctx context.Context, req *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return c.connectPeer.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetPendingWithdrawalBundle is not implemented")
 }
 
-// ForgetPeer calls bitassets.v1.BitAssetsService.ForgetPeer.
-func (c *bitAssetsServiceClient) ForgetPeer(ctx context.Context, req *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error) {
-	return c.forgetPeer.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.ConnectPeer is not implemented")
 }
 
-// ListPeers calls bitassets.v1.BitAssetsService.ListPeers.
-func (c *bitAssetsServiceClient) ListPeers(ctx context.Context, req *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return c.listPeers.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.ForgetPeer is not implemented")
 }
 
-// Mine calls bitassets.v1.BitAssetsService.Mine.
-func (c *bitAssetsServiceClient) Mine(ctx context.Context, req *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return c.mine.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.ListPeers is not implemented")
 }
 
-// GetBlock calls bitassets.v1.BitAssetsService.GetBlock.
-func (c *bitAssetsServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.Mine is not implemented")
 }
 
-// GetBestMainchainBlockHash calls bitassets.v1.BitAssetsService.GetBestMainchainBlockHash.
-func (c *bitAssetsServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return c.getBestMainchainBlockHash.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetBlock is not implemented")
 }
 
-// GetBestSidechainBlockHash calls bitassets.v1.BitAssetsService.GetBestSidechainBlockHash.
-func (c *bitAssetsServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return c.getBestSidechainBlockHash.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetBestMainchainBlockHash is not implemented")
 }
 
-// GetBmmInclusions calls bitassets.v1.BitAssetsService.GetBmmInclusions.
-func (c *bitAssetsServiceClient) GetBmmInclusions(ctx context.Context, req *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return c.getBmmInclusions.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetBestSidechainBlockHash is not implemented")
 }
 
-// GetWalletUtxos calls bitassets.v1.BitAssetsService.GetWalletUtxos.
-func (c *bitAssetsServiceClient) GetWalletUtxos(ctx context.Context, req *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return c.getWalletUtxos.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetBmmInclusions is not implemented")
 }
 
-// ListUtxos calls bitassets.v1.BitAssetsService.ListUtxos.
-func (c *bitAssetsServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetWalletUtxos is not implemented")
 }
 
-// RemoveFromMempool calls bitassets.v1.BitAssetsService.RemoveFromMempool.
-func (c *bitAssetsServiceClient) RemoveFromMempool(ctx context.Context, req *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return c.removeFromMempool.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.ListUtxos is not implemented")
 }
 
-// GetLatestFailedWithdrawalBundleHeight calls
-// bitassets.v1.BitAssetsService.GetLatestFailedWithdrawalBundleHeight.
-func (c *bitAssetsServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return c.getLatestFailedWithdrawalBundleHeight.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.RemoveFromMempool is not implemented")
 }
 
-// GenerateMnemonic calls bitassets.v1.BitAssetsService.GenerateMnemonic.
-func (c *bitAssetsServiceClient) GenerateMnemonic(ctx context.Context, req *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return c.generateMnemonic.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetLatestFailedWithdrawalBundleHeight is not implemented")
 }
 
-// SetSeedFromMnemonic calls bitassets.v1.BitAssetsService.SetSeedFromMnemonic.
-func (c *bitAssetsServiceClient) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return c.setSeedFromMnemonic.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GenerateMnemonic is not implemented")
 }
 
-// CallRaw calls bitassets.v1.BitAssetsService.CallRaw.
-func (c *bitAssetsServiceClient) CallRaw(ctx context.Context, req *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return c.callRaw.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.SetSeedFromMnemonic is not implemented")
 }
 
-// GetBitAssetData calls bitassets.v1.BitAssetsService.GetBitAssetData.
-func (c *bitAssetsServiceClient) GetBitAssetData(ctx context.Context, req *connect.Request[v1.GetBitAssetDataRequest]) (*connect.Response[v1.GetBitAssetDataResponse], error) {
-	return c.getBitAssetData.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.CallRaw is not implemented")
 }
 
-// ListBitAssets calls bitassets.v1.BitAssetsService.ListBitAssets.
-func (c *bitAssetsServiceClient) ListBitAssets(ctx context.Context, req *connect.Request[v1.ListBitAssetsRequest]) (*connect.Response[v1.ListBitAssetsResponse], error) {
-	return c.listBitAssets.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetBitAssetData(context.Context, *v1.GetBitAssetDataRequest) (*v1.GetBitAssetDataResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetBitAssetData is not implemented")
 }
 
-// RegisterBitAsset calls bitassets.v1.BitAssetsService.RegisterBitAsset.
-func (c *bitAssetsServiceClient) RegisterBitAsset(ctx context.Context, req *connect.Request[v1.RegisterBitAssetRequest]) (*connect.Response[v1.RegisterBitAssetResponse], error) {
-	return c.registerBitAsset.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) ListBitAssets(context.Context, *v1.ListBitAssetsRequest) (*v1.ListBitAssetsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.ListBitAssets is not implemented")
 }
 
-// ReserveBitAsset calls bitassets.v1.BitAssetsService.ReserveBitAsset.
-func (c *bitAssetsServiceClient) ReserveBitAsset(ctx context.Context, req *connect.Request[v1.ReserveBitAssetRequest]) (*connect.Response[v1.ReserveBitAssetResponse], error) {
-	return c.reserveBitAsset.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) RegisterBitAsset(context.Context, *v1.RegisterBitAssetRequest) (*v1.RegisterBitAssetResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.RegisterBitAsset is not implemented")
 }
 
-// TransferBitAsset calls bitassets.v1.BitAssetsService.TransferBitAsset.
-func (c *bitAssetsServiceClient) TransferBitAsset(ctx context.Context, req *connect.Request[v1.TransferBitAssetRequest]) (*connect.Response[v1.TransferBitAssetResponse], error) {
-	return c.transferBitAsset.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) ReserveBitAsset(context.Context, *v1.ReserveBitAssetRequest) (*v1.ReserveBitAssetResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.ReserveBitAsset is not implemented")
 }
 
-// GetNewEncryptionKey calls bitassets.v1.BitAssetsService.GetNewEncryptionKey.
-func (c *bitAssetsServiceClient) GetNewEncryptionKey(ctx context.Context, req *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error) {
-	return c.getNewEncryptionKey.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) TransferBitAsset(context.Context, *v1.TransferBitAssetRequest) (*v1.TransferBitAssetResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.TransferBitAsset is not implemented")
 }
 
-// GetNewVerifyingKey calls bitassets.v1.BitAssetsService.GetNewVerifyingKey.
-func (c *bitAssetsServiceClient) GetNewVerifyingKey(ctx context.Context, req *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error) {
-	return c.getNewVerifyingKey.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetNewEncryptionKey is not implemented")
 }
 
-// DecryptMsg calls bitassets.v1.BitAssetsService.DecryptMsg.
-func (c *bitAssetsServiceClient) DecryptMsg(ctx context.Context, req *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error) {
-	return c.decryptMsg.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetNewVerifyingKey is not implemented")
 }
 
-// EncryptMsg calls bitassets.v1.BitAssetsService.EncryptMsg.
-func (c *bitAssetsServiceClient) EncryptMsg(ctx context.Context, req *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error) {
-	return c.encryptMsg.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.DecryptMsg is not implemented")
 }
 
-// SignArbitraryMsg calls bitassets.v1.BitAssetsService.SignArbitraryMsg.
-func (c *bitAssetsServiceClient) SignArbitraryMsg(ctx context.Context, req *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error) {
-	return c.signArbitraryMsg.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.EncryptMsg is not implemented")
 }
 
-// SignArbitraryMsgAsAddr calls bitassets.v1.BitAssetsService.SignArbitraryMsgAsAddr.
-func (c *bitAssetsServiceClient) SignArbitraryMsgAsAddr(ctx context.Context, req *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error) {
-	return c.signArbitraryMsgAsAddr.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.SignArbitraryMsg is not implemented")
 }
 
-// VerifySignature calls bitassets.v1.BitAssetsService.VerifySignature.
-func (c *bitAssetsServiceClient) VerifySignature(ctx context.Context, req *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error) {
-	return c.verifySignature.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.SignArbitraryMsgAsAddr is not implemented")
 }
 
-// GetWalletAddresses calls bitassets.v1.BitAssetsService.GetWalletAddresses.
-func (c *bitAssetsServiceClient) GetWalletAddresses(ctx context.Context, req *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return c.getWalletAddresses.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) VerifySignature(context.Context, *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.VerifySignature is not implemented")
 }
 
-// MyUnconfirmedUtxos calls bitassets.v1.BitAssetsService.MyUnconfirmedUtxos.
-func (c *bitAssetsServiceClient) MyUnconfirmedUtxos(ctx context.Context, req *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error) {
-	return c.myUnconfirmedUtxos.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetWalletAddresses is not implemented")
 }
 
-// OpenapiSchema calls bitassets.v1.BitAssetsService.OpenapiSchema.
-func (c *bitAssetsServiceClient) OpenapiSchema(ctx context.Context, req *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error) {
-	return c.openapiSchema.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) MyUnconfirmedUtxos(context.Context, *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.MyUnconfirmedUtxos is not implemented")
 }
 
-// AmmBurn calls bitassets.v1.BitAssetsService.AmmBurn.
-func (c *bitAssetsServiceClient) AmmBurn(ctx context.Context, req *connect.Request[v1.AmmBurnRequest]) (*connect.Response[v1.AmmBurnResponse], error) {
-	return c.ammBurn.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.OpenapiSchema is not implemented")
 }
 
-// AmmMint calls bitassets.v1.BitAssetsService.AmmMint.
-func (c *bitAssetsServiceClient) AmmMint(ctx context.Context, req *connect.Request[v1.AmmMintRequest]) (*connect.Response[v1.AmmMintResponse], error) {
-	return c.ammMint.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) AmmBurn(context.Context, *v1.AmmBurnRequest) (*v1.AmmBurnResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.AmmBurn is not implemented")
 }
 
-// AmmSwap calls bitassets.v1.BitAssetsService.AmmSwap.
-func (c *bitAssetsServiceClient) AmmSwap(ctx context.Context, req *connect.Request[v1.AmmSwapRequest]) (*connect.Response[v1.AmmSwapResponse], error) {
-	return c.ammSwap.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) AmmMint(context.Context, *v1.AmmMintRequest) (*v1.AmmMintResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.AmmMint is not implemented")
 }
 
-// GetAmmPoolState calls bitassets.v1.BitAssetsService.GetAmmPoolState.
-func (c *bitAssetsServiceClient) GetAmmPoolState(ctx context.Context, req *connect.Request[v1.GetAmmPoolStateRequest]) (*connect.Response[v1.GetAmmPoolStateResponse], error) {
-	return c.getAmmPoolState.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) AmmSwap(context.Context, *v1.AmmSwapRequest) (*v1.AmmSwapResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.AmmSwap is not implemented")
 }
 
-// GetAmmPrice calls bitassets.v1.BitAssetsService.GetAmmPrice.
-func (c *bitAssetsServiceClient) GetAmmPrice(ctx context.Context, req *connect.Request[v1.GetAmmPriceRequest]) (*connect.Response[v1.GetAmmPriceResponse], error) {
-	return c.getAmmPrice.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetAmmPoolState(context.Context, *v1.GetAmmPoolStateRequest) (*v1.GetAmmPoolStateResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetAmmPoolState is not implemented")
 }
 
-// DutchAuctionBid calls bitassets.v1.BitAssetsService.DutchAuctionBid.
-func (c *bitAssetsServiceClient) DutchAuctionBid(ctx context.Context, req *connect.Request[v1.DutchAuctionBidRequest]) (*connect.Response[v1.DutchAuctionBidResponse], error) {
-	return c.dutchAuctionBid.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) GetAmmPrice(context.Context, *v1.GetAmmPriceRequest) (*v1.GetAmmPriceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.GetAmmPrice is not implemented")
 }
 
-// DutchAuctionCollect calls bitassets.v1.BitAssetsService.DutchAuctionCollect.
-func (c *bitAssetsServiceClient) DutchAuctionCollect(ctx context.Context, req *connect.Request[v1.DutchAuctionCollectRequest]) (*connect.Response[v1.DutchAuctionCollectResponse], error) {
-	return c.dutchAuctionCollect.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) DutchAuctionBid(context.Context, *v1.DutchAuctionBidRequest) (*v1.DutchAuctionBidResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.DutchAuctionBid is not implemented")
 }
 
-// DutchAuctionCreate calls bitassets.v1.BitAssetsService.DutchAuctionCreate.
-func (c *bitAssetsServiceClient) DutchAuctionCreate(ctx context.Context, req *connect.Request[v1.DutchAuctionCreateRequest]) (*connect.Response[v1.DutchAuctionCreateResponse], error) {
-	return c.dutchAuctionCreate.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) DutchAuctionCollect(context.Context, *v1.DutchAuctionCollectRequest) (*v1.DutchAuctionCollectResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.DutchAuctionCollect is not implemented")
 }
 
-// DutchAuctions calls bitassets.v1.BitAssetsService.DutchAuctions.
-func (c *bitAssetsServiceClient) DutchAuctions(ctx context.Context, req *connect.Request[v1.DutchAuctionsRequest]) (*connect.Response[v1.DutchAuctionsResponse], error) {
-	return c.dutchAuctions.CallUnary(ctx, req)
+func (UnimplementedBitAssetsServiceHandler) DutchAuctionCreate(context.Context, *v1.DutchAuctionCreateRequest) (*v1.DutchAuctionCreateResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.DutchAuctionCreate is not implemented")
 }
 
-// BitAssetsServiceHandler is an implementation of the bitassets.v1.BitAssetsService service.
-type BitAssetsServiceHandler interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the bitassets node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// Forget a peer.
-	ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get BitAsset data by asset ID.
-	GetBitAssetData(context.Context, *connect.Request[v1.GetBitAssetDataRequest]) (*connect.Response[v1.GetBitAssetDataResponse], error)
-	// List all BitAssets.
-	ListBitAssets(context.Context, *connect.Request[v1.ListBitAssetsRequest]) (*connect.Response[v1.ListBitAssetsResponse], error)
-	// Register a BitAsset.
-	RegisterBitAsset(context.Context, *connect.Request[v1.RegisterBitAssetRequest]) (*connect.Response[v1.RegisterBitAssetResponse], error)
-	// Reserve a BitAsset.
-	ReserveBitAsset(context.Context, *connect.Request[v1.ReserveBitAssetRequest]) (*connect.Response[v1.ReserveBitAssetResponse], error)
-	// Transfer a BitAsset token.
-	TransferBitAsset(context.Context, *connect.Request[v1.TransferBitAssetRequest]) (*connect.Response[v1.TransferBitAssetResponse], error)
-	// Get a new encryption key.
-	GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error)
-	// Get a new verifying key.
-	GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error)
-	// Decrypt a message.
-	DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error)
-	// Encrypt a message.
-	EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error)
-	// Sign an arbitrary message with the specified verifying key.
-	SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error)
-	// Sign an arbitrary message as a specific address.
-	SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error)
-	// Verify a signature.
-	VerifySignature(context.Context, *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// List unconfirmed owned UTXOs.
-	MyUnconfirmedUtxos(context.Context, *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error)
-	// Get OpenAPI schema.
-	OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error)
-	// Burn an AMM position.
-	AmmBurn(context.Context, *connect.Request[v1.AmmBurnRequest]) (*connect.Response[v1.AmmBurnResponse], error)
-	// Mint an AMM position.
-	AmmMint(context.Context, *connect.Request[v1.AmmMintRequest]) (*connect.Response[v1.AmmMintResponse], error)
-	// AMM swap.
-	AmmSwap(context.Context, *connect.Request[v1.AmmSwapRequest]) (*connect.Response[v1.AmmSwapResponse], error)
-	// Get the state of the specified AMM pool.
-	GetAmmPoolState(context.Context, *connect.Request[v1.GetAmmPoolStateRequest]) (*connect.Response[v1.GetAmmPoolStateResponse], error)
-	// Get the current price for the specified pair.
-	GetAmmPrice(context.Context, *connect.Request[v1.GetAmmPriceRequest]) (*connect.Response[v1.GetAmmPriceResponse], error)
-	// Bid on a dutch auction.
-	DutchAuctionBid(context.Context, *connect.Request[v1.DutchAuctionBidRequest]) (*connect.Response[v1.DutchAuctionBidResponse], error)
-	// Collect from a dutch auction.
-	DutchAuctionCollect(context.Context, *connect.Request[v1.DutchAuctionCollectRequest]) (*connect.Response[v1.DutchAuctionCollectResponse], error)
-	// Create a dutch auction.
-	DutchAuctionCreate(context.Context, *connect.Request[v1.DutchAuctionCreateRequest]) (*connect.Response[v1.DutchAuctionCreateResponse], error)
-	// List all dutch auctions.
-	DutchAuctions(context.Context, *connect.Request[v1.DutchAuctionsRequest]) (*connect.Response[v1.DutchAuctionsResponse], error)
-}
-
-// NewBitAssetsServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBitAssetsServiceHandler(svc BitAssetsServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	bitAssetsServiceMethods := v1.File_bitassets_v1_bitassets_proto.Services().ByName("BitAssetsService").Methods()
-	bitAssetsServiceGetBalanceHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceStopHandler := connect.NewUnaryHandler(
-		BitAssetsServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceWithdrawHandler := connect.NewUnaryHandler(
-		BitAssetsServiceWithdrawProcedure,
-		svc.Withdraw,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("Withdraw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceTransferHandler := connect.NewUnaryHandler(
-		BitAssetsServiceTransferProcedure,
-		svc.Transfer,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("Transfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetSidechainWealthHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetSidechainWealthProcedure,
-		svc.GetSidechainWealth,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetSidechainWealth")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceCreateDepositHandler := connect.NewUnaryHandler(
-		BitAssetsServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetPendingWithdrawalBundleHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetPendingWithdrawalBundleProcedure,
-		svc.GetPendingWithdrawalBundle,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetPendingWithdrawalBundle")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceConnectPeerHandler := connect.NewUnaryHandler(
-		BitAssetsServiceConnectPeerProcedure,
-		svc.ConnectPeer,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("ConnectPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceForgetPeerHandler := connect.NewUnaryHandler(
-		BitAssetsServiceForgetPeerProcedure,
-		svc.ForgetPeer,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("ForgetPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceListPeersHandler := connect.NewUnaryHandler(
-		BitAssetsServiceListPeersProcedure,
-		svc.ListPeers,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("ListPeers")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceMineHandler := connect.NewUnaryHandler(
-		BitAssetsServiceMineProcedure,
-		svc.Mine,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("Mine")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetBlockHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetBestMainchainBlockHashHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetBestMainchainBlockHashProcedure,
-		svc.GetBestMainchainBlockHash,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetBestMainchainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetBestSidechainBlockHashHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetBestSidechainBlockHashProcedure,
-		svc.GetBestSidechainBlockHash,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetBestSidechainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetBmmInclusionsHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetBmmInclusionsProcedure,
-		svc.GetBmmInclusions,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetBmmInclusions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetWalletUtxosHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetWalletUtxosProcedure,
-		svc.GetWalletUtxos,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetWalletUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceListUtxosHandler := connect.NewUnaryHandler(
-		BitAssetsServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceRemoveFromMempoolHandler := connect.NewUnaryHandler(
-		BitAssetsServiceRemoveFromMempoolProcedure,
-		svc.RemoveFromMempool,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("RemoveFromMempool")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetLatestFailedWithdrawalBundleHeightHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-		svc.GetLatestFailedWithdrawalBundleHeight,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGenerateMnemonicHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGenerateMnemonicProcedure,
-		svc.GenerateMnemonic,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GenerateMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceSetSeedFromMnemonicHandler := connect.NewUnaryHandler(
-		BitAssetsServiceSetSeedFromMnemonicProcedure,
-		svc.SetSeedFromMnemonic,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("SetSeedFromMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceCallRawHandler := connect.NewUnaryHandler(
-		BitAssetsServiceCallRawProcedure,
-		svc.CallRaw,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("CallRaw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetBitAssetDataHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetBitAssetDataProcedure,
-		svc.GetBitAssetData,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetBitAssetData")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceListBitAssetsHandler := connect.NewUnaryHandler(
-		BitAssetsServiceListBitAssetsProcedure,
-		svc.ListBitAssets,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("ListBitAssets")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceRegisterBitAssetHandler := connect.NewUnaryHandler(
-		BitAssetsServiceRegisterBitAssetProcedure,
-		svc.RegisterBitAsset,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("RegisterBitAsset")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceReserveBitAssetHandler := connect.NewUnaryHandler(
-		BitAssetsServiceReserveBitAssetProcedure,
-		svc.ReserveBitAsset,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("ReserveBitAsset")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceTransferBitAssetHandler := connect.NewUnaryHandler(
-		BitAssetsServiceTransferBitAssetProcedure,
-		svc.TransferBitAsset,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("TransferBitAsset")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetNewEncryptionKeyHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetNewEncryptionKeyProcedure,
-		svc.GetNewEncryptionKey,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetNewEncryptionKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetNewVerifyingKeyHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetNewVerifyingKeyProcedure,
-		svc.GetNewVerifyingKey,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetNewVerifyingKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceDecryptMsgHandler := connect.NewUnaryHandler(
-		BitAssetsServiceDecryptMsgProcedure,
-		svc.DecryptMsg,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("DecryptMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceEncryptMsgHandler := connect.NewUnaryHandler(
-		BitAssetsServiceEncryptMsgProcedure,
-		svc.EncryptMsg,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("EncryptMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceSignArbitraryMsgHandler := connect.NewUnaryHandler(
-		BitAssetsServiceSignArbitraryMsgProcedure,
-		svc.SignArbitraryMsg,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("SignArbitraryMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceSignArbitraryMsgAsAddrHandler := connect.NewUnaryHandler(
-		BitAssetsServiceSignArbitraryMsgAsAddrProcedure,
-		svc.SignArbitraryMsgAsAddr,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("SignArbitraryMsgAsAddr")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceVerifySignatureHandler := connect.NewUnaryHandler(
-		BitAssetsServiceVerifySignatureProcedure,
-		svc.VerifySignature,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("VerifySignature")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetWalletAddressesHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetWalletAddressesProcedure,
-		svc.GetWalletAddresses,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetWalletAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceMyUnconfirmedUtxosHandler := connect.NewUnaryHandler(
-		BitAssetsServiceMyUnconfirmedUtxosProcedure,
-		svc.MyUnconfirmedUtxos,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("MyUnconfirmedUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceOpenapiSchemaHandler := connect.NewUnaryHandler(
-		BitAssetsServiceOpenapiSchemaProcedure,
-		svc.OpenapiSchema,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("OpenapiSchema")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceAmmBurnHandler := connect.NewUnaryHandler(
-		BitAssetsServiceAmmBurnProcedure,
-		svc.AmmBurn,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("AmmBurn")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceAmmMintHandler := connect.NewUnaryHandler(
-		BitAssetsServiceAmmMintProcedure,
-		svc.AmmMint,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("AmmMint")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceAmmSwapHandler := connect.NewUnaryHandler(
-		BitAssetsServiceAmmSwapProcedure,
-		svc.AmmSwap,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("AmmSwap")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetAmmPoolStateHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetAmmPoolStateProcedure,
-		svc.GetAmmPoolState,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetAmmPoolState")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceGetAmmPriceHandler := connect.NewUnaryHandler(
-		BitAssetsServiceGetAmmPriceProcedure,
-		svc.GetAmmPrice,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("GetAmmPrice")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceDutchAuctionBidHandler := connect.NewUnaryHandler(
-		BitAssetsServiceDutchAuctionBidProcedure,
-		svc.DutchAuctionBid,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctionBid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceDutchAuctionCollectHandler := connect.NewUnaryHandler(
-		BitAssetsServiceDutchAuctionCollectProcedure,
-		svc.DutchAuctionCollect,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctionCollect")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceDutchAuctionCreateHandler := connect.NewUnaryHandler(
-		BitAssetsServiceDutchAuctionCreateProcedure,
-		svc.DutchAuctionCreate,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctionCreate")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitAssetsServiceDutchAuctionsHandler := connect.NewUnaryHandler(
-		BitAssetsServiceDutchAuctionsProcedure,
-		svc.DutchAuctions,
-		connect.WithSchema(bitAssetsServiceMethods.ByName("DutchAuctions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/bitassets.v1.BitAssetsService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BitAssetsServiceGetBalanceProcedure:
-			bitAssetsServiceGetBalanceHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetBlockCountProcedure:
-			bitAssetsServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case BitAssetsServiceStopProcedure:
-			bitAssetsServiceStopHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetNewAddressProcedure:
-			bitAssetsServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case BitAssetsServiceWithdrawProcedure:
-			bitAssetsServiceWithdrawHandler.ServeHTTP(w, r)
-		case BitAssetsServiceTransferProcedure:
-			bitAssetsServiceTransferHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetSidechainWealthProcedure:
-			bitAssetsServiceGetSidechainWealthHandler.ServeHTTP(w, r)
-		case BitAssetsServiceCreateDepositProcedure:
-			bitAssetsServiceCreateDepositHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetPendingWithdrawalBundleProcedure:
-			bitAssetsServiceGetPendingWithdrawalBundleHandler.ServeHTTP(w, r)
-		case BitAssetsServiceConnectPeerProcedure:
-			bitAssetsServiceConnectPeerHandler.ServeHTTP(w, r)
-		case BitAssetsServiceForgetPeerProcedure:
-			bitAssetsServiceForgetPeerHandler.ServeHTTP(w, r)
-		case BitAssetsServiceListPeersProcedure:
-			bitAssetsServiceListPeersHandler.ServeHTTP(w, r)
-		case BitAssetsServiceMineProcedure:
-			bitAssetsServiceMineHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetBlockProcedure:
-			bitAssetsServiceGetBlockHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetBestMainchainBlockHashProcedure:
-			bitAssetsServiceGetBestMainchainBlockHashHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetBestSidechainBlockHashProcedure:
-			bitAssetsServiceGetBestSidechainBlockHashHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetBmmInclusionsProcedure:
-			bitAssetsServiceGetBmmInclusionsHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetWalletUtxosProcedure:
-			bitAssetsServiceGetWalletUtxosHandler.ServeHTTP(w, r)
-		case BitAssetsServiceListUtxosProcedure:
-			bitAssetsServiceListUtxosHandler.ServeHTTP(w, r)
-		case BitAssetsServiceRemoveFromMempoolProcedure:
-			bitAssetsServiceRemoveFromMempoolHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetLatestFailedWithdrawalBundleHeightProcedure:
-			bitAssetsServiceGetLatestFailedWithdrawalBundleHeightHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGenerateMnemonicProcedure:
-			bitAssetsServiceGenerateMnemonicHandler.ServeHTTP(w, r)
-		case BitAssetsServiceSetSeedFromMnemonicProcedure:
-			bitAssetsServiceSetSeedFromMnemonicHandler.ServeHTTP(w, r)
-		case BitAssetsServiceCallRawProcedure:
-			bitAssetsServiceCallRawHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetBitAssetDataProcedure:
-			bitAssetsServiceGetBitAssetDataHandler.ServeHTTP(w, r)
-		case BitAssetsServiceListBitAssetsProcedure:
-			bitAssetsServiceListBitAssetsHandler.ServeHTTP(w, r)
-		case BitAssetsServiceRegisterBitAssetProcedure:
-			bitAssetsServiceRegisterBitAssetHandler.ServeHTTP(w, r)
-		case BitAssetsServiceReserveBitAssetProcedure:
-			bitAssetsServiceReserveBitAssetHandler.ServeHTTP(w, r)
-		case BitAssetsServiceTransferBitAssetProcedure:
-			bitAssetsServiceTransferBitAssetHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetNewEncryptionKeyProcedure:
-			bitAssetsServiceGetNewEncryptionKeyHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetNewVerifyingKeyProcedure:
-			bitAssetsServiceGetNewVerifyingKeyHandler.ServeHTTP(w, r)
-		case BitAssetsServiceDecryptMsgProcedure:
-			bitAssetsServiceDecryptMsgHandler.ServeHTTP(w, r)
-		case BitAssetsServiceEncryptMsgProcedure:
-			bitAssetsServiceEncryptMsgHandler.ServeHTTP(w, r)
-		case BitAssetsServiceSignArbitraryMsgProcedure:
-			bitAssetsServiceSignArbitraryMsgHandler.ServeHTTP(w, r)
-		case BitAssetsServiceSignArbitraryMsgAsAddrProcedure:
-			bitAssetsServiceSignArbitraryMsgAsAddrHandler.ServeHTTP(w, r)
-		case BitAssetsServiceVerifySignatureProcedure:
-			bitAssetsServiceVerifySignatureHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetWalletAddressesProcedure:
-			bitAssetsServiceGetWalletAddressesHandler.ServeHTTP(w, r)
-		case BitAssetsServiceMyUnconfirmedUtxosProcedure:
-			bitAssetsServiceMyUnconfirmedUtxosHandler.ServeHTTP(w, r)
-		case BitAssetsServiceOpenapiSchemaProcedure:
-			bitAssetsServiceOpenapiSchemaHandler.ServeHTTP(w, r)
-		case BitAssetsServiceAmmBurnProcedure:
-			bitAssetsServiceAmmBurnHandler.ServeHTTP(w, r)
-		case BitAssetsServiceAmmMintProcedure:
-			bitAssetsServiceAmmMintHandler.ServeHTTP(w, r)
-		case BitAssetsServiceAmmSwapProcedure:
-			bitAssetsServiceAmmSwapHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetAmmPoolStateProcedure:
-			bitAssetsServiceGetAmmPoolStateHandler.ServeHTTP(w, r)
-		case BitAssetsServiceGetAmmPriceProcedure:
-			bitAssetsServiceGetAmmPriceHandler.ServeHTTP(w, r)
-		case BitAssetsServiceDutchAuctionBidProcedure:
-			bitAssetsServiceDutchAuctionBidHandler.ServeHTTP(w, r)
-		case BitAssetsServiceDutchAuctionCollectProcedure:
-			bitAssetsServiceDutchAuctionCollectHandler.ServeHTTP(w, r)
-		case BitAssetsServiceDutchAuctionCreateProcedure:
-			bitAssetsServiceDutchAuctionCreateHandler.ServeHTTP(w, r)
-		case BitAssetsServiceDutchAuctionsProcedure:
-			bitAssetsServiceDutchAuctionsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedBitAssetsServiceHandler) DutchAuctions(context.Context, *v1.DutchAuctionsRequest) (*v1.DutchAuctionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitassets.v1.BitAssetsService.DutchAuctions is not implemented")
 }
 
-// UnimplementedBitAssetsServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBitAssetsServiceHandler struct{}
+type bitAssetsServiceClient struct {
+	client *connect.Client
+}
+
+func (c *bitAssetsServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) Withdraw(ctx context.Context, req *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	var res v1.WithdrawResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceWithdrawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) Transfer(ctx context.Context, req *v1.TransferRequest) (*v1.TransferResponse, error) {
+	var res v1.TransferResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) GetSidechainWealth(ctx context.Context, req *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	var res v1.GetSidechainWealthResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetSidechainWealthSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	var res v1.GetPendingWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetPendingWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) ConnectPeer(ctx context.Context, req *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	var res v1.ConnectPeerResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceConnectPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitAssetsServiceClient) ForgetPeer(ctx context.Context, req *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error) {
+	var res v1.ForgetPeerResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceForgetPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedBitAssetsServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetBalance is not implemented"))
+func (c *bitAssetsServiceClient) ListPeers(ctx context.Context, req *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	var res v1.ListPeersResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceListPeersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetBlockCount is not implemented"))
+func (c *bitAssetsServiceClient) Mine(ctx context.Context, req *v1.MineRequest) (*v1.MineResponse, error) {
+	var res v1.MineResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceMineSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.Stop is not implemented"))
+func (c *bitAssetsServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetNewAddress is not implemented"))
+func (c *bitAssetsServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	var res v1.GetBestMainchainBlockHashResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetBestMainchainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.Withdraw is not implemented"))
+func (c *bitAssetsServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	var res v1.GetBestSidechainBlockHashResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetBestSidechainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.Transfer is not implemented"))
+func (c *bitAssetsServiceClient) GetBmmInclusions(ctx context.Context, req *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	var res v1.GetBmmInclusionsResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetBmmInclusionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetSidechainWealth is not implemented"))
+func (c *bitAssetsServiceClient) GetWalletUtxos(ctx context.Context, req *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	var res v1.GetWalletUtxosResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetWalletUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.CreateDeposit is not implemented"))
+func (c *bitAssetsServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetPendingWithdrawalBundle is not implemented"))
+func (c *bitAssetsServiceClient) RemoveFromMempool(ctx context.Context, req *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	var res v1.RemoveFromMempoolResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceRemoveFromMempoolSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.ConnectPeer is not implemented"))
+func (c *bitAssetsServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	var res v1.GetLatestFailedWithdrawalBundleHeightResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetLatestFailedWithdrawalBundleHeightSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.ForgetPeer is not implemented"))
+func (c *bitAssetsServiceClient) GenerateMnemonic(ctx context.Context, req *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	var res v1.GenerateMnemonicResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGenerateMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.ListPeers is not implemented"))
+func (c *bitAssetsServiceClient) SetSeedFromMnemonic(ctx context.Context, req *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	var res v1.SetSeedFromMnemonicResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceSetSeedFromMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.Mine is not implemented"))
+func (c *bitAssetsServiceClient) CallRaw(ctx context.Context, req *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	var res v1.CallRawResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceCallRawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetBlock is not implemented"))
+func (c *bitAssetsServiceClient) GetBitAssetData(ctx context.Context, req *v1.GetBitAssetDataRequest) (*v1.GetBitAssetDataResponse, error) {
+	var res v1.GetBitAssetDataResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetBitAssetDataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetBestMainchainBlockHash is not implemented"))
+func (c *bitAssetsServiceClient) ListBitAssets(ctx context.Context, req *v1.ListBitAssetsRequest) (*v1.ListBitAssetsResponse, error) {
+	var res v1.ListBitAssetsResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceListBitAssetsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetBestSidechainBlockHash is not implemented"))
+func (c *bitAssetsServiceClient) RegisterBitAsset(ctx context.Context, req *v1.RegisterBitAssetRequest) (*v1.RegisterBitAssetResponse, error) {
+	var res v1.RegisterBitAssetResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceRegisterBitAssetSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetBmmInclusions is not implemented"))
+func (c *bitAssetsServiceClient) ReserveBitAsset(ctx context.Context, req *v1.ReserveBitAssetRequest) (*v1.ReserveBitAssetResponse, error) {
+	var res v1.ReserveBitAssetResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceReserveBitAssetSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetWalletUtxos is not implemented"))
+func (c *bitAssetsServiceClient) TransferBitAsset(ctx context.Context, req *v1.TransferBitAssetRequest) (*v1.TransferBitAssetResponse, error) {
+	var res v1.TransferBitAssetResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceTransferBitAssetSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.ListUtxos is not implemented"))
+func (c *bitAssetsServiceClient) GetNewEncryptionKey(ctx context.Context, req *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error) {
+	var res v1.GetNewEncryptionKeyResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetNewEncryptionKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.RemoveFromMempool is not implemented"))
+func (c *bitAssetsServiceClient) GetNewVerifyingKey(ctx context.Context, req *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error) {
+	var res v1.GetNewVerifyingKeyResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetNewVerifyingKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetLatestFailedWithdrawalBundleHeight is not implemented"))
+func (c *bitAssetsServiceClient) DecryptMsg(ctx context.Context, req *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error) {
+	var res v1.DecryptMsgResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceDecryptMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GenerateMnemonic is not implemented"))
+func (c *bitAssetsServiceClient) EncryptMsg(ctx context.Context, req *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error) {
+	var res v1.EncryptMsgResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceEncryptMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.SetSeedFromMnemonic is not implemented"))
+func (c *bitAssetsServiceClient) SignArbitraryMsg(ctx context.Context, req *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error) {
+	var res v1.SignArbitraryMsgResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceSignArbitraryMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.CallRaw is not implemented"))
+func (c *bitAssetsServiceClient) SignArbitraryMsgAsAddr(ctx context.Context, req *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error) {
+	var res v1.SignArbitraryMsgAsAddrResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceSignArbitraryMsgAsAddrSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetBitAssetData(context.Context, *connect.Request[v1.GetBitAssetDataRequest]) (*connect.Response[v1.GetBitAssetDataResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetBitAssetData is not implemented"))
+func (c *bitAssetsServiceClient) VerifySignature(ctx context.Context, req *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error) {
+	var res v1.VerifySignatureResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceVerifySignatureSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) ListBitAssets(context.Context, *connect.Request[v1.ListBitAssetsRequest]) (*connect.Response[v1.ListBitAssetsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.ListBitAssets is not implemented"))
+func (c *bitAssetsServiceClient) GetWalletAddresses(ctx context.Context, req *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	var res v1.GetWalletAddressesResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetWalletAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) RegisterBitAsset(context.Context, *connect.Request[v1.RegisterBitAssetRequest]) (*connect.Response[v1.RegisterBitAssetResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.RegisterBitAsset is not implemented"))
+func (c *bitAssetsServiceClient) MyUnconfirmedUtxos(ctx context.Context, req *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error) {
+	var res v1.MyUnconfirmedUtxosResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceMyUnconfirmedUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) ReserveBitAsset(context.Context, *connect.Request[v1.ReserveBitAssetRequest]) (*connect.Response[v1.ReserveBitAssetResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.ReserveBitAsset is not implemented"))
+func (c *bitAssetsServiceClient) OpenapiSchema(ctx context.Context, req *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error) {
+	var res v1.OpenapiSchemaResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceOpenapiSchemaSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) TransferBitAsset(context.Context, *connect.Request[v1.TransferBitAssetRequest]) (*connect.Response[v1.TransferBitAssetResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.TransferBitAsset is not implemented"))
+func (c *bitAssetsServiceClient) AmmBurn(ctx context.Context, req *v1.AmmBurnRequest) (*v1.AmmBurnResponse, error) {
+	var res v1.AmmBurnResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceAmmBurnSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetNewEncryptionKey is not implemented"))
+func (c *bitAssetsServiceClient) AmmMint(ctx context.Context, req *v1.AmmMintRequest) (*v1.AmmMintResponse, error) {
+	var res v1.AmmMintResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceAmmMintSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetNewVerifyingKey is not implemented"))
+func (c *bitAssetsServiceClient) AmmSwap(ctx context.Context, req *v1.AmmSwapRequest) (*v1.AmmSwapResponse, error) {
+	var res v1.AmmSwapResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceAmmSwapSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.DecryptMsg is not implemented"))
+func (c *bitAssetsServiceClient) GetAmmPoolState(ctx context.Context, req *v1.GetAmmPoolStateRequest) (*v1.GetAmmPoolStateResponse, error) {
+	var res v1.GetAmmPoolStateResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetAmmPoolStateSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.EncryptMsg is not implemented"))
+func (c *bitAssetsServiceClient) GetAmmPrice(ctx context.Context, req *v1.GetAmmPriceRequest) (*v1.GetAmmPriceResponse, error) {
+	var res v1.GetAmmPriceResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceGetAmmPriceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.SignArbitraryMsg is not implemented"))
+func (c *bitAssetsServiceClient) DutchAuctionBid(ctx context.Context, req *v1.DutchAuctionBidRequest) (*v1.DutchAuctionBidResponse, error) {
+	var res v1.DutchAuctionBidResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceDutchAuctionBidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.SignArbitraryMsgAsAddr is not implemented"))
+func (c *bitAssetsServiceClient) DutchAuctionCollect(ctx context.Context, req *v1.DutchAuctionCollectRequest) (*v1.DutchAuctionCollectResponse, error) {
+	var res v1.DutchAuctionCollectResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceDutchAuctionCollectSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) VerifySignature(context.Context, *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.VerifySignature is not implemented"))
+func (c *bitAssetsServiceClient) DutchAuctionCreate(ctx context.Context, req *v1.DutchAuctionCreateRequest) (*v1.DutchAuctionCreateResponse, error) {
+	var res v1.DutchAuctionCreateResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceDutchAuctionCreateSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetWalletAddresses is not implemented"))
+func (c *bitAssetsServiceClient) DutchAuctions(ctx context.Context, req *v1.DutchAuctionsRequest) (*v1.DutchAuctionsResponse, error) {
+	var res v1.DutchAuctionsResponse
+	if err := c.client.CallUnary(ctx, bitAssetsServiceDutchAuctionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitAssetsServiceHandler) MyUnconfirmedUtxos(context.Context, *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.MyUnconfirmedUtxos is not implemented"))
+type bitAssetsServiceHandler struct{ svc BitAssetsServiceHandler }
+
+func (h bitAssetsServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.OpenapiSchema is not implemented"))
+func (h bitAssetsServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) AmmBurn(context.Context, *connect.Request[v1.AmmBurnRequest]) (*connect.Response[v1.AmmBurnResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.AmmBurn is not implemented"))
+func (h bitAssetsServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) AmmMint(context.Context, *connect.Request[v1.AmmMintRequest]) (*connect.Response[v1.AmmMintResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.AmmMint is not implemented"))
+func (h bitAssetsServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) AmmSwap(context.Context, *connect.Request[v1.AmmSwapRequest]) (*connect.Response[v1.AmmSwapResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.AmmSwap is not implemented"))
+func (h bitAssetsServiceHandler) withdraw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WithdrawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Withdraw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetAmmPoolState(context.Context, *connect.Request[v1.GetAmmPoolStateRequest]) (*connect.Response[v1.GetAmmPoolStateResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetAmmPoolState is not implemented"))
+func (h bitAssetsServiceHandler) transfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Transfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) GetAmmPrice(context.Context, *connect.Request[v1.GetAmmPriceRequest]) (*connect.Response[v1.GetAmmPriceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.GetAmmPrice is not implemented"))
+func (h bitAssetsServiceHandler) getSidechainWealth(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainWealthRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainWealth(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) DutchAuctionBid(context.Context, *connect.Request[v1.DutchAuctionBidRequest]) (*connect.Response[v1.DutchAuctionBidResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.DutchAuctionBid is not implemented"))
+func (h bitAssetsServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getPendingWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) connectPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) forgetPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ForgetPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ForgetPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) listPeers(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPeersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPeers(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) mine(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MineRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Mine(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) DutchAuctionCollect(context.Context, *connect.Request[v1.DutchAuctionCollectRequest]) (*connect.Response[v1.DutchAuctionCollectResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.DutchAuctionCollect is not implemented"))
+func (h bitAssetsServiceHandler) getBestMainchainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestMainchainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestMainchainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getBestSidechainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestSidechainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestSidechainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getBmmInclusions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmInclusionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmInclusions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getWalletUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) DutchAuctionCreate(context.Context, *connect.Request[v1.DutchAuctionCreateRequest]) (*connect.Response[v1.DutchAuctionCreateResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.DutchAuctionCreate is not implemented"))
+func (h bitAssetsServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) removeFromMempool(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RemoveFromMempoolRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RemoveFromMempool(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitAssetsServiceHandler) DutchAuctions(context.Context, *connect.Request[v1.DutchAuctionsRequest]) (*connect.Response[v1.DutchAuctionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitassets.v1.BitAssetsService.DutchAuctions is not implemented"))
+func (h bitAssetsServiceHandler) getLatestFailedWithdrawalBundleHeight(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetLatestFailedWithdrawalBundleHeightRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetLatestFailedWithdrawalBundleHeight(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) generateMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) setSeedFromMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSeedFromMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSeedFromMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) callRaw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CallRawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CallRaw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getBitAssetData(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBitAssetDataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBitAssetData(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) listBitAssets(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListBitAssetsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListBitAssets(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) registerBitAsset(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RegisterBitAssetRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RegisterBitAsset(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) reserveBitAsset(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ReserveBitAssetRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ReserveBitAsset(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) transferBitAsset(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferBitAssetRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.TransferBitAsset(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getNewEncryptionKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewEncryptionKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewEncryptionKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getNewVerifyingKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewVerifyingKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewVerifyingKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) decryptMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DecryptMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DecryptMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) encryptMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EncryptMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EncryptMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) signArbitraryMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignArbitraryMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignArbitraryMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) signArbitraryMsgAsAddr(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignArbitraryMsgAsAddrRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignArbitraryMsgAsAddr(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) verifySignature(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VerifySignatureRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VerifySignature(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getWalletAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) myUnconfirmedUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MyUnconfirmedUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MyUnconfirmedUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) openapiSchema(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.OpenapiSchemaRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.OpenapiSchema(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) ammBurn(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.AmmBurnRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.AmmBurn(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) ammMint(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.AmmMintRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.AmmMint(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) ammSwap(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.AmmSwapRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.AmmSwap(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getAmmPoolState(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetAmmPoolStateRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetAmmPoolState(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) getAmmPrice(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetAmmPriceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetAmmPrice(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) dutchAuctionBid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DutchAuctionBidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DutchAuctionBid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) dutchAuctionCollect(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DutchAuctionCollectRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DutchAuctionCollect(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) dutchAuctionCreate(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DutchAuctionCreateRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DutchAuctionCreate(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitAssetsServiceHandler) dutchAuctions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DutchAuctionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DutchAuctions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/bitnames/v1/bitnamesv1connect/bitnames.connect.go b/sidechain-orchestrator/gen/bitnames/v1/bitnamesv1connect/bitnames.connect.go
index b0c5b84cb7..640abbd980 100644
--- a/sidechain-orchestrator/gen/bitnames/v1/bitnamesv1connect/bitnames.connect.go
+++ b/sidechain-orchestrator/gen/bitnames/v1/bitnamesv1connect/bitnames.connect.go
@@ -5,1315 +5,1524 @@
 package bitnamesv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitnames/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BitnamesServiceName is the fully-qualified name of the BitnamesService service.
 	BitnamesServiceName = "bitnames.v1.BitnamesService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BitnamesServiceGetBalanceProcedure is the fully-qualified name of the BitnamesService's
-	// GetBalance RPC.
+	// BitnamesServiceGetBalanceProcedure is the procedure name of the BitnamesService's GetBalance RPC.
 	BitnamesServiceGetBalanceProcedure = "/bitnames.v1.BitnamesService/GetBalance"
-	// BitnamesServiceGetBlockCountProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetBlockCountProcedure is the procedure name of the BitnamesService's
 	// GetBlockCount RPC.
 	BitnamesServiceGetBlockCountProcedure = "/bitnames.v1.BitnamesService/GetBlockCount"
-	// BitnamesServiceStopProcedure is the fully-qualified name of the BitnamesService's Stop RPC.
+	// BitnamesServiceStopProcedure is the procedure name of the BitnamesService's Stop RPC.
 	BitnamesServiceStopProcedure = "/bitnames.v1.BitnamesService/Stop"
-	// BitnamesServiceGetNewAddressProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetNewAddressProcedure is the procedure name of the BitnamesService's
 	// GetNewAddress RPC.
 	BitnamesServiceGetNewAddressProcedure = "/bitnames.v1.BitnamesService/GetNewAddress"
-	// BitnamesServiceWithdrawProcedure is the fully-qualified name of the BitnamesService's Withdraw
-	// RPC.
+	// BitnamesServiceWithdrawProcedure is the procedure name of the BitnamesService's Withdraw RPC.
 	BitnamesServiceWithdrawProcedure = "/bitnames.v1.BitnamesService/Withdraw"
-	// BitnamesServiceTransferProcedure is the fully-qualified name of the BitnamesService's Transfer
-	// RPC.
+	// BitnamesServiceTransferProcedure is the procedure name of the BitnamesService's Transfer RPC.
 	BitnamesServiceTransferProcedure = "/bitnames.v1.BitnamesService/Transfer"
-	// BitnamesServiceGetSidechainWealthProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetSidechainWealthProcedure is the procedure name of the BitnamesService's
 	// GetSidechainWealth RPC.
 	BitnamesServiceGetSidechainWealthProcedure = "/bitnames.v1.BitnamesService/GetSidechainWealth"
-	// BitnamesServiceCreateDepositProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceCreateDepositProcedure is the procedure name of the BitnamesService's
 	// CreateDeposit RPC.
 	BitnamesServiceCreateDepositProcedure = "/bitnames.v1.BitnamesService/CreateDeposit"
-	// BitnamesServiceGetPendingWithdrawalBundleProcedure is the fully-qualified name of the
-	// BitnamesService's GetPendingWithdrawalBundle RPC.
+	// BitnamesServiceGetPendingWithdrawalBundleProcedure is the procedure name of the BitnamesService's
+	// GetPendingWithdrawalBundle RPC.
 	BitnamesServiceGetPendingWithdrawalBundleProcedure = "/bitnames.v1.BitnamesService/GetPendingWithdrawalBundle"
-	// BitnamesServiceConnectPeerProcedure is the fully-qualified name of the BitnamesService's
-	// ConnectPeer RPC.
-	BitnamesServiceConnectPeerProcedure = "/bitnames.v1.BitnamesService/ConnectPeer"
-	// BitnamesServiceListPeersProcedure is the fully-qualified name of the BitnamesService's ListPeers
+	// BitnamesServiceConnectPeerProcedure is the procedure name of the BitnamesService's ConnectPeer
 	// RPC.
+	BitnamesServiceConnectPeerProcedure = "/bitnames.v1.BitnamesService/ConnectPeer"
+	// BitnamesServiceListPeersProcedure is the procedure name of the BitnamesService's ListPeers RPC.
 	BitnamesServiceListPeersProcedure = "/bitnames.v1.BitnamesService/ListPeers"
-	// BitnamesServiceMineProcedure is the fully-qualified name of the BitnamesService's Mine RPC.
+	// BitnamesServiceMineProcedure is the procedure name of the BitnamesService's Mine RPC.
 	BitnamesServiceMineProcedure = "/bitnames.v1.BitnamesService/Mine"
-	// BitnamesServiceGetBlockProcedure is the fully-qualified name of the BitnamesService's GetBlock
-	// RPC.
+	// BitnamesServiceGetBlockProcedure is the procedure name of the BitnamesService's GetBlock RPC.
 	BitnamesServiceGetBlockProcedure = "/bitnames.v1.BitnamesService/GetBlock"
-	// BitnamesServiceGetBestMainchainBlockHashProcedure is the fully-qualified name of the
-	// BitnamesService's GetBestMainchainBlockHash RPC.
+	// BitnamesServiceGetBestMainchainBlockHashProcedure is the procedure name of the BitnamesService's
+	// GetBestMainchainBlockHash RPC.
 	BitnamesServiceGetBestMainchainBlockHashProcedure = "/bitnames.v1.BitnamesService/GetBestMainchainBlockHash"
-	// BitnamesServiceGetBestSidechainBlockHashProcedure is the fully-qualified name of the
-	// BitnamesService's GetBestSidechainBlockHash RPC.
+	// BitnamesServiceGetBestSidechainBlockHashProcedure is the procedure name of the BitnamesService's
+	// GetBestSidechainBlockHash RPC.
 	BitnamesServiceGetBestSidechainBlockHashProcedure = "/bitnames.v1.BitnamesService/GetBestSidechainBlockHash"
-	// BitnamesServiceGetBmmInclusionsProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetBmmInclusionsProcedure is the procedure name of the BitnamesService's
 	// GetBmmInclusions RPC.
 	BitnamesServiceGetBmmInclusionsProcedure = "/bitnames.v1.BitnamesService/GetBmmInclusions"
-	// BitnamesServiceGetWalletUtxosProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetWalletUtxosProcedure is the procedure name of the BitnamesService's
 	// GetWalletUtxos RPC.
 	BitnamesServiceGetWalletUtxosProcedure = "/bitnames.v1.BitnamesService/GetWalletUtxos"
-	// BitnamesServiceListUtxosProcedure is the fully-qualified name of the BitnamesService's ListUtxos
-	// RPC.
+	// BitnamesServiceListUtxosProcedure is the procedure name of the BitnamesService's ListUtxos RPC.
 	BitnamesServiceListUtxosProcedure = "/bitnames.v1.BitnamesService/ListUtxos"
-	// BitnamesServiceGetLatestFailedWithdrawalBundleHeightProcedure is the fully-qualified name of the
+	// BitnamesServiceGetLatestFailedWithdrawalBundleHeightProcedure is the procedure name of the
 	// BitnamesService's GetLatestFailedWithdrawalBundleHeight RPC.
 	BitnamesServiceGetLatestFailedWithdrawalBundleHeightProcedure = "/bitnames.v1.BitnamesService/GetLatestFailedWithdrawalBundleHeight"
-	// BitnamesServiceGenerateMnemonicProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGenerateMnemonicProcedure is the procedure name of the BitnamesService's
 	// GenerateMnemonic RPC.
 	BitnamesServiceGenerateMnemonicProcedure = "/bitnames.v1.BitnamesService/GenerateMnemonic"
-	// BitnamesServiceSetSeedFromMnemonicProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceSetSeedFromMnemonicProcedure is the procedure name of the BitnamesService's
 	// SetSeedFromMnemonic RPC.
 	BitnamesServiceSetSeedFromMnemonicProcedure = "/bitnames.v1.BitnamesService/SetSeedFromMnemonic"
-	// BitnamesServiceCallRawProcedure is the fully-qualified name of the BitnamesService's CallRaw RPC.
+	// BitnamesServiceCallRawProcedure is the procedure name of the BitnamesService's CallRaw RPC.
 	BitnamesServiceCallRawProcedure = "/bitnames.v1.BitnamesService/CallRaw"
-	// BitnamesServiceGetBitNameDataProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetBitNameDataProcedure is the procedure name of the BitnamesService's
 	// GetBitNameData RPC.
 	BitnamesServiceGetBitNameDataProcedure = "/bitnames.v1.BitnamesService/GetBitNameData"
-	// BitnamesServiceListBitNamesProcedure is the fully-qualified name of the BitnamesService's
-	// ListBitNames RPC.
+	// BitnamesServiceListBitNamesProcedure is the procedure name of the BitnamesService's ListBitNames
+	// RPC.
 	BitnamesServiceListBitNamesProcedure = "/bitnames.v1.BitnamesService/ListBitNames"
-	// BitnamesServiceRegisterBitNameProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceRegisterBitNameProcedure is the procedure name of the BitnamesService's
 	// RegisterBitName RPC.
 	BitnamesServiceRegisterBitNameProcedure = "/bitnames.v1.BitnamesService/RegisterBitName"
-	// BitnamesServiceReserveBitNameProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceReserveBitNameProcedure is the procedure name of the BitnamesService's
 	// ReserveBitName RPC.
 	BitnamesServiceReserveBitNameProcedure = "/bitnames.v1.BitnamesService/ReserveBitName"
-	// BitnamesServiceGetNewEncryptionKeyProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetNewEncryptionKeyProcedure is the procedure name of the BitnamesService's
 	// GetNewEncryptionKey RPC.
 	BitnamesServiceGetNewEncryptionKeyProcedure = "/bitnames.v1.BitnamesService/GetNewEncryptionKey"
-	// BitnamesServiceGetNewVerifyingKeyProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetNewVerifyingKeyProcedure is the procedure name of the BitnamesService's
 	// GetNewVerifyingKey RPC.
 	BitnamesServiceGetNewVerifyingKeyProcedure = "/bitnames.v1.BitnamesService/GetNewVerifyingKey"
-	// BitnamesServiceDecryptMsgProcedure is the fully-qualified name of the BitnamesService's
-	// DecryptMsg RPC.
+	// BitnamesServiceDecryptMsgProcedure is the procedure name of the BitnamesService's DecryptMsg RPC.
 	BitnamesServiceDecryptMsgProcedure = "/bitnames.v1.BitnamesService/DecryptMsg"
-	// BitnamesServiceEncryptMsgProcedure is the fully-qualified name of the BitnamesService's
-	// EncryptMsg RPC.
+	// BitnamesServiceEncryptMsgProcedure is the procedure name of the BitnamesService's EncryptMsg RPC.
 	BitnamesServiceEncryptMsgProcedure = "/bitnames.v1.BitnamesService/EncryptMsg"
-	// BitnamesServiceGetPaymailProcedure is the fully-qualified name of the BitnamesService's
-	// GetPaymail RPC.
+	// BitnamesServiceGetPaymailProcedure is the procedure name of the BitnamesService's GetPaymail RPC.
 	BitnamesServiceGetPaymailProcedure = "/bitnames.v1.BitnamesService/GetPaymail"
-	// BitnamesServiceGetPendingPaymailProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetPendingPaymailProcedure is the procedure name of the BitnamesService's
 	// GetPendingPaymail RPC.
 	BitnamesServiceGetPendingPaymailProcedure = "/bitnames.v1.BitnamesService/GetPendingPaymail"
-	// BitnamesServiceGetBitNameOwnerProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetBitNameOwnerProcedure is the procedure name of the BitnamesService's
 	// GetBitNameOwner RPC.
 	BitnamesServiceGetBitNameOwnerProcedure = "/bitnames.v1.BitnamesService/GetBitNameOwner"
-	// BitnamesServiceResolveCommitProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceResolveCommitProcedure is the procedure name of the BitnamesService's
 	// ResolveCommit RPC.
 	BitnamesServiceResolveCommitProcedure = "/bitnames.v1.BitnamesService/ResolveCommit"
-	// BitnamesServiceReadCommitmentProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceReadCommitmentProcedure is the procedure name of the BitnamesService's
 	// ReadCommitment RPC.
 	BitnamesServiceReadCommitmentProcedure = "/bitnames.v1.BitnamesService/ReadCommitment"
-	// BitnamesServiceSignArbitraryMsgProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceSignArbitraryMsgProcedure is the procedure name of the BitnamesService's
 	// SignArbitraryMsg RPC.
 	BitnamesServiceSignArbitraryMsgProcedure = "/bitnames.v1.BitnamesService/SignArbitraryMsg"
-	// BitnamesServiceSignArbitraryMsgAsAddrProcedure is the fully-qualified name of the
-	// BitnamesService's SignArbitraryMsgAsAddr RPC.
+	// BitnamesServiceSignArbitraryMsgAsAddrProcedure is the procedure name of the BitnamesService's
+	// SignArbitraryMsgAsAddr RPC.
 	BitnamesServiceSignArbitraryMsgAsAddrProcedure = "/bitnames.v1.BitnamesService/SignArbitraryMsgAsAddr"
-	// BitnamesServiceGetWalletAddressesProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceGetWalletAddressesProcedure is the procedure name of the BitnamesService's
 	// GetWalletAddresses RPC.
 	BitnamesServiceGetWalletAddressesProcedure = "/bitnames.v1.BitnamesService/GetWalletAddresses"
-	// BitnamesServiceMyUtxosProcedure is the fully-qualified name of the BitnamesService's MyUtxos RPC.
+	// BitnamesServiceMyUtxosProcedure is the procedure name of the BitnamesService's MyUtxos RPC.
 	BitnamesServiceMyUtxosProcedure = "/bitnames.v1.BitnamesService/MyUtxos"
-	// BitnamesServiceOpenapiSchemaProcedure is the fully-qualified name of the BitnamesService's
+	// BitnamesServiceOpenapiSchemaProcedure is the procedure name of the BitnamesService's
 	// OpenapiSchema RPC.
 	BitnamesServiceOpenapiSchemaProcedure = "/bitnames.v1.BitnamesService/OpenapiSchema"
 )
 
+var (
+	bitnamesServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBalance"),
+			Procedure:  BitnamesServiceGetBalanceProcedure,
+		}
+	})
+	bitnamesServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBlockCount"),
+			Procedure:  BitnamesServiceGetBlockCountProcedure,
+		}
+	})
+	bitnamesServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("Stop"),
+			Procedure:  BitnamesServiceStopProcedure,
+		}
+	})
+	bitnamesServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetNewAddress"),
+			Procedure:  BitnamesServiceGetNewAddressProcedure,
+		}
+	})
+	bitnamesServiceWithdrawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("Withdraw"),
+			Procedure:  BitnamesServiceWithdrawProcedure,
+		}
+	})
+	bitnamesServiceTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("Transfer"),
+			Procedure:  BitnamesServiceTransferProcedure,
+		}
+	})
+	bitnamesServiceGetSidechainWealthSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetSidechainWealth"),
+			Procedure:  BitnamesServiceGetSidechainWealthProcedure,
+		}
+	})
+	bitnamesServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("CreateDeposit"),
+			Procedure:  BitnamesServiceCreateDepositProcedure,
+		}
+	})
+	bitnamesServiceGetPendingWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetPendingWithdrawalBundle"),
+			Procedure:  BitnamesServiceGetPendingWithdrawalBundleProcedure,
+		}
+	})
+	bitnamesServiceConnectPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("ConnectPeer"),
+			Procedure:  BitnamesServiceConnectPeerProcedure,
+		}
+	})
+	bitnamesServiceListPeersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("ListPeers"),
+			Procedure:  BitnamesServiceListPeersProcedure,
+		}
+	})
+	bitnamesServiceMineSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("Mine"),
+			Procedure:  BitnamesServiceMineProcedure,
+		}
+	})
+	bitnamesServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBlock"),
+			Procedure:  BitnamesServiceGetBlockProcedure,
+		}
+	})
+	bitnamesServiceGetBestMainchainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBestMainchainBlockHash"),
+			Procedure:  BitnamesServiceGetBestMainchainBlockHashProcedure,
+		}
+	})
+	bitnamesServiceGetBestSidechainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBestSidechainBlockHash"),
+			Procedure:  BitnamesServiceGetBestSidechainBlockHashProcedure,
+		}
+	})
+	bitnamesServiceGetBmmInclusionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBmmInclusions"),
+			Procedure:  BitnamesServiceGetBmmInclusionsProcedure,
+		}
+	})
+	bitnamesServiceGetWalletUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetWalletUtxos"),
+			Procedure:  BitnamesServiceGetWalletUtxosProcedure,
+		}
+	})
+	bitnamesServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("ListUtxos"),
+			Procedure:  BitnamesServiceListUtxosProcedure,
+		}
+	})
+	bitnamesServiceGetLatestFailedWithdrawalBundleHeightSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetLatestFailedWithdrawalBundleHeight"),
+			Procedure:  BitnamesServiceGetLatestFailedWithdrawalBundleHeightProcedure,
+		}
+	})
+	bitnamesServiceGenerateMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GenerateMnemonic"),
+			Procedure:  BitnamesServiceGenerateMnemonicProcedure,
+		}
+	})
+	bitnamesServiceSetSeedFromMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("SetSeedFromMnemonic"),
+			Procedure:  BitnamesServiceSetSeedFromMnemonicProcedure,
+		}
+	})
+	bitnamesServiceCallRawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("CallRaw"),
+			Procedure:  BitnamesServiceCallRawProcedure,
+		}
+	})
+	bitnamesServiceGetBitNameDataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBitNameData"),
+			Procedure:  BitnamesServiceGetBitNameDataProcedure,
+		}
+	})
+	bitnamesServiceListBitNamesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("ListBitNames"),
+			Procedure:  BitnamesServiceListBitNamesProcedure,
+		}
+	})
+	bitnamesServiceRegisterBitNameSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("RegisterBitName"),
+			Procedure:  BitnamesServiceRegisterBitNameProcedure,
+		}
+	})
+	bitnamesServiceReserveBitNameSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("ReserveBitName"),
+			Procedure:  BitnamesServiceReserveBitNameProcedure,
+		}
+	})
+	bitnamesServiceGetNewEncryptionKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetNewEncryptionKey"),
+			Procedure:  BitnamesServiceGetNewEncryptionKeyProcedure,
+		}
+	})
+	bitnamesServiceGetNewVerifyingKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetNewVerifyingKey"),
+			Procedure:  BitnamesServiceGetNewVerifyingKeyProcedure,
+		}
+	})
+	bitnamesServiceDecryptMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("DecryptMsg"),
+			Procedure:  BitnamesServiceDecryptMsgProcedure,
+		}
+	})
+	bitnamesServiceEncryptMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("EncryptMsg"),
+			Procedure:  BitnamesServiceEncryptMsgProcedure,
+		}
+	})
+	bitnamesServiceGetPaymailSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetPaymail"),
+			Procedure:  BitnamesServiceGetPaymailProcedure,
+		}
+	})
+	bitnamesServiceGetPendingPaymailSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetPendingPaymail"),
+			Procedure:  BitnamesServiceGetPendingPaymailProcedure,
+		}
+	})
+	bitnamesServiceGetBitNameOwnerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetBitNameOwner"),
+			Procedure:  BitnamesServiceGetBitNameOwnerProcedure,
+		}
+	})
+	bitnamesServiceResolveCommitSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("ResolveCommit"),
+			Procedure:  BitnamesServiceResolveCommitProcedure,
+		}
+	})
+	bitnamesServiceReadCommitmentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("ReadCommitment"),
+			Procedure:  BitnamesServiceReadCommitmentProcedure,
+		}
+	})
+	bitnamesServiceSignArbitraryMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("SignArbitraryMsg"),
+			Procedure:  BitnamesServiceSignArbitraryMsgProcedure,
+		}
+	})
+	bitnamesServiceSignArbitraryMsgAsAddrSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("SignArbitraryMsgAsAddr"),
+			Procedure:  BitnamesServiceSignArbitraryMsgAsAddrProcedure,
+		}
+	})
+	bitnamesServiceGetWalletAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("GetWalletAddresses"),
+			Procedure:  BitnamesServiceGetWalletAddressesProcedure,
+		}
+	})
+	bitnamesServiceMyUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("MyUtxos"),
+			Procedure:  BitnamesServiceMyUtxosProcedure,
+		}
+	})
+	bitnamesServiceOpenapiSchemaSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods().ByName("OpenapiSchema"),
+			Procedure:  BitnamesServiceOpenapiSchemaProcedure,
+		}
+	})
+)
+
 // BitnamesServiceClient is a client for the bitnames.v1.BitnamesService service.
 type BitnamesServiceClient interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the bitnames node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get BitName data by name.
-	GetBitNameData(context.Context, *connect.Request[v1.GetBitNameDataRequest]) (*connect.Response[v1.GetBitNameDataResponse], error)
-	// List all BitNames.
-	ListBitNames(context.Context, *connect.Request[v1.ListBitNamesRequest]) (*connect.Response[v1.ListBitNamesResponse], error)
-	// Register a BitName.
-	RegisterBitName(context.Context, *connect.Request[v1.RegisterBitNameRequest]) (*connect.Response[v1.RegisterBitNameResponse], error)
-	// Reserve a BitName.
-	ReserveBitName(context.Context, *connect.Request[v1.ReserveBitNameRequest]) (*connect.Response[v1.ReserveBitNameResponse], error)
-	// Get a new encryption key.
-	GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error)
-	// Get a new verifying key.
-	GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error)
-	// Decrypt a message.
-	DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error)
-	// Encrypt a message.
-	EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error)
-	// Get paymail information.
-	GetPaymail(context.Context, *connect.Request[v1.GetPaymailRequest]) (*connect.Response[v1.GetPaymailResponse], error)
-	// Read the messages that wait in the mempool. A message reaches a BitName
-	// one block before GetPaymail reports it, so a chat reads both.
-	GetPendingPaymail(context.Context, *connect.Request[v1.GetPendingPaymailRequest]) (*connect.Response[v1.GetPendingPaymailResponse], error)
-	// Read the address that holds a BitName. A message pays the holder.
-	GetBitNameOwner(context.Context, *connect.Request[v1.GetBitNameOwnerRequest]) (*connect.Response[v1.GetBitNameOwnerResponse], error)
-	// Resolve a commitment from a BitName.
-	ResolveCommit(context.Context, *connect.Request[v1.ResolveCommitRequest]) (*connect.Response[v1.ResolveCommitResponse], error)
-	// Read a data commitment from an address, before a BitName holds it.
-	ReadCommitment(context.Context, *connect.Request[v1.ReadCommitmentRequest]) (*connect.Response[v1.ReadCommitmentResponse], error)
-	// Sign an arbitrary message with the specified verifying key.
-	SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error)
-	// Sign an arbitrary message as a specific address.
-	SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// List owned UTXOs.
-	MyUtxos(context.Context, *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error)
-	// Get OpenAPI schema.
-	OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error)
-}
-
-// NewBitnamesServiceClient constructs a client for the bitnames.v1.BitnamesService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBitnamesServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BitnamesServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	bitnamesServiceMethods := v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods()
-	return &bitnamesServiceClient{
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBalanceProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBlockCountProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+BitnamesServiceStopProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetNewAddressProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		withdraw: connect.NewClient[v1.WithdrawRequest, v1.WithdrawResponse](
-			httpClient,
-			baseURL+BitnamesServiceWithdrawProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("Withdraw")),
-			connect.WithClientOptions(opts...),
-		),
-		transfer: connect.NewClient[v1.TransferRequest, v1.TransferResponse](
-			httpClient,
-			baseURL+BitnamesServiceTransferProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("Transfer")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainWealth: connect.NewClient[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetSidechainWealthProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetSidechainWealth")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+BitnamesServiceCreateDepositProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingWithdrawalBundle: connect.NewClient[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetPendingWithdrawalBundleProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetPendingWithdrawalBundle")),
-			connect.WithClientOptions(opts...),
-		),
-		connectPeer: connect.NewClient[v1.ConnectPeerRequest, v1.ConnectPeerResponse](
-			httpClient,
-			baseURL+BitnamesServiceConnectPeerProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("ConnectPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		listPeers: connect.NewClient[v1.ListPeersRequest, v1.ListPeersResponse](
-			httpClient,
-			baseURL+BitnamesServiceListPeersProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("ListPeers")),
-			connect.WithClientOptions(opts...),
-		),
-		mine: connect.NewClient[v1.MineRequest, v1.MineResponse](
-			httpClient,
-			baseURL+BitnamesServiceMineProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("Mine")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBlockProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestMainchainBlockHash: connect.NewClient[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBestMainchainBlockHashProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBestMainchainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestSidechainBlockHash: connect.NewClient[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBestSidechainBlockHashProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBestSidechainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmInclusions: connect.NewClient[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBmmInclusionsProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBmmInclusions")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletUtxos: connect.NewClient[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetWalletUtxosProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetWalletUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+BitnamesServiceListUtxosProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		getLatestFailedWithdrawalBundleHeight: connect.NewClient[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-			connect.WithClientOptions(opts...),
-		),
-		generateMnemonic: connect.NewClient[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse](
-			httpClient,
-			baseURL+BitnamesServiceGenerateMnemonicProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GenerateMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		setSeedFromMnemonic: connect.NewClient[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse](
-			httpClient,
-			baseURL+BitnamesServiceSetSeedFromMnemonicProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("SetSeedFromMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		callRaw: connect.NewClient[v1.CallRawRequest, v1.CallRawResponse](
-			httpClient,
-			baseURL+BitnamesServiceCallRawProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("CallRaw")),
-			connect.WithClientOptions(opts...),
-		),
-		getBitNameData: connect.NewClient[v1.GetBitNameDataRequest, v1.GetBitNameDataResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBitNameDataProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBitNameData")),
-			connect.WithClientOptions(opts...),
-		),
-		listBitNames: connect.NewClient[v1.ListBitNamesRequest, v1.ListBitNamesResponse](
-			httpClient,
-			baseURL+BitnamesServiceListBitNamesProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("ListBitNames")),
-			connect.WithClientOptions(opts...),
-		),
-		registerBitName: connect.NewClient[v1.RegisterBitNameRequest, v1.RegisterBitNameResponse](
-			httpClient,
-			baseURL+BitnamesServiceRegisterBitNameProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("RegisterBitName")),
-			connect.WithClientOptions(opts...),
-		),
-		reserveBitName: connect.NewClient[v1.ReserveBitNameRequest, v1.ReserveBitNameResponse](
-			httpClient,
-			baseURL+BitnamesServiceReserveBitNameProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("ReserveBitName")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewEncryptionKey: connect.NewClient[v1.GetNewEncryptionKeyRequest, v1.GetNewEncryptionKeyResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetNewEncryptionKeyProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetNewEncryptionKey")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewVerifyingKey: connect.NewClient[v1.GetNewVerifyingKeyRequest, v1.GetNewVerifyingKeyResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetNewVerifyingKeyProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetNewVerifyingKey")),
-			connect.WithClientOptions(opts...),
-		),
-		decryptMsg: connect.NewClient[v1.DecryptMsgRequest, v1.DecryptMsgResponse](
-			httpClient,
-			baseURL+BitnamesServiceDecryptMsgProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("DecryptMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		encryptMsg: connect.NewClient[v1.EncryptMsgRequest, v1.EncryptMsgResponse](
-			httpClient,
-			baseURL+BitnamesServiceEncryptMsgProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("EncryptMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		getPaymail: connect.NewClient[v1.GetPaymailRequest, v1.GetPaymailResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetPaymailProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetPaymail")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingPaymail: connect.NewClient[v1.GetPendingPaymailRequest, v1.GetPendingPaymailResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetPendingPaymailProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetPendingPaymail")),
-			connect.WithClientOptions(opts...),
-		),
-		getBitNameOwner: connect.NewClient[v1.GetBitNameOwnerRequest, v1.GetBitNameOwnerResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetBitNameOwnerProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetBitNameOwner")),
-			connect.WithClientOptions(opts...),
-		),
-		resolveCommit: connect.NewClient[v1.ResolveCommitRequest, v1.ResolveCommitResponse](
-			httpClient,
-			baseURL+BitnamesServiceResolveCommitProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("ResolveCommit")),
-			connect.WithClientOptions(opts...),
-		),
-		readCommitment: connect.NewClient[v1.ReadCommitmentRequest, v1.ReadCommitmentResponse](
-			httpClient,
-			baseURL+BitnamesServiceReadCommitmentProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("ReadCommitment")),
-			connect.WithClientOptions(opts...),
-		),
-		signArbitraryMsg: connect.NewClient[v1.SignArbitraryMsgRequest, v1.SignArbitraryMsgResponse](
-			httpClient,
-			baseURL+BitnamesServiceSignArbitraryMsgProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("SignArbitraryMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		signArbitraryMsgAsAddr: connect.NewClient[v1.SignArbitraryMsgAsAddrRequest, v1.SignArbitraryMsgAsAddrResponse](
-			httpClient,
-			baseURL+BitnamesServiceSignArbitraryMsgAsAddrProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("SignArbitraryMsgAsAddr")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletAddresses: connect.NewClient[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse](
-			httpClient,
-			baseURL+BitnamesServiceGetWalletAddressesProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("GetWalletAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		myUtxos: connect.NewClient[v1.MyUtxosRequest, v1.MyUtxosResponse](
-			httpClient,
-			baseURL+BitnamesServiceMyUtxosProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("MyUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		openapiSchema: connect.NewClient[v1.OpenapiSchemaRequest, v1.OpenapiSchemaResponse](
-			httpClient,
-			baseURL+BitnamesServiceOpenapiSchemaProcedure,
-			connect.WithSchema(bitnamesServiceMethods.ByName("OpenapiSchema")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// bitnamesServiceClient implements BitnamesServiceClient.
-type bitnamesServiceClient struct {
-	getBalance                            *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getBlockCount                         *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	stop                                  *connect.Client[v1.StopRequest, v1.StopResponse]
-	getNewAddress                         *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	withdraw                              *connect.Client[v1.WithdrawRequest, v1.WithdrawResponse]
-	transfer                              *connect.Client[v1.TransferRequest, v1.TransferResponse]
-	getSidechainWealth                    *connect.Client[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse]
-	createDeposit                         *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	getPendingWithdrawalBundle            *connect.Client[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse]
-	connectPeer                           *connect.Client[v1.ConnectPeerRequest, v1.ConnectPeerResponse]
-	listPeers                             *connect.Client[v1.ListPeersRequest, v1.ListPeersResponse]
-	mine                                  *connect.Client[v1.MineRequest, v1.MineResponse]
-	getBlock                              *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	getBestMainchainBlockHash             *connect.Client[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse]
-	getBestSidechainBlockHash             *connect.Client[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse]
-	getBmmInclusions                      *connect.Client[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse]
-	getWalletUtxos                        *connect.Client[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse]
-	listUtxos                             *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	getLatestFailedWithdrawalBundleHeight *connect.Client[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse]
-	generateMnemonic                      *connect.Client[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse]
-	setSeedFromMnemonic                   *connect.Client[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse]
-	callRaw                               *connect.Client[v1.CallRawRequest, v1.CallRawResponse]
-	getBitNameData                        *connect.Client[v1.GetBitNameDataRequest, v1.GetBitNameDataResponse]
-	listBitNames                          *connect.Client[v1.ListBitNamesRequest, v1.ListBitNamesResponse]
-	registerBitName                       *connect.Client[v1.RegisterBitNameRequest, v1.RegisterBitNameResponse]
-	reserveBitName                        *connect.Client[v1.ReserveBitNameRequest, v1.ReserveBitNameResponse]
-	getNewEncryptionKey                   *connect.Client[v1.GetNewEncryptionKeyRequest, v1.GetNewEncryptionKeyResponse]
-	getNewVerifyingKey                    *connect.Client[v1.GetNewVerifyingKeyRequest, v1.GetNewVerifyingKeyResponse]
-	decryptMsg                            *connect.Client[v1.DecryptMsgRequest, v1.DecryptMsgResponse]
-	encryptMsg                            *connect.Client[v1.EncryptMsgRequest, v1.EncryptMsgResponse]
-	getPaymail                            *connect.Client[v1.GetPaymailRequest, v1.GetPaymailResponse]
-	getPendingPaymail                     *connect.Client[v1.GetPendingPaymailRequest, v1.GetPendingPaymailResponse]
-	getBitNameOwner                       *connect.Client[v1.GetBitNameOwnerRequest, v1.GetBitNameOwnerResponse]
-	resolveCommit                         *connect.Client[v1.ResolveCommitRequest, v1.ResolveCommitResponse]
-	readCommitment                        *connect.Client[v1.ReadCommitmentRequest, v1.ReadCommitmentResponse]
-	signArbitraryMsg                      *connect.Client[v1.SignArbitraryMsgRequest, v1.SignArbitraryMsgResponse]
-	signArbitraryMsgAsAddr                *connect.Client[v1.SignArbitraryMsgAsAddrRequest, v1.SignArbitraryMsgAsAddrResponse]
-	getWalletAddresses                    *connect.Client[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse]
-	myUtxos                               *connect.Client[v1.MyUtxosRequest, v1.MyUtxosResponse]
-	openapiSchema                         *connect.Client[v1.OpenapiSchemaRequest, v1.OpenapiSchemaResponse]
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetBitNameData(context.Context, *v1.GetBitNameDataRequest) (*v1.GetBitNameDataResponse, error)
+	ListBitNames(context.Context, *v1.ListBitNamesRequest) (*v1.ListBitNamesResponse, error)
+	RegisterBitName(context.Context, *v1.RegisterBitNameRequest) (*v1.RegisterBitNameResponse, error)
+	ReserveBitName(context.Context, *v1.ReserveBitNameRequest) (*v1.ReserveBitNameResponse, error)
+	GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error)
+	GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error)
+	DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error)
+	EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error)
+	GetPaymail(context.Context, *v1.GetPaymailRequest) (*v1.GetPaymailResponse, error)
+	GetPendingPaymail(context.Context, *v1.GetPendingPaymailRequest) (*v1.GetPendingPaymailResponse, error)
+	GetBitNameOwner(context.Context, *v1.GetBitNameOwnerRequest) (*v1.GetBitNameOwnerResponse, error)
+	ResolveCommit(context.Context, *v1.ResolveCommitRequest) (*v1.ResolveCommitResponse, error)
+	ReadCommitment(context.Context, *v1.ReadCommitmentRequest) (*v1.ReadCommitmentResponse, error)
+	SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error)
+	SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	MyUtxos(context.Context, *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error)
+	OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error)
+}
+
+// NewBitnamesServiceClient constructs a client for the bitnames.v1.BitnamesService service.
+// Multiple service clients may share a single connect.Client.
+func NewBitnamesServiceClient(client *connect.Client) BitnamesServiceClient {
+	return &bitnamesServiceClient{client: client}
 }
 
-// GetBalance calls bitnames.v1.BitnamesService.GetBalance.
-func (c *bitnamesServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// BitnamesServiceHandler is an implementation of the bitnames.v1.BitnamesService service.
+type BitnamesServiceHandler interface {
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetBitNameData(context.Context, *v1.GetBitNameDataRequest) (*v1.GetBitNameDataResponse, error)
+	ListBitNames(context.Context, *v1.ListBitNamesRequest) (*v1.ListBitNamesResponse, error)
+	RegisterBitName(context.Context, *v1.RegisterBitNameRequest) (*v1.RegisterBitNameResponse, error)
+	ReserveBitName(context.Context, *v1.ReserveBitNameRequest) (*v1.ReserveBitNameResponse, error)
+	GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error)
+	GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error)
+	DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error)
+	EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error)
+	GetPaymail(context.Context, *v1.GetPaymailRequest) (*v1.GetPaymailResponse, error)
+	GetPendingPaymail(context.Context, *v1.GetPendingPaymailRequest) (*v1.GetPendingPaymailResponse, error)
+	GetBitNameOwner(context.Context, *v1.GetBitNameOwnerRequest) (*v1.GetBitNameOwnerResponse, error)
+	ResolveCommit(context.Context, *v1.ResolveCommitRequest) (*v1.ResolveCommitResponse, error)
+	ReadCommitment(context.Context, *v1.ReadCommitmentRequest) (*v1.ReadCommitmentResponse, error)
+	SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error)
+	SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	MyUtxos(context.Context, *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error)
+	OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error)
+}
+
+// RegisterBitnamesServiceHandler registers svc as the bitnames.v1.BitnamesService implementation on
+// server.
+func RegisterBitnamesServiceHandler(server *connect.Server, svc BitnamesServiceHandler) {
+	adapter := bitnamesServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: bitnamesServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: bitnamesServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: bitnamesServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: bitnamesServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: bitnamesServiceWithdrawSpec(), Handler: adapter.withdraw},
+		connect.Method{Spec: bitnamesServiceTransferSpec(), Handler: adapter.transfer},
+		connect.Method{Spec: bitnamesServiceGetSidechainWealthSpec(), Handler: adapter.getSidechainWealth},
+		connect.Method{Spec: bitnamesServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: bitnamesServiceGetPendingWithdrawalBundleSpec(), Handler: adapter.getPendingWithdrawalBundle},
+		connect.Method{Spec: bitnamesServiceConnectPeerSpec(), Handler: adapter.connectPeer},
+		connect.Method{Spec: bitnamesServiceListPeersSpec(), Handler: adapter.listPeers},
+		connect.Method{Spec: bitnamesServiceMineSpec(), Handler: adapter.mine},
+		connect.Method{Spec: bitnamesServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: bitnamesServiceGetBestMainchainBlockHashSpec(), Handler: adapter.getBestMainchainBlockHash},
+		connect.Method{Spec: bitnamesServiceGetBestSidechainBlockHashSpec(), Handler: adapter.getBestSidechainBlockHash},
+		connect.Method{Spec: bitnamesServiceGetBmmInclusionsSpec(), Handler: adapter.getBmmInclusions},
+		connect.Method{Spec: bitnamesServiceGetWalletUtxosSpec(), Handler: adapter.getWalletUtxos},
+		connect.Method{Spec: bitnamesServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: bitnamesServiceGetLatestFailedWithdrawalBundleHeightSpec(), Handler: adapter.getLatestFailedWithdrawalBundleHeight},
+		connect.Method{Spec: bitnamesServiceGenerateMnemonicSpec(), Handler: adapter.generateMnemonic},
+		connect.Method{Spec: bitnamesServiceSetSeedFromMnemonicSpec(), Handler: adapter.setSeedFromMnemonic},
+		connect.Method{Spec: bitnamesServiceCallRawSpec(), Handler: adapter.callRaw},
+		connect.Method{Spec: bitnamesServiceGetBitNameDataSpec(), Handler: adapter.getBitNameData},
+		connect.Method{Spec: bitnamesServiceListBitNamesSpec(), Handler: adapter.listBitNames},
+		connect.Method{Spec: bitnamesServiceRegisterBitNameSpec(), Handler: adapter.registerBitName},
+		connect.Method{Spec: bitnamesServiceReserveBitNameSpec(), Handler: adapter.reserveBitName},
+		connect.Method{Spec: bitnamesServiceGetNewEncryptionKeySpec(), Handler: adapter.getNewEncryptionKey},
+		connect.Method{Spec: bitnamesServiceGetNewVerifyingKeySpec(), Handler: adapter.getNewVerifyingKey},
+		connect.Method{Spec: bitnamesServiceDecryptMsgSpec(), Handler: adapter.decryptMsg},
+		connect.Method{Spec: bitnamesServiceEncryptMsgSpec(), Handler: adapter.encryptMsg},
+		connect.Method{Spec: bitnamesServiceGetPaymailSpec(), Handler: adapter.getPaymail},
+		connect.Method{Spec: bitnamesServiceGetPendingPaymailSpec(), Handler: adapter.getPendingPaymail},
+		connect.Method{Spec: bitnamesServiceGetBitNameOwnerSpec(), Handler: adapter.getBitNameOwner},
+		connect.Method{Spec: bitnamesServiceResolveCommitSpec(), Handler: adapter.resolveCommit},
+		connect.Method{Spec: bitnamesServiceReadCommitmentSpec(), Handler: adapter.readCommitment},
+		connect.Method{Spec: bitnamesServiceSignArbitraryMsgSpec(), Handler: adapter.signArbitraryMsg},
+		connect.Method{Spec: bitnamesServiceSignArbitraryMsgAsAddrSpec(), Handler: adapter.signArbitraryMsgAsAddr},
+		connect.Method{Spec: bitnamesServiceGetWalletAddressesSpec(), Handler: adapter.getWalletAddresses},
+		connect.Method{Spec: bitnamesServiceMyUtxosSpec(), Handler: adapter.myUtxos},
+		connect.Method{Spec: bitnamesServiceOpenapiSchemaSpec(), Handler: adapter.openapiSchema},
+	)
 }
 
-// GetBlockCount calls bitnames.v1.BitnamesService.GetBlockCount.
-func (c *bitnamesServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// UnimplementedBitnamesServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBitnamesServiceHandler struct{}
+
+func (UnimplementedBitnamesServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBalance is not implemented")
 }
 
-// Stop calls bitnames.v1.BitnamesService.Stop.
-func (c *bitnamesServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBlockCount is not implemented")
 }
 
-// GetNewAddress calls bitnames.v1.BitnamesService.GetNewAddress.
-func (c *bitnamesServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.Stop is not implemented")
 }
 
-// Withdraw calls bitnames.v1.BitnamesService.Withdraw.
-func (c *bitnamesServiceClient) Withdraw(ctx context.Context, req *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return c.withdraw.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetNewAddress is not implemented")
 }
 
-// Transfer calls bitnames.v1.BitnamesService.Transfer.
-func (c *bitnamesServiceClient) Transfer(ctx context.Context, req *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return c.transfer.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.Withdraw is not implemented")
 }
 
-// GetSidechainWealth calls bitnames.v1.BitnamesService.GetSidechainWealth.
-func (c *bitnamesServiceClient) GetSidechainWealth(ctx context.Context, req *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return c.getSidechainWealth.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.Transfer is not implemented")
 }
 
-// CreateDeposit calls bitnames.v1.BitnamesService.CreateDeposit.
-func (c *bitnamesServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetSidechainWealth is not implemented")
 }
 
-// GetPendingWithdrawalBundle calls bitnames.v1.BitnamesService.GetPendingWithdrawalBundle.
-func (c *bitnamesServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return c.getPendingWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.CreateDeposit is not implemented")
 }
 
-// ConnectPeer calls bitnames.v1.BitnamesService.ConnectPeer.
-func (c *bitnamesServiceClient) ConnectPeer(ctx context.Context, req *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return c.connectPeer.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetPendingWithdrawalBundle is not implemented")
 }
 
-// ListPeers calls bitnames.v1.BitnamesService.ListPeers.
-func (c *bitnamesServiceClient) ListPeers(ctx context.Context, req *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return c.listPeers.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.ConnectPeer is not implemented")
 }
 
-// Mine calls bitnames.v1.BitnamesService.Mine.
-func (c *bitnamesServiceClient) Mine(ctx context.Context, req *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return c.mine.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.ListPeers is not implemented")
 }
 
-// GetBlock calls bitnames.v1.BitnamesService.GetBlock.
-func (c *bitnamesServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.Mine is not implemented")
 }
 
-// GetBestMainchainBlockHash calls bitnames.v1.BitnamesService.GetBestMainchainBlockHash.
-func (c *bitnamesServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return c.getBestMainchainBlockHash.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBlock is not implemented")
 }
 
-// GetBestSidechainBlockHash calls bitnames.v1.BitnamesService.GetBestSidechainBlockHash.
-func (c *bitnamesServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return c.getBestSidechainBlockHash.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBestMainchainBlockHash is not implemented")
 }
 
-// GetBmmInclusions calls bitnames.v1.BitnamesService.GetBmmInclusions.
-func (c *bitnamesServiceClient) GetBmmInclusions(ctx context.Context, req *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return c.getBmmInclusions.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBestSidechainBlockHash is not implemented")
 }
 
-// GetWalletUtxos calls bitnames.v1.BitnamesService.GetWalletUtxos.
-func (c *bitnamesServiceClient) GetWalletUtxos(ctx context.Context, req *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return c.getWalletUtxos.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBmmInclusions is not implemented")
 }
 
-// ListUtxos calls bitnames.v1.BitnamesService.ListUtxos.
-func (c *bitnamesServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetWalletUtxos is not implemented")
 }
 
-// GetLatestFailedWithdrawalBundleHeight calls
-// bitnames.v1.BitnamesService.GetLatestFailedWithdrawalBundleHeight.
-func (c *bitnamesServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return c.getLatestFailedWithdrawalBundleHeight.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.ListUtxos is not implemented")
 }
 
-// GenerateMnemonic calls bitnames.v1.BitnamesService.GenerateMnemonic.
-func (c *bitnamesServiceClient) GenerateMnemonic(ctx context.Context, req *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return c.generateMnemonic.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetLatestFailedWithdrawalBundleHeight is not implemented")
 }
 
-// SetSeedFromMnemonic calls bitnames.v1.BitnamesService.SetSeedFromMnemonic.
-func (c *bitnamesServiceClient) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return c.setSeedFromMnemonic.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GenerateMnemonic is not implemented")
 }
 
-// CallRaw calls bitnames.v1.BitnamesService.CallRaw.
-func (c *bitnamesServiceClient) CallRaw(ctx context.Context, req *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return c.callRaw.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.SetSeedFromMnemonic is not implemented")
 }
 
-// GetBitNameData calls bitnames.v1.BitnamesService.GetBitNameData.
-func (c *bitnamesServiceClient) GetBitNameData(ctx context.Context, req *connect.Request[v1.GetBitNameDataRequest]) (*connect.Response[v1.GetBitNameDataResponse], error) {
-	return c.getBitNameData.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.CallRaw is not implemented")
 }
 
-// ListBitNames calls bitnames.v1.BitnamesService.ListBitNames.
-func (c *bitnamesServiceClient) ListBitNames(ctx context.Context, req *connect.Request[v1.ListBitNamesRequest]) (*connect.Response[v1.ListBitNamesResponse], error) {
-	return c.listBitNames.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetBitNameData(context.Context, *v1.GetBitNameDataRequest) (*v1.GetBitNameDataResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBitNameData is not implemented")
 }
 
-// RegisterBitName calls bitnames.v1.BitnamesService.RegisterBitName.
-func (c *bitnamesServiceClient) RegisterBitName(ctx context.Context, req *connect.Request[v1.RegisterBitNameRequest]) (*connect.Response[v1.RegisterBitNameResponse], error) {
-	return c.registerBitName.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) ListBitNames(context.Context, *v1.ListBitNamesRequest) (*v1.ListBitNamesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.ListBitNames is not implemented")
 }
 
-// ReserveBitName calls bitnames.v1.BitnamesService.ReserveBitName.
-func (c *bitnamesServiceClient) ReserveBitName(ctx context.Context, req *connect.Request[v1.ReserveBitNameRequest]) (*connect.Response[v1.ReserveBitNameResponse], error) {
-	return c.reserveBitName.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) RegisterBitName(context.Context, *v1.RegisterBitNameRequest) (*v1.RegisterBitNameResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.RegisterBitName is not implemented")
 }
 
-// GetNewEncryptionKey calls bitnames.v1.BitnamesService.GetNewEncryptionKey.
-func (c *bitnamesServiceClient) GetNewEncryptionKey(ctx context.Context, req *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error) {
-	return c.getNewEncryptionKey.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) ReserveBitName(context.Context, *v1.ReserveBitNameRequest) (*v1.ReserveBitNameResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.ReserveBitName is not implemented")
 }
 
-// GetNewVerifyingKey calls bitnames.v1.BitnamesService.GetNewVerifyingKey.
-func (c *bitnamesServiceClient) GetNewVerifyingKey(ctx context.Context, req *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error) {
-	return c.getNewVerifyingKey.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetNewEncryptionKey is not implemented")
 }
 
-// DecryptMsg calls bitnames.v1.BitnamesService.DecryptMsg.
-func (c *bitnamesServiceClient) DecryptMsg(ctx context.Context, req *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error) {
-	return c.decryptMsg.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetNewVerifyingKey is not implemented")
 }
 
-// EncryptMsg calls bitnames.v1.BitnamesService.EncryptMsg.
-func (c *bitnamesServiceClient) EncryptMsg(ctx context.Context, req *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error) {
-	return c.encryptMsg.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.DecryptMsg is not implemented")
 }
 
-// GetPaymail calls bitnames.v1.BitnamesService.GetPaymail.
-func (c *bitnamesServiceClient) GetPaymail(ctx context.Context, req *connect.Request[v1.GetPaymailRequest]) (*connect.Response[v1.GetPaymailResponse], error) {
-	return c.getPaymail.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.EncryptMsg is not implemented")
 }
 
-// GetPendingPaymail calls bitnames.v1.BitnamesService.GetPendingPaymail.
-func (c *bitnamesServiceClient) GetPendingPaymail(ctx context.Context, req *connect.Request[v1.GetPendingPaymailRequest]) (*connect.Response[v1.GetPendingPaymailResponse], error) {
-	return c.getPendingPaymail.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetPaymail(context.Context, *v1.GetPaymailRequest) (*v1.GetPaymailResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetPaymail is not implemented")
 }
 
-// GetBitNameOwner calls bitnames.v1.BitnamesService.GetBitNameOwner.
-func (c *bitnamesServiceClient) GetBitNameOwner(ctx context.Context, req *connect.Request[v1.GetBitNameOwnerRequest]) (*connect.Response[v1.GetBitNameOwnerResponse], error) {
-	return c.getBitNameOwner.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetPendingPaymail(context.Context, *v1.GetPendingPaymailRequest) (*v1.GetPendingPaymailResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetPendingPaymail is not implemented")
 }
 
-// ResolveCommit calls bitnames.v1.BitnamesService.ResolveCommit.
-func (c *bitnamesServiceClient) ResolveCommit(ctx context.Context, req *connect.Request[v1.ResolveCommitRequest]) (*connect.Response[v1.ResolveCommitResponse], error) {
-	return c.resolveCommit.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetBitNameOwner(context.Context, *v1.GetBitNameOwnerRequest) (*v1.GetBitNameOwnerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetBitNameOwner is not implemented")
 }
 
-// ReadCommitment calls bitnames.v1.BitnamesService.ReadCommitment.
-func (c *bitnamesServiceClient) ReadCommitment(ctx context.Context, req *connect.Request[v1.ReadCommitmentRequest]) (*connect.Response[v1.ReadCommitmentResponse], error) {
-	return c.readCommitment.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) ResolveCommit(context.Context, *v1.ResolveCommitRequest) (*v1.ResolveCommitResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.ResolveCommit is not implemented")
 }
 
-// SignArbitraryMsg calls bitnames.v1.BitnamesService.SignArbitraryMsg.
-func (c *bitnamesServiceClient) SignArbitraryMsg(ctx context.Context, req *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error) {
-	return c.signArbitraryMsg.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) ReadCommitment(context.Context, *v1.ReadCommitmentRequest) (*v1.ReadCommitmentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.ReadCommitment is not implemented")
 }
 
-// SignArbitraryMsgAsAddr calls bitnames.v1.BitnamesService.SignArbitraryMsgAsAddr.
-func (c *bitnamesServiceClient) SignArbitraryMsgAsAddr(ctx context.Context, req *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error) {
-	return c.signArbitraryMsgAsAddr.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.SignArbitraryMsg is not implemented")
 }
 
-// GetWalletAddresses calls bitnames.v1.BitnamesService.GetWalletAddresses.
-func (c *bitnamesServiceClient) GetWalletAddresses(ctx context.Context, req *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return c.getWalletAddresses.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.SignArbitraryMsgAsAddr is not implemented")
 }
 
-// MyUtxos calls bitnames.v1.BitnamesService.MyUtxos.
-func (c *bitnamesServiceClient) MyUtxos(ctx context.Context, req *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error) {
-	return c.myUtxos.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.GetWalletAddresses is not implemented")
 }
 
-// OpenapiSchema calls bitnames.v1.BitnamesService.OpenapiSchema.
-func (c *bitnamesServiceClient) OpenapiSchema(ctx context.Context, req *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error) {
-	return c.openapiSchema.CallUnary(ctx, req)
+func (UnimplementedBitnamesServiceHandler) MyUtxos(context.Context, *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.MyUtxos is not implemented")
 }
 
-// BitnamesServiceHandler is an implementation of the bitnames.v1.BitnamesService service.
-type BitnamesServiceHandler interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the bitnames node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get BitName data by name.
-	GetBitNameData(context.Context, *connect.Request[v1.GetBitNameDataRequest]) (*connect.Response[v1.GetBitNameDataResponse], error)
-	// List all BitNames.
-	ListBitNames(context.Context, *connect.Request[v1.ListBitNamesRequest]) (*connect.Response[v1.ListBitNamesResponse], error)
-	// Register a BitName.
-	RegisterBitName(context.Context, *connect.Request[v1.RegisterBitNameRequest]) (*connect.Response[v1.RegisterBitNameResponse], error)
-	// Reserve a BitName.
-	ReserveBitName(context.Context, *connect.Request[v1.ReserveBitNameRequest]) (*connect.Response[v1.ReserveBitNameResponse], error)
-	// Get a new encryption key.
-	GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error)
-	// Get a new verifying key.
-	GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error)
-	// Decrypt a message.
-	DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error)
-	// Encrypt a message.
-	EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error)
-	// Get paymail information.
-	GetPaymail(context.Context, *connect.Request[v1.GetPaymailRequest]) (*connect.Response[v1.GetPaymailResponse], error)
-	// Read the messages that wait in the mempool. A message reaches a BitName
-	// one block before GetPaymail reports it, so a chat reads both.
-	GetPendingPaymail(context.Context, *connect.Request[v1.GetPendingPaymailRequest]) (*connect.Response[v1.GetPendingPaymailResponse], error)
-	// Read the address that holds a BitName. A message pays the holder.
-	GetBitNameOwner(context.Context, *connect.Request[v1.GetBitNameOwnerRequest]) (*connect.Response[v1.GetBitNameOwnerResponse], error)
-	// Resolve a commitment from a BitName.
-	ResolveCommit(context.Context, *connect.Request[v1.ResolveCommitRequest]) (*connect.Response[v1.ResolveCommitResponse], error)
-	// Read a data commitment from an address, before a BitName holds it.
-	ReadCommitment(context.Context, *connect.Request[v1.ReadCommitmentRequest]) (*connect.Response[v1.ReadCommitmentResponse], error)
-	// Sign an arbitrary message with the specified verifying key.
-	SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error)
-	// Sign an arbitrary message as a specific address.
-	SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// List owned UTXOs.
-	MyUtxos(context.Context, *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error)
-	// Get OpenAPI schema.
-	OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error)
-}
-
-// NewBitnamesServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBitnamesServiceHandler(svc BitnamesServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	bitnamesServiceMethods := v1.File_bitnames_v1_bitnames_proto.Services().ByName("BitnamesService").Methods()
-	bitnamesServiceGetBalanceHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceStopHandler := connect.NewUnaryHandler(
-		BitnamesServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(bitnamesServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceWithdrawHandler := connect.NewUnaryHandler(
-		BitnamesServiceWithdrawProcedure,
-		svc.Withdraw,
-		connect.WithSchema(bitnamesServiceMethods.ByName("Withdraw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceTransferHandler := connect.NewUnaryHandler(
-		BitnamesServiceTransferProcedure,
-		svc.Transfer,
-		connect.WithSchema(bitnamesServiceMethods.ByName("Transfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetSidechainWealthHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetSidechainWealthProcedure,
-		svc.GetSidechainWealth,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetSidechainWealth")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceCreateDepositHandler := connect.NewUnaryHandler(
-		BitnamesServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(bitnamesServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetPendingWithdrawalBundleHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetPendingWithdrawalBundleProcedure,
-		svc.GetPendingWithdrawalBundle,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetPendingWithdrawalBundle")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceConnectPeerHandler := connect.NewUnaryHandler(
-		BitnamesServiceConnectPeerProcedure,
-		svc.ConnectPeer,
-		connect.WithSchema(bitnamesServiceMethods.ByName("ConnectPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceListPeersHandler := connect.NewUnaryHandler(
-		BitnamesServiceListPeersProcedure,
-		svc.ListPeers,
-		connect.WithSchema(bitnamesServiceMethods.ByName("ListPeers")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceMineHandler := connect.NewUnaryHandler(
-		BitnamesServiceMineProcedure,
-		svc.Mine,
-		connect.WithSchema(bitnamesServiceMethods.ByName("Mine")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetBlockHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetBestMainchainBlockHashHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBestMainchainBlockHashProcedure,
-		svc.GetBestMainchainBlockHash,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBestMainchainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetBestSidechainBlockHashHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBestSidechainBlockHashProcedure,
-		svc.GetBestSidechainBlockHash,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBestSidechainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetBmmInclusionsHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBmmInclusionsProcedure,
-		svc.GetBmmInclusions,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBmmInclusions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetWalletUtxosHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetWalletUtxosProcedure,
-		svc.GetWalletUtxos,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetWalletUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceListUtxosHandler := connect.NewUnaryHandler(
-		BitnamesServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(bitnamesServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetLatestFailedWithdrawalBundleHeightHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-		svc.GetLatestFailedWithdrawalBundleHeight,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGenerateMnemonicHandler := connect.NewUnaryHandler(
-		BitnamesServiceGenerateMnemonicProcedure,
-		svc.GenerateMnemonic,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GenerateMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceSetSeedFromMnemonicHandler := connect.NewUnaryHandler(
-		BitnamesServiceSetSeedFromMnemonicProcedure,
-		svc.SetSeedFromMnemonic,
-		connect.WithSchema(bitnamesServiceMethods.ByName("SetSeedFromMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceCallRawHandler := connect.NewUnaryHandler(
-		BitnamesServiceCallRawProcedure,
-		svc.CallRaw,
-		connect.WithSchema(bitnamesServiceMethods.ByName("CallRaw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetBitNameDataHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBitNameDataProcedure,
-		svc.GetBitNameData,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBitNameData")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceListBitNamesHandler := connect.NewUnaryHandler(
-		BitnamesServiceListBitNamesProcedure,
-		svc.ListBitNames,
-		connect.WithSchema(bitnamesServiceMethods.ByName("ListBitNames")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceRegisterBitNameHandler := connect.NewUnaryHandler(
-		BitnamesServiceRegisterBitNameProcedure,
-		svc.RegisterBitName,
-		connect.WithSchema(bitnamesServiceMethods.ByName("RegisterBitName")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceReserveBitNameHandler := connect.NewUnaryHandler(
-		BitnamesServiceReserveBitNameProcedure,
-		svc.ReserveBitName,
-		connect.WithSchema(bitnamesServiceMethods.ByName("ReserveBitName")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetNewEncryptionKeyHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetNewEncryptionKeyProcedure,
-		svc.GetNewEncryptionKey,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetNewEncryptionKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetNewVerifyingKeyHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetNewVerifyingKeyProcedure,
-		svc.GetNewVerifyingKey,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetNewVerifyingKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceDecryptMsgHandler := connect.NewUnaryHandler(
-		BitnamesServiceDecryptMsgProcedure,
-		svc.DecryptMsg,
-		connect.WithSchema(bitnamesServiceMethods.ByName("DecryptMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceEncryptMsgHandler := connect.NewUnaryHandler(
-		BitnamesServiceEncryptMsgProcedure,
-		svc.EncryptMsg,
-		connect.WithSchema(bitnamesServiceMethods.ByName("EncryptMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetPaymailHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetPaymailProcedure,
-		svc.GetPaymail,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetPaymail")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetPendingPaymailHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetPendingPaymailProcedure,
-		svc.GetPendingPaymail,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetPendingPaymail")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetBitNameOwnerHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetBitNameOwnerProcedure,
-		svc.GetBitNameOwner,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetBitNameOwner")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceResolveCommitHandler := connect.NewUnaryHandler(
-		BitnamesServiceResolveCommitProcedure,
-		svc.ResolveCommit,
-		connect.WithSchema(bitnamesServiceMethods.ByName("ResolveCommit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceReadCommitmentHandler := connect.NewUnaryHandler(
-		BitnamesServiceReadCommitmentProcedure,
-		svc.ReadCommitment,
-		connect.WithSchema(bitnamesServiceMethods.ByName("ReadCommitment")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceSignArbitraryMsgHandler := connect.NewUnaryHandler(
-		BitnamesServiceSignArbitraryMsgProcedure,
-		svc.SignArbitraryMsg,
-		connect.WithSchema(bitnamesServiceMethods.ByName("SignArbitraryMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceSignArbitraryMsgAsAddrHandler := connect.NewUnaryHandler(
-		BitnamesServiceSignArbitraryMsgAsAddrProcedure,
-		svc.SignArbitraryMsgAsAddr,
-		connect.WithSchema(bitnamesServiceMethods.ByName("SignArbitraryMsgAsAddr")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceGetWalletAddressesHandler := connect.NewUnaryHandler(
-		BitnamesServiceGetWalletAddressesProcedure,
-		svc.GetWalletAddresses,
-		connect.WithSchema(bitnamesServiceMethods.ByName("GetWalletAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceMyUtxosHandler := connect.NewUnaryHandler(
-		BitnamesServiceMyUtxosProcedure,
-		svc.MyUtxos,
-		connect.WithSchema(bitnamesServiceMethods.ByName("MyUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitnamesServiceOpenapiSchemaHandler := connect.NewUnaryHandler(
-		BitnamesServiceOpenapiSchemaProcedure,
-		svc.OpenapiSchema,
-		connect.WithSchema(bitnamesServiceMethods.ByName("OpenapiSchema")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/bitnames.v1.BitnamesService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BitnamesServiceGetBalanceProcedure:
-			bitnamesServiceGetBalanceHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetBlockCountProcedure:
-			bitnamesServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case BitnamesServiceStopProcedure:
-			bitnamesServiceStopHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetNewAddressProcedure:
-			bitnamesServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case BitnamesServiceWithdrawProcedure:
-			bitnamesServiceWithdrawHandler.ServeHTTP(w, r)
-		case BitnamesServiceTransferProcedure:
-			bitnamesServiceTransferHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetSidechainWealthProcedure:
-			bitnamesServiceGetSidechainWealthHandler.ServeHTTP(w, r)
-		case BitnamesServiceCreateDepositProcedure:
-			bitnamesServiceCreateDepositHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetPendingWithdrawalBundleProcedure:
-			bitnamesServiceGetPendingWithdrawalBundleHandler.ServeHTTP(w, r)
-		case BitnamesServiceConnectPeerProcedure:
-			bitnamesServiceConnectPeerHandler.ServeHTTP(w, r)
-		case BitnamesServiceListPeersProcedure:
-			bitnamesServiceListPeersHandler.ServeHTTP(w, r)
-		case BitnamesServiceMineProcedure:
-			bitnamesServiceMineHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetBlockProcedure:
-			bitnamesServiceGetBlockHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetBestMainchainBlockHashProcedure:
-			bitnamesServiceGetBestMainchainBlockHashHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetBestSidechainBlockHashProcedure:
-			bitnamesServiceGetBestSidechainBlockHashHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetBmmInclusionsProcedure:
-			bitnamesServiceGetBmmInclusionsHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetWalletUtxosProcedure:
-			bitnamesServiceGetWalletUtxosHandler.ServeHTTP(w, r)
-		case BitnamesServiceListUtxosProcedure:
-			bitnamesServiceListUtxosHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetLatestFailedWithdrawalBundleHeightProcedure:
-			bitnamesServiceGetLatestFailedWithdrawalBundleHeightHandler.ServeHTTP(w, r)
-		case BitnamesServiceGenerateMnemonicProcedure:
-			bitnamesServiceGenerateMnemonicHandler.ServeHTTP(w, r)
-		case BitnamesServiceSetSeedFromMnemonicProcedure:
-			bitnamesServiceSetSeedFromMnemonicHandler.ServeHTTP(w, r)
-		case BitnamesServiceCallRawProcedure:
-			bitnamesServiceCallRawHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetBitNameDataProcedure:
-			bitnamesServiceGetBitNameDataHandler.ServeHTTP(w, r)
-		case BitnamesServiceListBitNamesProcedure:
-			bitnamesServiceListBitNamesHandler.ServeHTTP(w, r)
-		case BitnamesServiceRegisterBitNameProcedure:
-			bitnamesServiceRegisterBitNameHandler.ServeHTTP(w, r)
-		case BitnamesServiceReserveBitNameProcedure:
-			bitnamesServiceReserveBitNameHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetNewEncryptionKeyProcedure:
-			bitnamesServiceGetNewEncryptionKeyHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetNewVerifyingKeyProcedure:
-			bitnamesServiceGetNewVerifyingKeyHandler.ServeHTTP(w, r)
-		case BitnamesServiceDecryptMsgProcedure:
-			bitnamesServiceDecryptMsgHandler.ServeHTTP(w, r)
-		case BitnamesServiceEncryptMsgProcedure:
-			bitnamesServiceEncryptMsgHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetPaymailProcedure:
-			bitnamesServiceGetPaymailHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetPendingPaymailProcedure:
-			bitnamesServiceGetPendingPaymailHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetBitNameOwnerProcedure:
-			bitnamesServiceGetBitNameOwnerHandler.ServeHTTP(w, r)
-		case BitnamesServiceResolveCommitProcedure:
-			bitnamesServiceResolveCommitHandler.ServeHTTP(w, r)
-		case BitnamesServiceReadCommitmentProcedure:
-			bitnamesServiceReadCommitmentHandler.ServeHTTP(w, r)
-		case BitnamesServiceSignArbitraryMsgProcedure:
-			bitnamesServiceSignArbitraryMsgHandler.ServeHTTP(w, r)
-		case BitnamesServiceSignArbitraryMsgAsAddrProcedure:
-			bitnamesServiceSignArbitraryMsgAsAddrHandler.ServeHTTP(w, r)
-		case BitnamesServiceGetWalletAddressesProcedure:
-			bitnamesServiceGetWalletAddressesHandler.ServeHTTP(w, r)
-		case BitnamesServiceMyUtxosProcedure:
-			bitnamesServiceMyUtxosHandler.ServeHTTP(w, r)
-		case BitnamesServiceOpenapiSchemaProcedure:
-			bitnamesServiceOpenapiSchemaHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedBitnamesServiceHandler) OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bitnames.v1.BitnamesService.OpenapiSchema is not implemented")
 }
 
-// UnimplementedBitnamesServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBitnamesServiceHandler struct{}
+type bitnamesServiceClient struct {
+	client *connect.Client
+}
+
+func (c *bitnamesServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) Withdraw(ctx context.Context, req *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	var res v1.WithdrawResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceWithdrawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) Transfer(ctx context.Context, req *v1.TransferRequest) (*v1.TransferResponse, error) {
+	var res v1.TransferResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetSidechainWealth(ctx context.Context, req *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	var res v1.GetSidechainWealthResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetSidechainWealthSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	var res v1.GetPendingWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetPendingWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedBitnamesServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBalance is not implemented"))
+func (c *bitnamesServiceClient) ConnectPeer(ctx context.Context, req *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	var res v1.ConnectPeerResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceConnectPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) ListPeers(ctx context.Context, req *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	var res v1.ListPeersResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceListPeersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) Mine(ctx context.Context, req *v1.MineRequest) (*v1.MineResponse, error) {
+	var res v1.MineResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceMineSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	var res v1.GetBestMainchainBlockHashResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBestMainchainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	var res v1.GetBestSidechainBlockHashResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBestSidechainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetBmmInclusions(ctx context.Context, req *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	var res v1.GetBmmInclusionsResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBmmInclusionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetWalletUtxos(ctx context.Context, req *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	var res v1.GetWalletUtxosResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetWalletUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	var res v1.GetLatestFailedWithdrawalBundleHeightResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetLatestFailedWithdrawalBundleHeightSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GenerateMnemonic(ctx context.Context, req *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	var res v1.GenerateMnemonicResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGenerateMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) SetSeedFromMnemonic(ctx context.Context, req *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	var res v1.SetSeedFromMnemonicResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceSetSeedFromMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) CallRaw(ctx context.Context, req *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	var res v1.CallRawResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceCallRawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetBitNameData(ctx context.Context, req *v1.GetBitNameDataRequest) (*v1.GetBitNameDataResponse, error) {
+	var res v1.GetBitNameDataResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBitNameDataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) ListBitNames(ctx context.Context, req *v1.ListBitNamesRequest) (*v1.ListBitNamesResponse, error) {
+	var res v1.ListBitNamesResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceListBitNamesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) RegisterBitName(ctx context.Context, req *v1.RegisterBitNameRequest) (*v1.RegisterBitNameResponse, error) {
+	var res v1.RegisterBitNameResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceRegisterBitNameSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) ReserveBitName(ctx context.Context, req *v1.ReserveBitNameRequest) (*v1.ReserveBitNameResponse, error) {
+	var res v1.ReserveBitNameResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceReserveBitNameSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetNewEncryptionKey(ctx context.Context, req *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error) {
+	var res v1.GetNewEncryptionKeyResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetNewEncryptionKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetNewVerifyingKey(ctx context.Context, req *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error) {
+	var res v1.GetNewVerifyingKeyResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetNewVerifyingKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) DecryptMsg(ctx context.Context, req *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error) {
+	var res v1.DecryptMsgResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceDecryptMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) EncryptMsg(ctx context.Context, req *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error) {
+	var res v1.EncryptMsgResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceEncryptMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetPaymail(ctx context.Context, req *v1.GetPaymailRequest) (*v1.GetPaymailResponse, error) {
+	var res v1.GetPaymailResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetPaymailSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetPendingPaymail(ctx context.Context, req *v1.GetPendingPaymailRequest) (*v1.GetPendingPaymailResponse, error) {
+	var res v1.GetPendingPaymailResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetPendingPaymailSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetBitNameOwner(ctx context.Context, req *v1.GetBitNameOwnerRequest) (*v1.GetBitNameOwnerResponse, error) {
+	var res v1.GetBitNameOwnerResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetBitNameOwnerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) ResolveCommit(ctx context.Context, req *v1.ResolveCommitRequest) (*v1.ResolveCommitResponse, error) {
+	var res v1.ResolveCommitResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceResolveCommitSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) ReadCommitment(ctx context.Context, req *v1.ReadCommitmentRequest) (*v1.ReadCommitmentResponse, error) {
+	var res v1.ReadCommitmentResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceReadCommitmentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) SignArbitraryMsg(ctx context.Context, req *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error) {
+	var res v1.SignArbitraryMsgResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceSignArbitraryMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) SignArbitraryMsgAsAddr(ctx context.Context, req *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error) {
+	var res v1.SignArbitraryMsgAsAddrResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceSignArbitraryMsgAsAddrSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) GetWalletAddresses(ctx context.Context, req *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	var res v1.GetWalletAddressesResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceGetWalletAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitnamesServiceClient) MyUtxos(ctx context.Context, req *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error) {
+	var res v1.MyUtxosResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceMyUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitnamesServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBlockCount is not implemented"))
+func (c *bitnamesServiceClient) OpenapiSchema(ctx context.Context, req *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error) {
+	var res v1.OpenapiSchemaResponse
+	if err := c.client.CallUnary(ctx, bitnamesServiceOpenapiSchemaSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitnamesServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.Stop is not implemented"))
+type bitnamesServiceHandler struct{ svc BitnamesServiceHandler }
+
+func (h bitnamesServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetNewAddress is not implemented"))
+func (h bitnamesServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.Withdraw is not implemented"))
+func (h bitnamesServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.Transfer is not implemented"))
+func (h bitnamesServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetSidechainWealth is not implemented"))
+func (h bitnamesServiceHandler) withdraw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WithdrawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Withdraw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.CreateDeposit is not implemented"))
+func (h bitnamesServiceHandler) transfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Transfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetPendingWithdrawalBundle is not implemented"))
+func (h bitnamesServiceHandler) getSidechainWealth(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainWealthRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainWealth(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.ConnectPeer is not implemented"))
+func (h bitnamesServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.ListPeers is not implemented"))
+func (h bitnamesServiceHandler) getPendingWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.Mine is not implemented"))
+func (h bitnamesServiceHandler) connectPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBlock is not implemented"))
+func (h bitnamesServiceHandler) listPeers(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPeersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPeers(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBestMainchainBlockHash is not implemented"))
+func (h bitnamesServiceHandler) mine(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MineRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Mine(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBestSidechainBlockHash is not implemented"))
+func (h bitnamesServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBmmInclusions is not implemented"))
+func (h bitnamesServiceHandler) getBestMainchainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestMainchainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestMainchainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetWalletUtxos is not implemented"))
+func (h bitnamesServiceHandler) getBestSidechainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestSidechainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestSidechainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.ListUtxos is not implemented"))
+func (h bitnamesServiceHandler) getBmmInclusions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmInclusionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmInclusions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetLatestFailedWithdrawalBundleHeight is not implemented"))
+func (h bitnamesServiceHandler) getWalletUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GenerateMnemonic is not implemented"))
+func (h bitnamesServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.SetSeedFromMnemonic is not implemented"))
+func (h bitnamesServiceHandler) getLatestFailedWithdrawalBundleHeight(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetLatestFailedWithdrawalBundleHeightRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetLatestFailedWithdrawalBundleHeight(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.CallRaw is not implemented"))
+func (h bitnamesServiceHandler) generateMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetBitNameData(context.Context, *connect.Request[v1.GetBitNameDataRequest]) (*connect.Response[v1.GetBitNameDataResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBitNameData is not implemented"))
+func (h bitnamesServiceHandler) setSeedFromMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSeedFromMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSeedFromMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) ListBitNames(context.Context, *connect.Request[v1.ListBitNamesRequest]) (*connect.Response[v1.ListBitNamesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.ListBitNames is not implemented"))
+func (h bitnamesServiceHandler) callRaw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CallRawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CallRaw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) RegisterBitName(context.Context, *connect.Request[v1.RegisterBitNameRequest]) (*connect.Response[v1.RegisterBitNameResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.RegisterBitName is not implemented"))
+func (h bitnamesServiceHandler) getBitNameData(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBitNameDataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBitNameData(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) ReserveBitName(context.Context, *connect.Request[v1.ReserveBitNameRequest]) (*connect.Response[v1.ReserveBitNameResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.ReserveBitName is not implemented"))
+func (h bitnamesServiceHandler) listBitNames(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListBitNamesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListBitNames(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetNewEncryptionKey is not implemented"))
+func (h bitnamesServiceHandler) registerBitName(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RegisterBitNameRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RegisterBitName(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetNewVerifyingKey is not implemented"))
+func (h bitnamesServiceHandler) reserveBitName(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ReserveBitNameRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ReserveBitName(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.DecryptMsg is not implemented"))
+func (h bitnamesServiceHandler) getNewEncryptionKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewEncryptionKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewEncryptionKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.EncryptMsg is not implemented"))
+func (h bitnamesServiceHandler) getNewVerifyingKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewVerifyingKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewVerifyingKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetPaymail(context.Context, *connect.Request[v1.GetPaymailRequest]) (*connect.Response[v1.GetPaymailResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetPaymail is not implemented"))
+func (h bitnamesServiceHandler) decryptMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DecryptMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DecryptMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetPendingPaymail(context.Context, *connect.Request[v1.GetPendingPaymailRequest]) (*connect.Response[v1.GetPendingPaymailResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetPendingPaymail is not implemented"))
+func (h bitnamesServiceHandler) encryptMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EncryptMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EncryptMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetBitNameOwner(context.Context, *connect.Request[v1.GetBitNameOwnerRequest]) (*connect.Response[v1.GetBitNameOwnerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetBitNameOwner is not implemented"))
+func (h bitnamesServiceHandler) getPaymail(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPaymailRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPaymail(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) ResolveCommit(context.Context, *connect.Request[v1.ResolveCommitRequest]) (*connect.Response[v1.ResolveCommitResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.ResolveCommit is not implemented"))
+func (h bitnamesServiceHandler) getPendingPaymail(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingPaymailRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingPaymail(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) ReadCommitment(context.Context, *connect.Request[v1.ReadCommitmentRequest]) (*connect.Response[v1.ReadCommitmentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.ReadCommitment is not implemented"))
+func (h bitnamesServiceHandler) getBitNameOwner(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBitNameOwnerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBitNameOwner(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.SignArbitraryMsg is not implemented"))
+func (h bitnamesServiceHandler) resolveCommit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ResolveCommitRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ResolveCommit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.SignArbitraryMsgAsAddr is not implemented"))
+func (h bitnamesServiceHandler) readCommitment(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ReadCommitmentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ReadCommitment(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.GetWalletAddresses is not implemented"))
+func (h bitnamesServiceHandler) signArbitraryMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignArbitraryMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignArbitraryMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) MyUtxos(context.Context, *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.MyUtxos is not implemented"))
+func (h bitnamesServiceHandler) signArbitraryMsgAsAddr(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignArbitraryMsgAsAddrRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignArbitraryMsgAsAddr(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitnamesServiceHandler) OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bitnames.v1.BitnamesService.OpenapiSchema is not implemented"))
+func (h bitnamesServiceHandler) getWalletAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitnamesServiceHandler) myUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MyUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MyUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitnamesServiceHandler) openapiSchema(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.OpenapiSchemaRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.OpenapiSchema(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/bmm/v1/bmmv1connect/bmm.connect.go b/sidechain-orchestrator/gen/bmm/v1/bmmv1connect/bmm.connect.go
index 32bc50a3c4..3bef0ff622 100644
--- a/sidechain-orchestrator/gen/bmm/v1/bmmv1connect/bmm.connect.go
+++ b/sidechain-orchestrator/gen/bmm/v1/bmmv1connect/bmm.connect.go
@@ -5,396 +5,447 @@
 package bmmv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BMMServiceName is the fully-qualified name of the BMMService service.
 	BMMServiceName = "bmm.v1.BMMService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BMMServiceStartProcedure is the fully-qualified name of the BMMService's Start RPC.
+	// BMMServiceStartProcedure is the procedure name of the BMMService's Start RPC.
 	BMMServiceStartProcedure = "/bmm.v1.BMMService/Start"
-	// BMMServiceStopProcedure is the fully-qualified name of the BMMService's Stop RPC.
+	// BMMServiceStopProcedure is the procedure name of the BMMService's Stop RPC.
 	BMMServiceStopProcedure = "/bmm.v1.BMMService/Stop"
-	// BMMServiceClearHistoryProcedure is the fully-qualified name of the BMMService's ClearHistory RPC.
+	// BMMServiceClearHistoryProcedure is the procedure name of the BMMService's ClearHistory RPC.
 	BMMServiceClearHistoryProcedure = "/bmm.v1.BMMService/ClearHistory"
-	// BMMServiceWatchProcedure is the fully-qualified name of the BMMService's Watch RPC.
+	// BMMServiceWatchProcedure is the procedure name of the BMMService's Watch RPC.
 	BMMServiceWatchProcedure = "/bmm.v1.BMMService/Watch"
-	// BMMServiceGetRoundBidsProcedure is the fully-qualified name of the BMMService's GetRoundBids RPC.
+	// BMMServiceGetRoundBidsProcedure is the procedure name of the BMMService's GetRoundBids RPC.
 	BMMServiceGetRoundBidsProcedure = "/bmm.v1.BMMService/GetRoundBids"
-	// BMMServiceCreateBidProcedure is the fully-qualified name of the BMMService's CreateBid RPC.
+	// BMMServiceCreateBidProcedure is the procedure name of the BMMService's CreateBid RPC.
 	BMMServiceCreateBidProcedure = "/bmm.v1.BMMService/CreateBid"
-	// BMMServiceConnectBidProcedure is the fully-qualified name of the BMMService's ConnectBid RPC.
+	// BMMServiceConnectBidProcedure is the procedure name of the BMMService's ConnectBid RPC.
 	BMMServiceConnectBidProcedure = "/bmm.v1.BMMService/ConnectBid"
-	// BMMServiceCancelBidProcedure is the fully-qualified name of the BMMService's CancelBid RPC.
+	// BMMServiceCancelBidProcedure is the procedure name of the BMMService's CancelBid RPC.
 	BMMServiceCancelBidProcedure = "/bmm.v1.BMMService/CancelBid"
-	// BMMServiceListBidsProcedure is the fully-qualified name of the BMMService's ListBids RPC.
+	// BMMServiceListBidsProcedure is the procedure name of the BMMService's ListBids RPC.
 	BMMServiceListBidsProcedure = "/bmm.v1.BMMService/ListBids"
-	// BMMServicePrepareBMMProcedure is the fully-qualified name of the BMMService's PrepareBMM RPC.
+	// BMMServicePrepareBMMProcedure is the procedure name of the BMMService's PrepareBMM RPC.
 	BMMServicePrepareBMMProcedure = "/bmm.v1.BMMService/PrepareBMM"
 )
 
+var (
+	bMMServiceStartSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("Start"),
+			Procedure:  BMMServiceStartProcedure,
+		}
+	})
+	bMMServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("Stop"),
+			Procedure:  BMMServiceStopProcedure,
+		}
+	})
+	bMMServiceClearHistorySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("ClearHistory"),
+			Procedure:  BMMServiceClearHistoryProcedure,
+		}
+	})
+	bMMServiceWatchSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("Watch"),
+			Procedure:  BMMServiceWatchProcedure,
+		}
+	})
+	bMMServiceGetRoundBidsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("GetRoundBids"),
+			Procedure:  BMMServiceGetRoundBidsProcedure,
+		}
+	})
+	bMMServiceCreateBidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("CreateBid"),
+			Procedure:  BMMServiceCreateBidProcedure,
+		}
+	})
+	bMMServiceConnectBidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("ConnectBid"),
+			Procedure:  BMMServiceConnectBidProcedure,
+		}
+	})
+	bMMServiceCancelBidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("CancelBid"),
+			Procedure:  BMMServiceCancelBidProcedure,
+		}
+	})
+	bMMServiceListBidsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("ListBids"),
+			Procedure:  BMMServiceListBidsProcedure,
+		}
+	})
+	bMMServicePrepareBMMSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods().ByName("PrepareBMM"),
+			Procedure:  BMMServicePrepareBMMProcedure,
+		}
+	})
+)
+
 // BMMServiceClient is a client for the bmm.v1.BMMService service.
 type BMMServiceClient interface {
-	// Start bids on every new mainchain tip and connects the blocks miners take,
-	// until Stop. Bids are funded by the wallet the request names, and are
-	// opened at Core's next block fee and raised toward max_bid_sats when a
-	// competitor outbids us.
-	Start(context.Context, *connect.Request[v1.StartRequest]) (*connect.Response[v1.StartResponse], error)
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	ClearHistory(context.Context, *connect.Request[v1.ClearHistoryRequest]) (*connect.Response[v1.ClearHistoryResponse], error)
-	// Watch streams the round being bid on now plus recent finished rounds. The
-	// full state goes out on every frame, so a reconnect needs no delta merge.
-	Watch(context.Context, *connect.Request[v1.WatchRequest]) (*connect.ServerStreamForClient[v1.WatchResponse], error)
-	// GetRoundBids returns every bid seen for one round. A losing bid never
-	// confirms and leaves the mempool, so this is limited to what was observed
-	// while that round was open.
-	GetRoundBids(context.Context, *connect.Request[v1.GetRoundBidsRequest]) (*connect.Response[v1.GetRoundBidsResponse], error)
-	// CreateBid assembles a sidechain block and broadcasts one M8 bid for it;
-	// ConnectBid connects that block once a miner includes the bid. Use these to
-	// drive a single attempt by hand; Start does both on a loop.
-	CreateBid(context.Context, *connect.Request[v1.CreateBidRequest]) (*connect.Response[v1.CreateBidResponse], error)
-	ConnectBid(context.Context, *connect.Request[v1.ConnectBidRequest]) (*connect.Response[v1.ConnectBidResponse], error)
-	// CancelBid replaces a stranded bid with a payment back to its own wallet,
-	// so the coins under it come back. A bid that can still win is refused.
-	CancelBid(context.Context, *connect.Request[v1.CancelBidRequest]) (*connect.Response[v1.CancelBidResponse], error)
-	// ListBids reads the competing bids for the slot out of the mainchain
-	// mempool, highest bid first.
-	ListBids(context.Context, *connect.Request[v1.ListBidsRequest]) (*connect.Response[v1.ListBidsResponse], error)
-	// PrepareBMM gives every bidding sidechain a coin of its own to bid from,
-	// and splits one large coin when the wallet holds too few. One wallet funds
-	// them all, and a bid over another slot's bid change dies when that slot
-	// replaces its own bid.
-	PrepareBMM(context.Context, *connect.Request[v1.PrepareBMMRequest]) (*connect.Response[v1.PrepareBMMResponse], error)
-}
-
-// NewBMMServiceClient constructs a client for the bmm.v1.BMMService service. By default, it uses
-// the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBMMServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BMMServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	bMMServiceMethods := v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods()
-	return &bMMServiceClient{
-		start: connect.NewClient[v1.StartRequest, v1.StartResponse](
-			httpClient,
-			baseURL+BMMServiceStartProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("Start")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+BMMServiceStopProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		clearHistory: connect.NewClient[v1.ClearHistoryRequest, v1.ClearHistoryResponse](
-			httpClient,
-			baseURL+BMMServiceClearHistoryProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("ClearHistory")),
-			connect.WithClientOptions(opts...),
-		),
-		watch: connect.NewClient[v1.WatchRequest, v1.WatchResponse](
-			httpClient,
-			baseURL+BMMServiceWatchProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("Watch")),
-			connect.WithClientOptions(opts...),
-		),
-		getRoundBids: connect.NewClient[v1.GetRoundBidsRequest, v1.GetRoundBidsResponse](
-			httpClient,
-			baseURL+BMMServiceGetRoundBidsProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("GetRoundBids")),
-			connect.WithClientOptions(opts...),
-		),
-		createBid: connect.NewClient[v1.CreateBidRequest, v1.CreateBidResponse](
-			httpClient,
-			baseURL+BMMServiceCreateBidProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("CreateBid")),
-			connect.WithClientOptions(opts...),
-		),
-		connectBid: connect.NewClient[v1.ConnectBidRequest, v1.ConnectBidResponse](
-			httpClient,
-			baseURL+BMMServiceConnectBidProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("ConnectBid")),
-			connect.WithClientOptions(opts...),
-		),
-		cancelBid: connect.NewClient[v1.CancelBidRequest, v1.CancelBidResponse](
-			httpClient,
-			baseURL+BMMServiceCancelBidProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("CancelBid")),
-			connect.WithClientOptions(opts...),
-		),
-		listBids: connect.NewClient[v1.ListBidsRequest, v1.ListBidsResponse](
-			httpClient,
-			baseURL+BMMServiceListBidsProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("ListBids")),
-			connect.WithClientOptions(opts...),
-		),
-		prepareBMM: connect.NewClient[v1.PrepareBMMRequest, v1.PrepareBMMResponse](
-			httpClient,
-			baseURL+BMMServicePrepareBMMProcedure,
-			connect.WithSchema(bMMServiceMethods.ByName("PrepareBMM")),
-			connect.WithClientOptions(opts...),
-		),
+	Start(context.Context, *v1.StartRequest) (*v1.StartResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	ClearHistory(context.Context, *v1.ClearHistoryRequest) (*v1.ClearHistoryResponse, error)
+	Watch(context.Context, *v1.WatchRequest) (BMMServiceWatchClientStream, error)
+	GetRoundBids(context.Context, *v1.GetRoundBidsRequest) (*v1.GetRoundBidsResponse, error)
+	CreateBid(context.Context, *v1.CreateBidRequest) (*v1.CreateBidResponse, error)
+	ConnectBid(context.Context, *v1.ConnectBidRequest) (*v1.ConnectBidResponse, error)
+	CancelBid(context.Context, *v1.CancelBidRequest) (*v1.CancelBidResponse, error)
+	ListBids(context.Context, *v1.ListBidsRequest) (*v1.ListBidsResponse, error)
+	PrepareBMM(context.Context, *v1.PrepareBMMRequest) (*v1.PrepareBMMResponse, error)
+}
+
+// NewBMMServiceClient constructs a client for the bmm.v1.BMMService service. Multiple service
+// clients may share a single connect.Client.
+func NewBMMServiceClient(client *connect.Client) BMMServiceClient {
+	return &bMMServiceClient{client: client}
+}
+
+// BMMServiceWatchClientStream is the client stream for the BMMService's Watch RPC.
+type BMMServiceWatchClientStream struct {
+	stream connect.ClientStream
+}
+
+// Receive returns the next response message from the server.
+func (s BMMServiceWatchClientStream) Receive() (*v1.WatchResponse, error) {
+	var res v1.WatchResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
 	}
+	return &res, nil
 }
 
-// bMMServiceClient implements BMMServiceClient.
-type bMMServiceClient struct {
-	start        *connect.Client[v1.StartRequest, v1.StartResponse]
-	stop         *connect.Client[v1.StopRequest, v1.StopResponse]
-	clearHistory *connect.Client[v1.ClearHistoryRequest, v1.ClearHistoryResponse]
-	watch        *connect.Client[v1.WatchRequest, v1.WatchResponse]
-	getRoundBids *connect.Client[v1.GetRoundBidsRequest, v1.GetRoundBidsResponse]
-	createBid    *connect.Client[v1.CreateBidRequest, v1.CreateBidResponse]
-	connectBid   *connect.Client[v1.ConnectBidRequest, v1.ConnectBidResponse]
-	cancelBid    *connect.Client[v1.CancelBidRequest, v1.CancelBidResponse]
-	listBids     *connect.Client[v1.ListBidsRequest, v1.ListBidsResponse]
-	prepareBMM   *connect.Client[v1.PrepareBMMRequest, v1.PrepareBMMResponse]
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s BMMServiceWatchClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// Start calls bmm.v1.BMMService.Start.
-func (c *bMMServiceClient) Start(ctx context.Context, req *connect.Request[v1.StartRequest]) (*connect.Response[v1.StartResponse], error) {
-	return c.start.CallUnary(ctx, req)
+// BMMServiceHandler is an implementation of the bmm.v1.BMMService service.
+type BMMServiceHandler interface {
+	Start(context.Context, *v1.StartRequest) (*v1.StartResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	ClearHistory(context.Context, *v1.ClearHistoryRequest) (*v1.ClearHistoryResponse, error)
+	Watch(context.Context, *v1.WatchRequest, BMMServiceWatchServerStream) error
+	GetRoundBids(context.Context, *v1.GetRoundBidsRequest) (*v1.GetRoundBidsResponse, error)
+	CreateBid(context.Context, *v1.CreateBidRequest) (*v1.CreateBidResponse, error)
+	ConnectBid(context.Context, *v1.ConnectBidRequest) (*v1.ConnectBidResponse, error)
+	CancelBid(context.Context, *v1.CancelBidRequest) (*v1.CancelBidResponse, error)
+	ListBids(context.Context, *v1.ListBidsRequest) (*v1.ListBidsResponse, error)
+	PrepareBMM(context.Context, *v1.PrepareBMMRequest) (*v1.PrepareBMMResponse, error)
 }
 
-// Stop calls bmm.v1.BMMService.Stop.
-func (c *bMMServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+// RegisterBMMServiceHandler registers svc as the bmm.v1.BMMService implementation on server.
+func RegisterBMMServiceHandler(server *connect.Server, svc BMMServiceHandler) {
+	adapter := bMMServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: bMMServiceStartSpec(), Handler: adapter.start},
+		connect.Method{Spec: bMMServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: bMMServiceClearHistorySpec(), Handler: adapter.clearHistory},
+		connect.Method{Spec: bMMServiceWatchSpec(), Handler: adapter.watch},
+		connect.Method{Spec: bMMServiceGetRoundBidsSpec(), Handler: adapter.getRoundBids},
+		connect.Method{Spec: bMMServiceCreateBidSpec(), Handler: adapter.createBid},
+		connect.Method{Spec: bMMServiceConnectBidSpec(), Handler: adapter.connectBid},
+		connect.Method{Spec: bMMServiceCancelBidSpec(), Handler: adapter.cancelBid},
+		connect.Method{Spec: bMMServiceListBidsSpec(), Handler: adapter.listBids},
+		connect.Method{Spec: bMMServicePrepareBMMSpec(), Handler: adapter.prepareBMM},
+	)
 }
 
-// ClearHistory calls bmm.v1.BMMService.ClearHistory.
-func (c *bMMServiceClient) ClearHistory(ctx context.Context, req *connect.Request[v1.ClearHistoryRequest]) (*connect.Response[v1.ClearHistoryResponse], error) {
-	return c.clearHistory.CallUnary(ctx, req)
+// BMMServiceWatchServerStream is the server stream for the BMMService's Watch RPC.
+type BMMServiceWatchServerStream struct {
+	stream connect.ServerStream
 }
 
-// Watch calls bmm.v1.BMMService.Watch.
-func (c *bMMServiceClient) Watch(ctx context.Context, req *connect.Request[v1.WatchRequest]) (*connect.ServerStreamForClient[v1.WatchResponse], error) {
-	return c.watch.CallServerStream(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s BMMServiceWatchServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// GetRoundBids calls bmm.v1.BMMService.GetRoundBids.
-func (c *bMMServiceClient) GetRoundBids(ctx context.Context, req *connect.Request[v1.GetRoundBidsRequest]) (*connect.Response[v1.GetRoundBidsResponse], error) {
-	return c.getRoundBids.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s BMMServiceWatchServerStream) Send(res *v1.WatchResponse) error {
+	return s.stream.Send(res)
 }
 
-// CreateBid calls bmm.v1.BMMService.CreateBid.
-func (c *bMMServiceClient) CreateBid(ctx context.Context, req *connect.Request[v1.CreateBidRequest]) (*connect.Response[v1.CreateBidResponse], error) {
-	return c.createBid.CallUnary(ctx, req)
+// UnimplementedBMMServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBMMServiceHandler struct{}
+
+func (UnimplementedBMMServiceHandler) Start(context.Context, *v1.StartRequest) (*v1.StartResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.Start is not implemented")
 }
 
-// ConnectBid calls bmm.v1.BMMService.ConnectBid.
-func (c *bMMServiceClient) ConnectBid(ctx context.Context, req *connect.Request[v1.ConnectBidRequest]) (*connect.Response[v1.ConnectBidResponse], error) {
-	return c.connectBid.CallUnary(ctx, req)
+func (UnimplementedBMMServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.Stop is not implemented")
 }
 
-// CancelBid calls bmm.v1.BMMService.CancelBid.
-func (c *bMMServiceClient) CancelBid(ctx context.Context, req *connect.Request[v1.CancelBidRequest]) (*connect.Response[v1.CancelBidResponse], error) {
-	return c.cancelBid.CallUnary(ctx, req)
+func (UnimplementedBMMServiceHandler) ClearHistory(context.Context, *v1.ClearHistoryRequest) (*v1.ClearHistoryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.ClearHistory is not implemented")
 }
 
-// ListBids calls bmm.v1.BMMService.ListBids.
-func (c *bMMServiceClient) ListBids(ctx context.Context, req *connect.Request[v1.ListBidsRequest]) (*connect.Response[v1.ListBidsResponse], error) {
-	return c.listBids.CallUnary(ctx, req)
+func (UnimplementedBMMServiceHandler) Watch(context.Context, *v1.WatchRequest, BMMServiceWatchServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.Watch is not implemented")
 }
 
-// PrepareBMM calls bmm.v1.BMMService.PrepareBMM.
-func (c *bMMServiceClient) PrepareBMM(ctx context.Context, req *connect.Request[v1.PrepareBMMRequest]) (*connect.Response[v1.PrepareBMMResponse], error) {
-	return c.prepareBMM.CallUnary(ctx, req)
+func (UnimplementedBMMServiceHandler) GetRoundBids(context.Context, *v1.GetRoundBidsRequest) (*v1.GetRoundBidsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.GetRoundBids is not implemented")
 }
 
-// BMMServiceHandler is an implementation of the bmm.v1.BMMService service.
-type BMMServiceHandler interface {
-	// Start bids on every new mainchain tip and connects the blocks miners take,
-	// until Stop. Bids are funded by the wallet the request names, and are
-	// opened at Core's next block fee and raised toward max_bid_sats when a
-	// competitor outbids us.
-	Start(context.Context, *connect.Request[v1.StartRequest]) (*connect.Response[v1.StartResponse], error)
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	ClearHistory(context.Context, *connect.Request[v1.ClearHistoryRequest]) (*connect.Response[v1.ClearHistoryResponse], error)
-	// Watch streams the round being bid on now plus recent finished rounds. The
-	// full state goes out on every frame, so a reconnect needs no delta merge.
-	Watch(context.Context, *connect.Request[v1.WatchRequest], *connect.ServerStream[v1.WatchResponse]) error
-	// GetRoundBids returns every bid seen for one round. A losing bid never
-	// confirms and leaves the mempool, so this is limited to what was observed
-	// while that round was open.
-	GetRoundBids(context.Context, *connect.Request[v1.GetRoundBidsRequest]) (*connect.Response[v1.GetRoundBidsResponse], error)
-	// CreateBid assembles a sidechain block and broadcasts one M8 bid for it;
-	// ConnectBid connects that block once a miner includes the bid. Use these to
-	// drive a single attempt by hand; Start does both on a loop.
-	CreateBid(context.Context, *connect.Request[v1.CreateBidRequest]) (*connect.Response[v1.CreateBidResponse], error)
-	ConnectBid(context.Context, *connect.Request[v1.ConnectBidRequest]) (*connect.Response[v1.ConnectBidResponse], error)
-	// CancelBid replaces a stranded bid with a payment back to its own wallet,
-	// so the coins under it come back. A bid that can still win is refused.
-	CancelBid(context.Context, *connect.Request[v1.CancelBidRequest]) (*connect.Response[v1.CancelBidResponse], error)
-	// ListBids reads the competing bids for the slot out of the mainchain
-	// mempool, highest bid first.
-	ListBids(context.Context, *connect.Request[v1.ListBidsRequest]) (*connect.Response[v1.ListBidsResponse], error)
-	// PrepareBMM gives every bidding sidechain a coin of its own to bid from,
-	// and splits one large coin when the wallet holds too few. One wallet funds
-	// them all, and a bid over another slot's bid change dies when that slot
-	// replaces its own bid.
-	PrepareBMM(context.Context, *connect.Request[v1.PrepareBMMRequest]) (*connect.Response[v1.PrepareBMMResponse], error)
-}
-
-// NewBMMServiceHandler builds an HTTP handler from the service implementation. It returns the path
-// on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBMMServiceHandler(svc BMMServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	bMMServiceMethods := v1.File_bmm_v1_bmm_proto.Services().ByName("BMMService").Methods()
-	bMMServiceStartHandler := connect.NewUnaryHandler(
-		BMMServiceStartProcedure,
-		svc.Start,
-		connect.WithSchema(bMMServiceMethods.ByName("Start")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceStopHandler := connect.NewUnaryHandler(
-		BMMServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(bMMServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceClearHistoryHandler := connect.NewUnaryHandler(
-		BMMServiceClearHistoryProcedure,
-		svc.ClearHistory,
-		connect.WithSchema(bMMServiceMethods.ByName("ClearHistory")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceWatchHandler := connect.NewServerStreamHandler(
-		BMMServiceWatchProcedure,
-		svc.Watch,
-		connect.WithSchema(bMMServiceMethods.ByName("Watch")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceGetRoundBidsHandler := connect.NewUnaryHandler(
-		BMMServiceGetRoundBidsProcedure,
-		svc.GetRoundBids,
-		connect.WithSchema(bMMServiceMethods.ByName("GetRoundBids")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceCreateBidHandler := connect.NewUnaryHandler(
-		BMMServiceCreateBidProcedure,
-		svc.CreateBid,
-		connect.WithSchema(bMMServiceMethods.ByName("CreateBid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceConnectBidHandler := connect.NewUnaryHandler(
-		BMMServiceConnectBidProcedure,
-		svc.ConnectBid,
-		connect.WithSchema(bMMServiceMethods.ByName("ConnectBid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceCancelBidHandler := connect.NewUnaryHandler(
-		BMMServiceCancelBidProcedure,
-		svc.CancelBid,
-		connect.WithSchema(bMMServiceMethods.ByName("CancelBid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServiceListBidsHandler := connect.NewUnaryHandler(
-		BMMServiceListBidsProcedure,
-		svc.ListBids,
-		connect.WithSchema(bMMServiceMethods.ByName("ListBids")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bMMServicePrepareBMMHandler := connect.NewUnaryHandler(
-		BMMServicePrepareBMMProcedure,
-		svc.PrepareBMM,
-		connect.WithSchema(bMMServiceMethods.ByName("PrepareBMM")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/bmm.v1.BMMService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BMMServiceStartProcedure:
-			bMMServiceStartHandler.ServeHTTP(w, r)
-		case BMMServiceStopProcedure:
-			bMMServiceStopHandler.ServeHTTP(w, r)
-		case BMMServiceClearHistoryProcedure:
-			bMMServiceClearHistoryHandler.ServeHTTP(w, r)
-		case BMMServiceWatchProcedure:
-			bMMServiceWatchHandler.ServeHTTP(w, r)
-		case BMMServiceGetRoundBidsProcedure:
-			bMMServiceGetRoundBidsHandler.ServeHTTP(w, r)
-		case BMMServiceCreateBidProcedure:
-			bMMServiceCreateBidHandler.ServeHTTP(w, r)
-		case BMMServiceConnectBidProcedure:
-			bMMServiceConnectBidHandler.ServeHTTP(w, r)
-		case BMMServiceCancelBidProcedure:
-			bMMServiceCancelBidHandler.ServeHTTP(w, r)
-		case BMMServiceListBidsProcedure:
-			bMMServiceListBidsHandler.ServeHTTP(w, r)
-		case BMMServicePrepareBMMProcedure:
-			bMMServicePrepareBMMHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedBMMServiceHandler) CreateBid(context.Context, *v1.CreateBidRequest) (*v1.CreateBidResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.CreateBid is not implemented")
 }
 
-// UnimplementedBMMServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBMMServiceHandler struct{}
+func (UnimplementedBMMServiceHandler) ConnectBid(context.Context, *v1.ConnectBidRequest) (*v1.ConnectBidResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.ConnectBid is not implemented")
+}
+
+func (UnimplementedBMMServiceHandler) CancelBid(context.Context, *v1.CancelBidRequest) (*v1.CancelBidResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.CancelBid is not implemented")
+}
 
-func (UnimplementedBMMServiceHandler) Start(context.Context, *connect.Request[v1.StartRequest]) (*connect.Response[v1.StartResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.Start is not implemented"))
+func (UnimplementedBMMServiceHandler) ListBids(context.Context, *v1.ListBidsRequest) (*v1.ListBidsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.ListBids is not implemented")
 }
 
-func (UnimplementedBMMServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.Stop is not implemented"))
+func (UnimplementedBMMServiceHandler) PrepareBMM(context.Context, *v1.PrepareBMMRequest) (*v1.PrepareBMMResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "bmm.v1.BMMService.PrepareBMM is not implemented")
 }
 
-func (UnimplementedBMMServiceHandler) ClearHistory(context.Context, *connect.Request[v1.ClearHistoryRequest]) (*connect.Response[v1.ClearHistoryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.ClearHistory is not implemented"))
+type bMMServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedBMMServiceHandler) Watch(context.Context, *connect.Request[v1.WatchRequest], *connect.ServerStream[v1.WatchResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.Watch is not implemented"))
+func (c *bMMServiceClient) Start(ctx context.Context, req *v1.StartRequest) (*v1.StartResponse, error) {
+	var res v1.StartResponse
+	if err := c.client.CallUnary(ctx, bMMServiceStartSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBMMServiceHandler) GetRoundBids(context.Context, *connect.Request[v1.GetRoundBidsRequest]) (*connect.Response[v1.GetRoundBidsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.GetRoundBids is not implemented"))
+func (c *bMMServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, bMMServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBMMServiceHandler) CreateBid(context.Context, *connect.Request[v1.CreateBidRequest]) (*connect.Response[v1.CreateBidResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.CreateBid is not implemented"))
+func (c *bMMServiceClient) ClearHistory(ctx context.Context, req *v1.ClearHistoryRequest) (*v1.ClearHistoryResponse, error) {
+	var res v1.ClearHistoryResponse
+	if err := c.client.CallUnary(ctx, bMMServiceClearHistorySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBMMServiceHandler) ConnectBid(context.Context, *connect.Request[v1.ConnectBidRequest]) (*connect.Response[v1.ConnectBidResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.ConnectBid is not implemented"))
+func (c *bMMServiceClient) Watch(ctx context.Context, req *v1.WatchRequest) (BMMServiceWatchClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, bMMServiceWatchSpec(), req)
+	if err != nil {
+		return BMMServiceWatchClientStream{}, err
+	}
+	return BMMServiceWatchClientStream{stream: stream}, nil
 }
 
-func (UnimplementedBMMServiceHandler) CancelBid(context.Context, *connect.Request[v1.CancelBidRequest]) (*connect.Response[v1.CancelBidResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.CancelBid is not implemented"))
+func (c *bMMServiceClient) GetRoundBids(ctx context.Context, req *v1.GetRoundBidsRequest) (*v1.GetRoundBidsResponse, error) {
+	var res v1.GetRoundBidsResponse
+	if err := c.client.CallUnary(ctx, bMMServiceGetRoundBidsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBMMServiceHandler) ListBids(context.Context, *connect.Request[v1.ListBidsRequest]) (*connect.Response[v1.ListBidsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.ListBids is not implemented"))
+func (c *bMMServiceClient) CreateBid(ctx context.Context, req *v1.CreateBidRequest) (*v1.CreateBidResponse, error) {
+	var res v1.CreateBidResponse
+	if err := c.client.CallUnary(ctx, bMMServiceCreateBidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBMMServiceHandler) PrepareBMM(context.Context, *connect.Request[v1.PrepareBMMRequest]) (*connect.Response[v1.PrepareBMMResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bmm.v1.BMMService.PrepareBMM is not implemented"))
+func (c *bMMServiceClient) ConnectBid(ctx context.Context, req *v1.ConnectBidRequest) (*v1.ConnectBidResponse, error) {
+	var res v1.ConnectBidResponse
+	if err := c.client.CallUnary(ctx, bMMServiceConnectBidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bMMServiceClient) CancelBid(ctx context.Context, req *v1.CancelBidRequest) (*v1.CancelBidResponse, error) {
+	var res v1.CancelBidResponse
+	if err := c.client.CallUnary(ctx, bMMServiceCancelBidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bMMServiceClient) ListBids(ctx context.Context, req *v1.ListBidsRequest) (*v1.ListBidsResponse, error) {
+	var res v1.ListBidsResponse
+	if err := c.client.CallUnary(ctx, bMMServiceListBidsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bMMServiceClient) PrepareBMM(ctx context.Context, req *v1.PrepareBMMRequest) (*v1.PrepareBMMResponse, error) {
+	var res v1.PrepareBMMResponse
+	if err := c.client.CallUnary(ctx, bMMServicePrepareBMMSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type bMMServiceHandler struct{ svc BMMServiceHandler }
+
+func (h bMMServiceHandler) start(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StartRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Start(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) clearHistory(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ClearHistoryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ClearHistory(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) watch(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WatchRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.Watch(ctx, &req, BMMServiceWatchServerStream{stream: stream})
+}
+
+func (h bMMServiceHandler) getRoundBids(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetRoundBidsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetRoundBids(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) createBid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateBidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateBid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) connectBid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectBidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectBid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) cancelBid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CancelBidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CancelBid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) listBids(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListBidsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListBids(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bMMServiceHandler) prepareBMM(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PrepareBMMRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PrepareBMM(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/coinshift/v1/coinshiftv1connect/coinshift.connect.go b/sidechain-orchestrator/gen/coinshift/v1/coinshiftv1connect/coinshift.connect.go
index 9df06ebc01..dd09d3a8a7 100644
--- a/sidechain-orchestrator/gen/coinshift/v1/coinshiftv1connect/coinshift.connect.go
+++ b/sidechain-orchestrator/gen/coinshift/v1/coinshiftv1connect/coinshift.connect.go
@@ -5,1098 +5,1268 @@
 package coinshiftv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/coinshift/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// CoinShiftServiceName is the fully-qualified name of the CoinShiftService service.
 	CoinShiftServiceName = "coinshift.v1.CoinShiftService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// CoinShiftServiceGetBalanceProcedure is the fully-qualified name of the CoinShiftService's
-	// GetBalance RPC.
+	// CoinShiftServiceGetBalanceProcedure is the procedure name of the CoinShiftService's GetBalance
+	// RPC.
 	CoinShiftServiceGetBalanceProcedure = "/coinshift.v1.CoinShiftService/GetBalance"
-	// CoinShiftServiceGetBlockCountProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGetBlockCountProcedure is the procedure name of the CoinShiftService's
 	// GetBlockCount RPC.
 	CoinShiftServiceGetBlockCountProcedure = "/coinshift.v1.CoinShiftService/GetBlockCount"
-	// CoinShiftServiceStopProcedure is the fully-qualified name of the CoinShiftService's Stop RPC.
+	// CoinShiftServiceStopProcedure is the procedure name of the CoinShiftService's Stop RPC.
 	CoinShiftServiceStopProcedure = "/coinshift.v1.CoinShiftService/Stop"
-	// CoinShiftServiceGetNewAddressProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGetNewAddressProcedure is the procedure name of the CoinShiftService's
 	// GetNewAddress RPC.
 	CoinShiftServiceGetNewAddressProcedure = "/coinshift.v1.CoinShiftService/GetNewAddress"
-	// CoinShiftServiceWithdrawProcedure is the fully-qualified name of the CoinShiftService's Withdraw
-	// RPC.
+	// CoinShiftServiceWithdrawProcedure is the procedure name of the CoinShiftService's Withdraw RPC.
 	CoinShiftServiceWithdrawProcedure = "/coinshift.v1.CoinShiftService/Withdraw"
-	// CoinShiftServiceTransferProcedure is the fully-qualified name of the CoinShiftService's Transfer
-	// RPC.
+	// CoinShiftServiceTransferProcedure is the procedure name of the CoinShiftService's Transfer RPC.
 	CoinShiftServiceTransferProcedure = "/coinshift.v1.CoinShiftService/Transfer"
-	// CoinShiftServiceGetSidechainWealthProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGetSidechainWealthProcedure is the procedure name of the CoinShiftService's
 	// GetSidechainWealth RPC.
 	CoinShiftServiceGetSidechainWealthProcedure = "/coinshift.v1.CoinShiftService/GetSidechainWealth"
-	// CoinShiftServiceCreateDepositProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceCreateDepositProcedure is the procedure name of the CoinShiftService's
 	// CreateDeposit RPC.
 	CoinShiftServiceCreateDepositProcedure = "/coinshift.v1.CoinShiftService/CreateDeposit"
-	// CoinShiftServiceGetPendingWithdrawalBundleProcedure is the fully-qualified name of the
+	// CoinShiftServiceGetPendingWithdrawalBundleProcedure is the procedure name of the
 	// CoinShiftService's GetPendingWithdrawalBundle RPC.
 	CoinShiftServiceGetPendingWithdrawalBundleProcedure = "/coinshift.v1.CoinShiftService/GetPendingWithdrawalBundle"
-	// CoinShiftServiceConnectPeerProcedure is the fully-qualified name of the CoinShiftService's
-	// ConnectPeer RPC.
+	// CoinShiftServiceConnectPeerProcedure is the procedure name of the CoinShiftService's ConnectPeer
+	// RPC.
 	CoinShiftServiceConnectPeerProcedure = "/coinshift.v1.CoinShiftService/ConnectPeer"
-	// CoinShiftServiceForgetPeerProcedure is the fully-qualified name of the CoinShiftService's
-	// ForgetPeer RPC.
+	// CoinShiftServiceForgetPeerProcedure is the procedure name of the CoinShiftService's ForgetPeer
+	// RPC.
 	CoinShiftServiceForgetPeerProcedure = "/coinshift.v1.CoinShiftService/ForgetPeer"
-	// CoinShiftServiceListPeersProcedure is the fully-qualified name of the CoinShiftService's
-	// ListPeers RPC.
+	// CoinShiftServiceListPeersProcedure is the procedure name of the CoinShiftService's ListPeers RPC.
 	CoinShiftServiceListPeersProcedure = "/coinshift.v1.CoinShiftService/ListPeers"
-	// CoinShiftServiceMineProcedure is the fully-qualified name of the CoinShiftService's Mine RPC.
+	// CoinShiftServiceMineProcedure is the procedure name of the CoinShiftService's Mine RPC.
 	CoinShiftServiceMineProcedure = "/coinshift.v1.CoinShiftService/Mine"
-	// CoinShiftServiceGetBlockProcedure is the fully-qualified name of the CoinShiftService's GetBlock
-	// RPC.
+	// CoinShiftServiceGetBlockProcedure is the procedure name of the CoinShiftService's GetBlock RPC.
 	CoinShiftServiceGetBlockProcedure = "/coinshift.v1.CoinShiftService/GetBlock"
-	// CoinShiftServiceGetBestMainchainBlockHashProcedure is the fully-qualified name of the
+	// CoinShiftServiceGetBestMainchainBlockHashProcedure is the procedure name of the
 	// CoinShiftService's GetBestMainchainBlockHash RPC.
 	CoinShiftServiceGetBestMainchainBlockHashProcedure = "/coinshift.v1.CoinShiftService/GetBestMainchainBlockHash"
-	// CoinShiftServiceGetBestSidechainBlockHashProcedure is the fully-qualified name of the
+	// CoinShiftServiceGetBestSidechainBlockHashProcedure is the procedure name of the
 	// CoinShiftService's GetBestSidechainBlockHash RPC.
 	CoinShiftServiceGetBestSidechainBlockHashProcedure = "/coinshift.v1.CoinShiftService/GetBestSidechainBlockHash"
-	// CoinShiftServiceGetBmmInclusionsProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGetBmmInclusionsProcedure is the procedure name of the CoinShiftService's
 	// GetBmmInclusions RPC.
 	CoinShiftServiceGetBmmInclusionsProcedure = "/coinshift.v1.CoinShiftService/GetBmmInclusions"
-	// CoinShiftServiceGetWalletUtxosProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGetWalletUtxosProcedure is the procedure name of the CoinShiftService's
 	// GetWalletUtxos RPC.
 	CoinShiftServiceGetWalletUtxosProcedure = "/coinshift.v1.CoinShiftService/GetWalletUtxos"
-	// CoinShiftServiceListUtxosProcedure is the fully-qualified name of the CoinShiftService's
-	// ListUtxos RPC.
+	// CoinShiftServiceListUtxosProcedure is the procedure name of the CoinShiftService's ListUtxos RPC.
 	CoinShiftServiceListUtxosProcedure = "/coinshift.v1.CoinShiftService/ListUtxos"
-	// CoinShiftServiceRemoveFromMempoolProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceRemoveFromMempoolProcedure is the procedure name of the CoinShiftService's
 	// RemoveFromMempool RPC.
 	CoinShiftServiceRemoveFromMempoolProcedure = "/coinshift.v1.CoinShiftService/RemoveFromMempool"
-	// CoinShiftServiceGetLatestFailedWithdrawalBundleHeightProcedure is the fully-qualified name of the
+	// CoinShiftServiceGetLatestFailedWithdrawalBundleHeightProcedure is the procedure name of the
 	// CoinShiftService's GetLatestFailedWithdrawalBundleHeight RPC.
 	CoinShiftServiceGetLatestFailedWithdrawalBundleHeightProcedure = "/coinshift.v1.CoinShiftService/GetLatestFailedWithdrawalBundleHeight"
-	// CoinShiftServiceGenerateMnemonicProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGenerateMnemonicProcedure is the procedure name of the CoinShiftService's
 	// GenerateMnemonic RPC.
 	CoinShiftServiceGenerateMnemonicProcedure = "/coinshift.v1.CoinShiftService/GenerateMnemonic"
-	// CoinShiftServiceSetSeedFromMnemonicProcedure is the fully-qualified name of the
-	// CoinShiftService's SetSeedFromMnemonic RPC.
+	// CoinShiftServiceSetSeedFromMnemonicProcedure is the procedure name of the CoinShiftService's
+	// SetSeedFromMnemonic RPC.
 	CoinShiftServiceSetSeedFromMnemonicProcedure = "/coinshift.v1.CoinShiftService/SetSeedFromMnemonic"
-	// CoinShiftServiceCallRawProcedure is the fully-qualified name of the CoinShiftService's CallRaw
-	// RPC.
+	// CoinShiftServiceCallRawProcedure is the procedure name of the CoinShiftService's CallRaw RPC.
 	CoinShiftServiceCallRawProcedure = "/coinshift.v1.CoinShiftService/CallRaw"
-	// CoinShiftServiceGetWalletAddressesProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGetWalletAddressesProcedure is the procedure name of the CoinShiftService's
 	// GetWalletAddresses RPC.
 	CoinShiftServiceGetWalletAddressesProcedure = "/coinshift.v1.CoinShiftService/GetWalletAddresses"
-	// CoinShiftServiceOpenapiSchemaProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceOpenapiSchemaProcedure is the procedure name of the CoinShiftService's
 	// OpenapiSchema RPC.
 	CoinShiftServiceOpenapiSchemaProcedure = "/coinshift.v1.CoinShiftService/OpenapiSchema"
-	// CoinShiftServiceCreateSwapProcedure is the fully-qualified name of the CoinShiftService's
-	// CreateSwap RPC.
+	// CoinShiftServiceCreateSwapProcedure is the procedure name of the CoinShiftService's CreateSwap
+	// RPC.
 	CoinShiftServiceCreateSwapProcedure = "/coinshift.v1.CoinShiftService/CreateSwap"
-	// CoinShiftServiceClaimSwapProcedure is the fully-qualified name of the CoinShiftService's
-	// ClaimSwap RPC.
+	// CoinShiftServiceClaimSwapProcedure is the procedure name of the CoinShiftService's ClaimSwap RPC.
 	CoinShiftServiceClaimSwapProcedure = "/coinshift.v1.CoinShiftService/ClaimSwap"
-	// CoinShiftServiceGetSwapStatusProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceGetSwapStatusProcedure is the procedure name of the CoinShiftService's
 	// GetSwapStatus RPC.
 	CoinShiftServiceGetSwapStatusProcedure = "/coinshift.v1.CoinShiftService/GetSwapStatus"
-	// CoinShiftServiceListSwapsProcedure is the fully-qualified name of the CoinShiftService's
-	// ListSwaps RPC.
+	// CoinShiftServiceListSwapsProcedure is the procedure name of the CoinShiftService's ListSwaps RPC.
 	CoinShiftServiceListSwapsProcedure = "/coinshift.v1.CoinShiftService/ListSwaps"
-	// CoinShiftServiceListSwapsByRecipientProcedure is the fully-qualified name of the
-	// CoinShiftService's ListSwapsByRecipient RPC.
+	// CoinShiftServiceListSwapsByRecipientProcedure is the procedure name of the CoinShiftService's
+	// ListSwapsByRecipient RPC.
 	CoinShiftServiceListSwapsByRecipientProcedure = "/coinshift.v1.CoinShiftService/ListSwapsByRecipient"
-	// CoinShiftServiceUpdateSwapL1TxidProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceUpdateSwapL1TxidProcedure is the procedure name of the CoinShiftService's
 	// UpdateSwapL1Txid RPC.
 	CoinShiftServiceUpdateSwapL1TxidProcedure = "/coinshift.v1.CoinShiftService/UpdateSwapL1Txid"
-	// CoinShiftServiceReconstructSwapsProcedure is the fully-qualified name of the CoinShiftService's
+	// CoinShiftServiceReconstructSwapsProcedure is the procedure name of the CoinShiftService's
 	// ReconstructSwaps RPC.
 	CoinShiftServiceReconstructSwapsProcedure = "/coinshift.v1.CoinShiftService/ReconstructSwaps"
 )
 
+var (
+	coinShiftServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetBalance"),
+			Procedure:  CoinShiftServiceGetBalanceProcedure,
+		}
+	})
+	coinShiftServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetBlockCount"),
+			Procedure:  CoinShiftServiceGetBlockCountProcedure,
+		}
+	})
+	coinShiftServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("Stop"),
+			Procedure:  CoinShiftServiceStopProcedure,
+		}
+	})
+	coinShiftServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetNewAddress"),
+			Procedure:  CoinShiftServiceGetNewAddressProcedure,
+		}
+	})
+	coinShiftServiceWithdrawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("Withdraw"),
+			Procedure:  CoinShiftServiceWithdrawProcedure,
+		}
+	})
+	coinShiftServiceTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("Transfer"),
+			Procedure:  CoinShiftServiceTransferProcedure,
+		}
+	})
+	coinShiftServiceGetSidechainWealthSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetSidechainWealth"),
+			Procedure:  CoinShiftServiceGetSidechainWealthProcedure,
+		}
+	})
+	coinShiftServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("CreateDeposit"),
+			Procedure:  CoinShiftServiceCreateDepositProcedure,
+		}
+	})
+	coinShiftServiceGetPendingWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetPendingWithdrawalBundle"),
+			Procedure:  CoinShiftServiceGetPendingWithdrawalBundleProcedure,
+		}
+	})
+	coinShiftServiceConnectPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ConnectPeer"),
+			Procedure:  CoinShiftServiceConnectPeerProcedure,
+		}
+	})
+	coinShiftServiceForgetPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ForgetPeer"),
+			Procedure:  CoinShiftServiceForgetPeerProcedure,
+		}
+	})
+	coinShiftServiceListPeersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ListPeers"),
+			Procedure:  CoinShiftServiceListPeersProcedure,
+		}
+	})
+	coinShiftServiceMineSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("Mine"),
+			Procedure:  CoinShiftServiceMineProcedure,
+		}
+	})
+	coinShiftServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetBlock"),
+			Procedure:  CoinShiftServiceGetBlockProcedure,
+		}
+	})
+	coinShiftServiceGetBestMainchainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetBestMainchainBlockHash"),
+			Procedure:  CoinShiftServiceGetBestMainchainBlockHashProcedure,
+		}
+	})
+	coinShiftServiceGetBestSidechainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetBestSidechainBlockHash"),
+			Procedure:  CoinShiftServiceGetBestSidechainBlockHashProcedure,
+		}
+	})
+	coinShiftServiceGetBmmInclusionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetBmmInclusions"),
+			Procedure:  CoinShiftServiceGetBmmInclusionsProcedure,
+		}
+	})
+	coinShiftServiceGetWalletUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetWalletUtxos"),
+			Procedure:  CoinShiftServiceGetWalletUtxosProcedure,
+		}
+	})
+	coinShiftServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ListUtxos"),
+			Procedure:  CoinShiftServiceListUtxosProcedure,
+		}
+	})
+	coinShiftServiceRemoveFromMempoolSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("RemoveFromMempool"),
+			Procedure:  CoinShiftServiceRemoveFromMempoolProcedure,
+		}
+	})
+	coinShiftServiceGetLatestFailedWithdrawalBundleHeightSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetLatestFailedWithdrawalBundleHeight"),
+			Procedure:  CoinShiftServiceGetLatestFailedWithdrawalBundleHeightProcedure,
+		}
+	})
+	coinShiftServiceGenerateMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GenerateMnemonic"),
+			Procedure:  CoinShiftServiceGenerateMnemonicProcedure,
+		}
+	})
+	coinShiftServiceSetSeedFromMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("SetSeedFromMnemonic"),
+			Procedure:  CoinShiftServiceSetSeedFromMnemonicProcedure,
+		}
+	})
+	coinShiftServiceCallRawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("CallRaw"),
+			Procedure:  CoinShiftServiceCallRawProcedure,
+		}
+	})
+	coinShiftServiceGetWalletAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetWalletAddresses"),
+			Procedure:  CoinShiftServiceGetWalletAddressesProcedure,
+		}
+	})
+	coinShiftServiceOpenapiSchemaSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("OpenapiSchema"),
+			Procedure:  CoinShiftServiceOpenapiSchemaProcedure,
+		}
+	})
+	coinShiftServiceCreateSwapSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("CreateSwap"),
+			Procedure:  CoinShiftServiceCreateSwapProcedure,
+		}
+	})
+	coinShiftServiceClaimSwapSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ClaimSwap"),
+			Procedure:  CoinShiftServiceClaimSwapProcedure,
+		}
+	})
+	coinShiftServiceGetSwapStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("GetSwapStatus"),
+			Procedure:  CoinShiftServiceGetSwapStatusProcedure,
+		}
+	})
+	coinShiftServiceListSwapsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ListSwaps"),
+			Procedure:  CoinShiftServiceListSwapsProcedure,
+		}
+	})
+	coinShiftServiceListSwapsByRecipientSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ListSwapsByRecipient"),
+			Procedure:  CoinShiftServiceListSwapsByRecipientProcedure,
+		}
+	})
+	coinShiftServiceUpdateSwapL1TxidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("UpdateSwapL1Txid"),
+			Procedure:  CoinShiftServiceUpdateSwapL1TxidProcedure,
+		}
+	})
+	coinShiftServiceReconstructSwapsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods().ByName("ReconstructSwaps"),
+			Procedure:  CoinShiftServiceReconstructSwapsProcedure,
+		}
+	})
+)
+
 // CoinShiftServiceClient is a client for the coinshift.v1.CoinShiftService service.
 type CoinShiftServiceClient interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the coinshift node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// Forget a peer.
-	ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// Get OpenAPI schema.
-	OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error)
-	// Create a swap (L2 to L1).
-	CreateSwap(context.Context, *connect.Request[v1.CreateSwapRequest]) (*connect.Response[v1.CreateSwapResponse], error)
-	// Claim a swap.
-	ClaimSwap(context.Context, *connect.Request[v1.ClaimSwapRequest]) (*connect.Response[v1.ClaimSwapResponse], error)
-	// Get swap status.
-	GetSwapStatus(context.Context, *connect.Request[v1.GetSwapStatusRequest]) (*connect.Response[v1.GetSwapStatusResponse], error)
-	// List all swaps.
-	ListSwaps(context.Context, *connect.Request[v1.ListSwapsRequest]) (*connect.Response[v1.ListSwapsResponse], error)
-	// List swaps for a specific recipient.
-	ListSwapsByRecipient(context.Context, *connect.Request[v1.ListSwapsByRecipientRequest]) (*connect.Response[v1.ListSwapsByRecipientResponse], error)
-	// Update swap L1 transaction ID.
-	UpdateSwapL1Txid(context.Context, *connect.Request[v1.UpdateSwapL1TxidRequest]) (*connect.Response[v1.UpdateSwapL1TxidResponse], error)
-	// Reconstruct all swaps from blockchain.
-	ReconstructSwaps(context.Context, *connect.Request[v1.ReconstructSwapsRequest]) (*connect.Response[v1.ReconstructSwapsResponse], error)
-}
-
-// NewCoinShiftServiceClient constructs a client for the coinshift.v1.CoinShiftService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewCoinShiftServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) CoinShiftServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	coinShiftServiceMethods := v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods()
-	return &coinShiftServiceClient{
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetBalanceProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetBlockCountProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+CoinShiftServiceStopProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetNewAddressProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		withdraw: connect.NewClient[v1.WithdrawRequest, v1.WithdrawResponse](
-			httpClient,
-			baseURL+CoinShiftServiceWithdrawProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("Withdraw")),
-			connect.WithClientOptions(opts...),
-		),
-		transfer: connect.NewClient[v1.TransferRequest, v1.TransferResponse](
-			httpClient,
-			baseURL+CoinShiftServiceTransferProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("Transfer")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainWealth: connect.NewClient[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetSidechainWealthProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetSidechainWealth")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+CoinShiftServiceCreateDepositProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingWithdrawalBundle: connect.NewClient[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetPendingWithdrawalBundleProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetPendingWithdrawalBundle")),
-			connect.WithClientOptions(opts...),
-		),
-		connectPeer: connect.NewClient[v1.ConnectPeerRequest, v1.ConnectPeerResponse](
-			httpClient,
-			baseURL+CoinShiftServiceConnectPeerProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ConnectPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		forgetPeer: connect.NewClient[v1.ForgetPeerRequest, v1.ForgetPeerResponse](
-			httpClient,
-			baseURL+CoinShiftServiceForgetPeerProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ForgetPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		listPeers: connect.NewClient[v1.ListPeersRequest, v1.ListPeersResponse](
-			httpClient,
-			baseURL+CoinShiftServiceListPeersProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ListPeers")),
-			connect.WithClientOptions(opts...),
-		),
-		mine: connect.NewClient[v1.MineRequest, v1.MineResponse](
-			httpClient,
-			baseURL+CoinShiftServiceMineProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("Mine")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetBlockProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestMainchainBlockHash: connect.NewClient[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetBestMainchainBlockHashProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetBestMainchainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestSidechainBlockHash: connect.NewClient[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetBestSidechainBlockHashProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetBestSidechainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmInclusions: connect.NewClient[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetBmmInclusionsProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetBmmInclusions")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletUtxos: connect.NewClient[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetWalletUtxosProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetWalletUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+CoinShiftServiceListUtxosProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		removeFromMempool: connect.NewClient[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse](
-			httpClient,
-			baseURL+CoinShiftServiceRemoveFromMempoolProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("RemoveFromMempool")),
-			connect.WithClientOptions(opts...),
-		),
-		getLatestFailedWithdrawalBundleHeight: connect.NewClient[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-			connect.WithClientOptions(opts...),
-		),
-		generateMnemonic: connect.NewClient[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGenerateMnemonicProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GenerateMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		setSeedFromMnemonic: connect.NewClient[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse](
-			httpClient,
-			baseURL+CoinShiftServiceSetSeedFromMnemonicProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("SetSeedFromMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		callRaw: connect.NewClient[v1.CallRawRequest, v1.CallRawResponse](
-			httpClient,
-			baseURL+CoinShiftServiceCallRawProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("CallRaw")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletAddresses: connect.NewClient[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetWalletAddressesProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetWalletAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		openapiSchema: connect.NewClient[v1.OpenapiSchemaRequest, v1.OpenapiSchemaResponse](
-			httpClient,
-			baseURL+CoinShiftServiceOpenapiSchemaProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("OpenapiSchema")),
-			connect.WithClientOptions(opts...),
-		),
-		createSwap: connect.NewClient[v1.CreateSwapRequest, v1.CreateSwapResponse](
-			httpClient,
-			baseURL+CoinShiftServiceCreateSwapProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("CreateSwap")),
-			connect.WithClientOptions(opts...),
-		),
-		claimSwap: connect.NewClient[v1.ClaimSwapRequest, v1.ClaimSwapResponse](
-			httpClient,
-			baseURL+CoinShiftServiceClaimSwapProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ClaimSwap")),
-			connect.WithClientOptions(opts...),
-		),
-		getSwapStatus: connect.NewClient[v1.GetSwapStatusRequest, v1.GetSwapStatusResponse](
-			httpClient,
-			baseURL+CoinShiftServiceGetSwapStatusProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("GetSwapStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		listSwaps: connect.NewClient[v1.ListSwapsRequest, v1.ListSwapsResponse](
-			httpClient,
-			baseURL+CoinShiftServiceListSwapsProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ListSwaps")),
-			connect.WithClientOptions(opts...),
-		),
-		listSwapsByRecipient: connect.NewClient[v1.ListSwapsByRecipientRequest, v1.ListSwapsByRecipientResponse](
-			httpClient,
-			baseURL+CoinShiftServiceListSwapsByRecipientProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ListSwapsByRecipient")),
-			connect.WithClientOptions(opts...),
-		),
-		updateSwapL1Txid: connect.NewClient[v1.UpdateSwapL1TxidRequest, v1.UpdateSwapL1TxidResponse](
-			httpClient,
-			baseURL+CoinShiftServiceUpdateSwapL1TxidProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("UpdateSwapL1Txid")),
-			connect.WithClientOptions(opts...),
-		),
-		reconstructSwaps: connect.NewClient[v1.ReconstructSwapsRequest, v1.ReconstructSwapsResponse](
-			httpClient,
-			baseURL+CoinShiftServiceReconstructSwapsProcedure,
-			connect.WithSchema(coinShiftServiceMethods.ByName("ReconstructSwaps")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// coinShiftServiceClient implements CoinShiftServiceClient.
-type coinShiftServiceClient struct {
-	getBalance                            *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getBlockCount                         *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	stop                                  *connect.Client[v1.StopRequest, v1.StopResponse]
-	getNewAddress                         *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	withdraw                              *connect.Client[v1.WithdrawRequest, v1.WithdrawResponse]
-	transfer                              *connect.Client[v1.TransferRequest, v1.TransferResponse]
-	getSidechainWealth                    *connect.Client[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse]
-	createDeposit                         *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	getPendingWithdrawalBundle            *connect.Client[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse]
-	connectPeer                           *connect.Client[v1.ConnectPeerRequest, v1.ConnectPeerResponse]
-	forgetPeer                            *connect.Client[v1.ForgetPeerRequest, v1.ForgetPeerResponse]
-	listPeers                             *connect.Client[v1.ListPeersRequest, v1.ListPeersResponse]
-	mine                                  *connect.Client[v1.MineRequest, v1.MineResponse]
-	getBlock                              *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	getBestMainchainBlockHash             *connect.Client[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse]
-	getBestSidechainBlockHash             *connect.Client[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse]
-	getBmmInclusions                      *connect.Client[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse]
-	getWalletUtxos                        *connect.Client[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse]
-	listUtxos                             *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	removeFromMempool                     *connect.Client[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse]
-	getLatestFailedWithdrawalBundleHeight *connect.Client[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse]
-	generateMnemonic                      *connect.Client[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse]
-	setSeedFromMnemonic                   *connect.Client[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse]
-	callRaw                               *connect.Client[v1.CallRawRequest, v1.CallRawResponse]
-	getWalletAddresses                    *connect.Client[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse]
-	openapiSchema                         *connect.Client[v1.OpenapiSchemaRequest, v1.OpenapiSchemaResponse]
-	createSwap                            *connect.Client[v1.CreateSwapRequest, v1.CreateSwapResponse]
-	claimSwap                             *connect.Client[v1.ClaimSwapRequest, v1.ClaimSwapResponse]
-	getSwapStatus                         *connect.Client[v1.GetSwapStatusRequest, v1.GetSwapStatusResponse]
-	listSwaps                             *connect.Client[v1.ListSwapsRequest, v1.ListSwapsResponse]
-	listSwapsByRecipient                  *connect.Client[v1.ListSwapsByRecipientRequest, v1.ListSwapsByRecipientResponse]
-	updateSwapL1Txid                      *connect.Client[v1.UpdateSwapL1TxidRequest, v1.UpdateSwapL1TxidResponse]
-	reconstructSwaps                      *connect.Client[v1.ReconstructSwapsRequest, v1.ReconstructSwapsResponse]
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error)
+	CreateSwap(context.Context, *v1.CreateSwapRequest) (*v1.CreateSwapResponse, error)
+	ClaimSwap(context.Context, *v1.ClaimSwapRequest) (*v1.ClaimSwapResponse, error)
+	GetSwapStatus(context.Context, *v1.GetSwapStatusRequest) (*v1.GetSwapStatusResponse, error)
+	ListSwaps(context.Context, *v1.ListSwapsRequest) (*v1.ListSwapsResponse, error)
+	ListSwapsByRecipient(context.Context, *v1.ListSwapsByRecipientRequest) (*v1.ListSwapsByRecipientResponse, error)
+	UpdateSwapL1Txid(context.Context, *v1.UpdateSwapL1TxidRequest) (*v1.UpdateSwapL1TxidResponse, error)
+	ReconstructSwaps(context.Context, *v1.ReconstructSwapsRequest) (*v1.ReconstructSwapsResponse, error)
+}
+
+// NewCoinShiftServiceClient constructs a client for the coinshift.v1.CoinShiftService service.
+// Multiple service clients may share a single connect.Client.
+func NewCoinShiftServiceClient(client *connect.Client) CoinShiftServiceClient {
+	return &coinShiftServiceClient{client: client}
 }
 
-// GetBalance calls coinshift.v1.CoinShiftService.GetBalance.
-func (c *coinShiftServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// CoinShiftServiceHandler is an implementation of the coinshift.v1.CoinShiftService service.
+type CoinShiftServiceHandler interface {
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error)
+	CreateSwap(context.Context, *v1.CreateSwapRequest) (*v1.CreateSwapResponse, error)
+	ClaimSwap(context.Context, *v1.ClaimSwapRequest) (*v1.ClaimSwapResponse, error)
+	GetSwapStatus(context.Context, *v1.GetSwapStatusRequest) (*v1.GetSwapStatusResponse, error)
+	ListSwaps(context.Context, *v1.ListSwapsRequest) (*v1.ListSwapsResponse, error)
+	ListSwapsByRecipient(context.Context, *v1.ListSwapsByRecipientRequest) (*v1.ListSwapsByRecipientResponse, error)
+	UpdateSwapL1Txid(context.Context, *v1.UpdateSwapL1TxidRequest) (*v1.UpdateSwapL1TxidResponse, error)
+	ReconstructSwaps(context.Context, *v1.ReconstructSwapsRequest) (*v1.ReconstructSwapsResponse, error)
+}
+
+// RegisterCoinShiftServiceHandler registers svc as the coinshift.v1.CoinShiftService implementation
+// on server.
+func RegisterCoinShiftServiceHandler(server *connect.Server, svc CoinShiftServiceHandler) {
+	adapter := coinShiftServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: coinShiftServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: coinShiftServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: coinShiftServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: coinShiftServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: coinShiftServiceWithdrawSpec(), Handler: adapter.withdraw},
+		connect.Method{Spec: coinShiftServiceTransferSpec(), Handler: adapter.transfer},
+		connect.Method{Spec: coinShiftServiceGetSidechainWealthSpec(), Handler: adapter.getSidechainWealth},
+		connect.Method{Spec: coinShiftServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: coinShiftServiceGetPendingWithdrawalBundleSpec(), Handler: adapter.getPendingWithdrawalBundle},
+		connect.Method{Spec: coinShiftServiceConnectPeerSpec(), Handler: adapter.connectPeer},
+		connect.Method{Spec: coinShiftServiceForgetPeerSpec(), Handler: adapter.forgetPeer},
+		connect.Method{Spec: coinShiftServiceListPeersSpec(), Handler: adapter.listPeers},
+		connect.Method{Spec: coinShiftServiceMineSpec(), Handler: adapter.mine},
+		connect.Method{Spec: coinShiftServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: coinShiftServiceGetBestMainchainBlockHashSpec(), Handler: adapter.getBestMainchainBlockHash},
+		connect.Method{Spec: coinShiftServiceGetBestSidechainBlockHashSpec(), Handler: adapter.getBestSidechainBlockHash},
+		connect.Method{Spec: coinShiftServiceGetBmmInclusionsSpec(), Handler: adapter.getBmmInclusions},
+		connect.Method{Spec: coinShiftServiceGetWalletUtxosSpec(), Handler: adapter.getWalletUtxos},
+		connect.Method{Spec: coinShiftServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: coinShiftServiceRemoveFromMempoolSpec(), Handler: adapter.removeFromMempool},
+		connect.Method{Spec: coinShiftServiceGetLatestFailedWithdrawalBundleHeightSpec(), Handler: adapter.getLatestFailedWithdrawalBundleHeight},
+		connect.Method{Spec: coinShiftServiceGenerateMnemonicSpec(), Handler: adapter.generateMnemonic},
+		connect.Method{Spec: coinShiftServiceSetSeedFromMnemonicSpec(), Handler: adapter.setSeedFromMnemonic},
+		connect.Method{Spec: coinShiftServiceCallRawSpec(), Handler: adapter.callRaw},
+		connect.Method{Spec: coinShiftServiceGetWalletAddressesSpec(), Handler: adapter.getWalletAddresses},
+		connect.Method{Spec: coinShiftServiceOpenapiSchemaSpec(), Handler: adapter.openapiSchema},
+		connect.Method{Spec: coinShiftServiceCreateSwapSpec(), Handler: adapter.createSwap},
+		connect.Method{Spec: coinShiftServiceClaimSwapSpec(), Handler: adapter.claimSwap},
+		connect.Method{Spec: coinShiftServiceGetSwapStatusSpec(), Handler: adapter.getSwapStatus},
+		connect.Method{Spec: coinShiftServiceListSwapsSpec(), Handler: adapter.listSwaps},
+		connect.Method{Spec: coinShiftServiceListSwapsByRecipientSpec(), Handler: adapter.listSwapsByRecipient},
+		connect.Method{Spec: coinShiftServiceUpdateSwapL1TxidSpec(), Handler: adapter.updateSwapL1Txid},
+		connect.Method{Spec: coinShiftServiceReconstructSwapsSpec(), Handler: adapter.reconstructSwaps},
+	)
 }
 
-// GetBlockCount calls coinshift.v1.CoinShiftService.GetBlockCount.
-func (c *coinShiftServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// UnimplementedCoinShiftServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedCoinShiftServiceHandler struct{}
+
+func (UnimplementedCoinShiftServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetBalance is not implemented")
 }
 
-// Stop calls coinshift.v1.CoinShiftService.Stop.
-func (c *coinShiftServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetBlockCount is not implemented")
 }
 
-// GetNewAddress calls coinshift.v1.CoinShiftService.GetNewAddress.
-func (c *coinShiftServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.Stop is not implemented")
 }
 
-// Withdraw calls coinshift.v1.CoinShiftService.Withdraw.
-func (c *coinShiftServiceClient) Withdraw(ctx context.Context, req *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return c.withdraw.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetNewAddress is not implemented")
 }
 
-// Transfer calls coinshift.v1.CoinShiftService.Transfer.
-func (c *coinShiftServiceClient) Transfer(ctx context.Context, req *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return c.transfer.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.Withdraw is not implemented")
 }
 
-// GetSidechainWealth calls coinshift.v1.CoinShiftService.GetSidechainWealth.
-func (c *coinShiftServiceClient) GetSidechainWealth(ctx context.Context, req *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return c.getSidechainWealth.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.Transfer is not implemented")
 }
 
-// CreateDeposit calls coinshift.v1.CoinShiftService.CreateDeposit.
-func (c *coinShiftServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetSidechainWealth is not implemented")
 }
 
-// GetPendingWithdrawalBundle calls coinshift.v1.CoinShiftService.GetPendingWithdrawalBundle.
-func (c *coinShiftServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return c.getPendingWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.CreateDeposit is not implemented")
 }
 
-// ConnectPeer calls coinshift.v1.CoinShiftService.ConnectPeer.
-func (c *coinShiftServiceClient) ConnectPeer(ctx context.Context, req *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return c.connectPeer.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetPendingWithdrawalBundle is not implemented")
 }
 
-// ForgetPeer calls coinshift.v1.CoinShiftService.ForgetPeer.
-func (c *coinShiftServiceClient) ForgetPeer(ctx context.Context, req *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error) {
-	return c.forgetPeer.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ConnectPeer is not implemented")
 }
 
-// ListPeers calls coinshift.v1.CoinShiftService.ListPeers.
-func (c *coinShiftServiceClient) ListPeers(ctx context.Context, req *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return c.listPeers.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ForgetPeer is not implemented")
 }
 
-// Mine calls coinshift.v1.CoinShiftService.Mine.
-func (c *coinShiftServiceClient) Mine(ctx context.Context, req *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return c.mine.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ListPeers is not implemented")
 }
 
-// GetBlock calls coinshift.v1.CoinShiftService.GetBlock.
-func (c *coinShiftServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.Mine is not implemented")
 }
 
-// GetBestMainchainBlockHash calls coinshift.v1.CoinShiftService.GetBestMainchainBlockHash.
-func (c *coinShiftServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return c.getBestMainchainBlockHash.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetBlock is not implemented")
 }
 
-// GetBestSidechainBlockHash calls coinshift.v1.CoinShiftService.GetBestSidechainBlockHash.
-func (c *coinShiftServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return c.getBestSidechainBlockHash.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetBestMainchainBlockHash is not implemented")
 }
 
-// GetBmmInclusions calls coinshift.v1.CoinShiftService.GetBmmInclusions.
-func (c *coinShiftServiceClient) GetBmmInclusions(ctx context.Context, req *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return c.getBmmInclusions.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetBestSidechainBlockHash is not implemented")
 }
 
-// GetWalletUtxos calls coinshift.v1.CoinShiftService.GetWalletUtxos.
-func (c *coinShiftServiceClient) GetWalletUtxos(ctx context.Context, req *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return c.getWalletUtxos.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetBmmInclusions is not implemented")
 }
 
-// ListUtxos calls coinshift.v1.CoinShiftService.ListUtxos.
-func (c *coinShiftServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetWalletUtxos is not implemented")
 }
 
-// RemoveFromMempool calls coinshift.v1.CoinShiftService.RemoveFromMempool.
-func (c *coinShiftServiceClient) RemoveFromMempool(ctx context.Context, req *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return c.removeFromMempool.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ListUtxos is not implemented")
 }
 
-// GetLatestFailedWithdrawalBundleHeight calls
-// coinshift.v1.CoinShiftService.GetLatestFailedWithdrawalBundleHeight.
-func (c *coinShiftServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return c.getLatestFailedWithdrawalBundleHeight.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.RemoveFromMempool is not implemented")
 }
 
-// GenerateMnemonic calls coinshift.v1.CoinShiftService.GenerateMnemonic.
-func (c *coinShiftServiceClient) GenerateMnemonic(ctx context.Context, req *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return c.generateMnemonic.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetLatestFailedWithdrawalBundleHeight is not implemented")
 }
 
-// SetSeedFromMnemonic calls coinshift.v1.CoinShiftService.SetSeedFromMnemonic.
-func (c *coinShiftServiceClient) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return c.setSeedFromMnemonic.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GenerateMnemonic is not implemented")
 }
 
-// CallRaw calls coinshift.v1.CoinShiftService.CallRaw.
-func (c *coinShiftServiceClient) CallRaw(ctx context.Context, req *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return c.callRaw.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.SetSeedFromMnemonic is not implemented")
 }
 
-// GetWalletAddresses calls coinshift.v1.CoinShiftService.GetWalletAddresses.
-func (c *coinShiftServiceClient) GetWalletAddresses(ctx context.Context, req *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return c.getWalletAddresses.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.CallRaw is not implemented")
 }
 
-// OpenapiSchema calls coinshift.v1.CoinShiftService.OpenapiSchema.
-func (c *coinShiftServiceClient) OpenapiSchema(ctx context.Context, req *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error) {
-	return c.openapiSchema.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetWalletAddresses is not implemented")
 }
 
-// CreateSwap calls coinshift.v1.CoinShiftService.CreateSwap.
-func (c *coinShiftServiceClient) CreateSwap(ctx context.Context, req *connect.Request[v1.CreateSwapRequest]) (*connect.Response[v1.CreateSwapResponse], error) {
-	return c.createSwap.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) OpenapiSchema(context.Context, *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.OpenapiSchema is not implemented")
 }
 
-// ClaimSwap calls coinshift.v1.CoinShiftService.ClaimSwap.
-func (c *coinShiftServiceClient) ClaimSwap(ctx context.Context, req *connect.Request[v1.ClaimSwapRequest]) (*connect.Response[v1.ClaimSwapResponse], error) {
-	return c.claimSwap.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) CreateSwap(context.Context, *v1.CreateSwapRequest) (*v1.CreateSwapResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.CreateSwap is not implemented")
 }
 
-// GetSwapStatus calls coinshift.v1.CoinShiftService.GetSwapStatus.
-func (c *coinShiftServiceClient) GetSwapStatus(ctx context.Context, req *connect.Request[v1.GetSwapStatusRequest]) (*connect.Response[v1.GetSwapStatusResponse], error) {
-	return c.getSwapStatus.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) ClaimSwap(context.Context, *v1.ClaimSwapRequest) (*v1.ClaimSwapResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ClaimSwap is not implemented")
 }
 
-// ListSwaps calls coinshift.v1.CoinShiftService.ListSwaps.
-func (c *coinShiftServiceClient) ListSwaps(ctx context.Context, req *connect.Request[v1.ListSwapsRequest]) (*connect.Response[v1.ListSwapsResponse], error) {
-	return c.listSwaps.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) GetSwapStatus(context.Context, *v1.GetSwapStatusRequest) (*v1.GetSwapStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.GetSwapStatus is not implemented")
 }
 
-// ListSwapsByRecipient calls coinshift.v1.CoinShiftService.ListSwapsByRecipient.
-func (c *coinShiftServiceClient) ListSwapsByRecipient(ctx context.Context, req *connect.Request[v1.ListSwapsByRecipientRequest]) (*connect.Response[v1.ListSwapsByRecipientResponse], error) {
-	return c.listSwapsByRecipient.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) ListSwaps(context.Context, *v1.ListSwapsRequest) (*v1.ListSwapsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ListSwaps is not implemented")
 }
 
-// UpdateSwapL1Txid calls coinshift.v1.CoinShiftService.UpdateSwapL1Txid.
-func (c *coinShiftServiceClient) UpdateSwapL1Txid(ctx context.Context, req *connect.Request[v1.UpdateSwapL1TxidRequest]) (*connect.Response[v1.UpdateSwapL1TxidResponse], error) {
-	return c.updateSwapL1Txid.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) ListSwapsByRecipient(context.Context, *v1.ListSwapsByRecipientRequest) (*v1.ListSwapsByRecipientResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ListSwapsByRecipient is not implemented")
 }
 
-// ReconstructSwaps calls coinshift.v1.CoinShiftService.ReconstructSwaps.
-func (c *coinShiftServiceClient) ReconstructSwaps(ctx context.Context, req *connect.Request[v1.ReconstructSwapsRequest]) (*connect.Response[v1.ReconstructSwapsResponse], error) {
-	return c.reconstructSwaps.CallUnary(ctx, req)
+func (UnimplementedCoinShiftServiceHandler) UpdateSwapL1Txid(context.Context, *v1.UpdateSwapL1TxidRequest) (*v1.UpdateSwapL1TxidResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.UpdateSwapL1Txid is not implemented")
 }
 
-// CoinShiftServiceHandler is an implementation of the coinshift.v1.CoinShiftService service.
-type CoinShiftServiceHandler interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the coinshift node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// Forget a peer.
-	ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// Get OpenAPI schema.
-	OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error)
-	// Create a swap (L2 to L1).
-	CreateSwap(context.Context, *connect.Request[v1.CreateSwapRequest]) (*connect.Response[v1.CreateSwapResponse], error)
-	// Claim a swap.
-	ClaimSwap(context.Context, *connect.Request[v1.ClaimSwapRequest]) (*connect.Response[v1.ClaimSwapResponse], error)
-	// Get swap status.
-	GetSwapStatus(context.Context, *connect.Request[v1.GetSwapStatusRequest]) (*connect.Response[v1.GetSwapStatusResponse], error)
-	// List all swaps.
-	ListSwaps(context.Context, *connect.Request[v1.ListSwapsRequest]) (*connect.Response[v1.ListSwapsResponse], error)
-	// List swaps for a specific recipient.
-	ListSwapsByRecipient(context.Context, *connect.Request[v1.ListSwapsByRecipientRequest]) (*connect.Response[v1.ListSwapsByRecipientResponse], error)
-	// Update swap L1 transaction ID.
-	UpdateSwapL1Txid(context.Context, *connect.Request[v1.UpdateSwapL1TxidRequest]) (*connect.Response[v1.UpdateSwapL1TxidResponse], error)
-	// Reconstruct all swaps from blockchain.
-	ReconstructSwaps(context.Context, *connect.Request[v1.ReconstructSwapsRequest]) (*connect.Response[v1.ReconstructSwapsResponse], error)
-}
-
-// NewCoinShiftServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewCoinShiftServiceHandler(svc CoinShiftServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	coinShiftServiceMethods := v1.File_coinshift_v1_coinshift_proto.Services().ByName("CoinShiftService").Methods()
-	coinShiftServiceGetBalanceHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceStopHandler := connect.NewUnaryHandler(
-		CoinShiftServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(coinShiftServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceWithdrawHandler := connect.NewUnaryHandler(
-		CoinShiftServiceWithdrawProcedure,
-		svc.Withdraw,
-		connect.WithSchema(coinShiftServiceMethods.ByName("Withdraw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceTransferHandler := connect.NewUnaryHandler(
-		CoinShiftServiceTransferProcedure,
-		svc.Transfer,
-		connect.WithSchema(coinShiftServiceMethods.ByName("Transfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetSidechainWealthHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetSidechainWealthProcedure,
-		svc.GetSidechainWealth,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetSidechainWealth")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceCreateDepositHandler := connect.NewUnaryHandler(
-		CoinShiftServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(coinShiftServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetPendingWithdrawalBundleHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetPendingWithdrawalBundleProcedure,
-		svc.GetPendingWithdrawalBundle,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetPendingWithdrawalBundle")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceConnectPeerHandler := connect.NewUnaryHandler(
-		CoinShiftServiceConnectPeerProcedure,
-		svc.ConnectPeer,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ConnectPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceForgetPeerHandler := connect.NewUnaryHandler(
-		CoinShiftServiceForgetPeerProcedure,
-		svc.ForgetPeer,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ForgetPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceListPeersHandler := connect.NewUnaryHandler(
-		CoinShiftServiceListPeersProcedure,
-		svc.ListPeers,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ListPeers")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceMineHandler := connect.NewUnaryHandler(
-		CoinShiftServiceMineProcedure,
-		svc.Mine,
-		connect.WithSchema(coinShiftServiceMethods.ByName("Mine")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetBlockHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetBestMainchainBlockHashHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetBestMainchainBlockHashProcedure,
-		svc.GetBestMainchainBlockHash,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetBestMainchainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetBestSidechainBlockHashHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetBestSidechainBlockHashProcedure,
-		svc.GetBestSidechainBlockHash,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetBestSidechainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetBmmInclusionsHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetBmmInclusionsProcedure,
-		svc.GetBmmInclusions,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetBmmInclusions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetWalletUtxosHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetWalletUtxosProcedure,
-		svc.GetWalletUtxos,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetWalletUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceListUtxosHandler := connect.NewUnaryHandler(
-		CoinShiftServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceRemoveFromMempoolHandler := connect.NewUnaryHandler(
-		CoinShiftServiceRemoveFromMempoolProcedure,
-		svc.RemoveFromMempool,
-		connect.WithSchema(coinShiftServiceMethods.ByName("RemoveFromMempool")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetLatestFailedWithdrawalBundleHeightHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-		svc.GetLatestFailedWithdrawalBundleHeight,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGenerateMnemonicHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGenerateMnemonicProcedure,
-		svc.GenerateMnemonic,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GenerateMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceSetSeedFromMnemonicHandler := connect.NewUnaryHandler(
-		CoinShiftServiceSetSeedFromMnemonicProcedure,
-		svc.SetSeedFromMnemonic,
-		connect.WithSchema(coinShiftServiceMethods.ByName("SetSeedFromMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceCallRawHandler := connect.NewUnaryHandler(
-		CoinShiftServiceCallRawProcedure,
-		svc.CallRaw,
-		connect.WithSchema(coinShiftServiceMethods.ByName("CallRaw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetWalletAddressesHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetWalletAddressesProcedure,
-		svc.GetWalletAddresses,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetWalletAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceOpenapiSchemaHandler := connect.NewUnaryHandler(
-		CoinShiftServiceOpenapiSchemaProcedure,
-		svc.OpenapiSchema,
-		connect.WithSchema(coinShiftServiceMethods.ByName("OpenapiSchema")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceCreateSwapHandler := connect.NewUnaryHandler(
-		CoinShiftServiceCreateSwapProcedure,
-		svc.CreateSwap,
-		connect.WithSchema(coinShiftServiceMethods.ByName("CreateSwap")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceClaimSwapHandler := connect.NewUnaryHandler(
-		CoinShiftServiceClaimSwapProcedure,
-		svc.ClaimSwap,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ClaimSwap")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceGetSwapStatusHandler := connect.NewUnaryHandler(
-		CoinShiftServiceGetSwapStatusProcedure,
-		svc.GetSwapStatus,
-		connect.WithSchema(coinShiftServiceMethods.ByName("GetSwapStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceListSwapsHandler := connect.NewUnaryHandler(
-		CoinShiftServiceListSwapsProcedure,
-		svc.ListSwaps,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ListSwaps")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceListSwapsByRecipientHandler := connect.NewUnaryHandler(
-		CoinShiftServiceListSwapsByRecipientProcedure,
-		svc.ListSwapsByRecipient,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ListSwapsByRecipient")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceUpdateSwapL1TxidHandler := connect.NewUnaryHandler(
-		CoinShiftServiceUpdateSwapL1TxidProcedure,
-		svc.UpdateSwapL1Txid,
-		connect.WithSchema(coinShiftServiceMethods.ByName("UpdateSwapL1Txid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	coinShiftServiceReconstructSwapsHandler := connect.NewUnaryHandler(
-		CoinShiftServiceReconstructSwapsProcedure,
-		svc.ReconstructSwaps,
-		connect.WithSchema(coinShiftServiceMethods.ByName("ReconstructSwaps")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/coinshift.v1.CoinShiftService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case CoinShiftServiceGetBalanceProcedure:
-			coinShiftServiceGetBalanceHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetBlockCountProcedure:
-			coinShiftServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case CoinShiftServiceStopProcedure:
-			coinShiftServiceStopHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetNewAddressProcedure:
-			coinShiftServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case CoinShiftServiceWithdrawProcedure:
-			coinShiftServiceWithdrawHandler.ServeHTTP(w, r)
-		case CoinShiftServiceTransferProcedure:
-			coinShiftServiceTransferHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetSidechainWealthProcedure:
-			coinShiftServiceGetSidechainWealthHandler.ServeHTTP(w, r)
-		case CoinShiftServiceCreateDepositProcedure:
-			coinShiftServiceCreateDepositHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetPendingWithdrawalBundleProcedure:
-			coinShiftServiceGetPendingWithdrawalBundleHandler.ServeHTTP(w, r)
-		case CoinShiftServiceConnectPeerProcedure:
-			coinShiftServiceConnectPeerHandler.ServeHTTP(w, r)
-		case CoinShiftServiceForgetPeerProcedure:
-			coinShiftServiceForgetPeerHandler.ServeHTTP(w, r)
-		case CoinShiftServiceListPeersProcedure:
-			coinShiftServiceListPeersHandler.ServeHTTP(w, r)
-		case CoinShiftServiceMineProcedure:
-			coinShiftServiceMineHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetBlockProcedure:
-			coinShiftServiceGetBlockHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetBestMainchainBlockHashProcedure:
-			coinShiftServiceGetBestMainchainBlockHashHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetBestSidechainBlockHashProcedure:
-			coinShiftServiceGetBestSidechainBlockHashHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetBmmInclusionsProcedure:
-			coinShiftServiceGetBmmInclusionsHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetWalletUtxosProcedure:
-			coinShiftServiceGetWalletUtxosHandler.ServeHTTP(w, r)
-		case CoinShiftServiceListUtxosProcedure:
-			coinShiftServiceListUtxosHandler.ServeHTTP(w, r)
-		case CoinShiftServiceRemoveFromMempoolProcedure:
-			coinShiftServiceRemoveFromMempoolHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetLatestFailedWithdrawalBundleHeightProcedure:
-			coinShiftServiceGetLatestFailedWithdrawalBundleHeightHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGenerateMnemonicProcedure:
-			coinShiftServiceGenerateMnemonicHandler.ServeHTTP(w, r)
-		case CoinShiftServiceSetSeedFromMnemonicProcedure:
-			coinShiftServiceSetSeedFromMnemonicHandler.ServeHTTP(w, r)
-		case CoinShiftServiceCallRawProcedure:
-			coinShiftServiceCallRawHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetWalletAddressesProcedure:
-			coinShiftServiceGetWalletAddressesHandler.ServeHTTP(w, r)
-		case CoinShiftServiceOpenapiSchemaProcedure:
-			coinShiftServiceOpenapiSchemaHandler.ServeHTTP(w, r)
-		case CoinShiftServiceCreateSwapProcedure:
-			coinShiftServiceCreateSwapHandler.ServeHTTP(w, r)
-		case CoinShiftServiceClaimSwapProcedure:
-			coinShiftServiceClaimSwapHandler.ServeHTTP(w, r)
-		case CoinShiftServiceGetSwapStatusProcedure:
-			coinShiftServiceGetSwapStatusHandler.ServeHTTP(w, r)
-		case CoinShiftServiceListSwapsProcedure:
-			coinShiftServiceListSwapsHandler.ServeHTTP(w, r)
-		case CoinShiftServiceListSwapsByRecipientProcedure:
-			coinShiftServiceListSwapsByRecipientHandler.ServeHTTP(w, r)
-		case CoinShiftServiceUpdateSwapL1TxidProcedure:
-			coinShiftServiceUpdateSwapL1TxidHandler.ServeHTTP(w, r)
-		case CoinShiftServiceReconstructSwapsProcedure:
-			coinShiftServiceReconstructSwapsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedCoinShiftServiceHandler) ReconstructSwaps(context.Context, *v1.ReconstructSwapsRequest) (*v1.ReconstructSwapsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "coinshift.v1.CoinShiftService.ReconstructSwaps is not implemented")
 }
 
-// UnimplementedCoinShiftServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedCoinShiftServiceHandler struct{}
+type coinShiftServiceClient struct {
+	client *connect.Client
+}
 
-func (UnimplementedCoinShiftServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetBalance is not implemented"))
+func (c *coinShiftServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetBlockCount is not implemented"))
+func (c *coinShiftServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.Stop is not implemented"))
+func (c *coinShiftServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetNewAddress is not implemented"))
+func (c *coinShiftServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.Withdraw is not implemented"))
+func (c *coinShiftServiceClient) Withdraw(ctx context.Context, req *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	var res v1.WithdrawResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceWithdrawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.Transfer is not implemented"))
+func (c *coinShiftServiceClient) Transfer(ctx context.Context, req *v1.TransferRequest) (*v1.TransferResponse, error) {
+	var res v1.TransferResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetSidechainWealth is not implemented"))
+func (c *coinShiftServiceClient) GetSidechainWealth(ctx context.Context, req *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	var res v1.GetSidechainWealthResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetSidechainWealthSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.CreateDeposit is not implemented"))
+func (c *coinShiftServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetPendingWithdrawalBundle is not implemented"))
+func (c *coinShiftServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	var res v1.GetPendingWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetPendingWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ConnectPeer is not implemented"))
+func (c *coinShiftServiceClient) ConnectPeer(ctx context.Context, req *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	var res v1.ConnectPeerResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceConnectPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ForgetPeer is not implemented"))
+func (c *coinShiftServiceClient) ForgetPeer(ctx context.Context, req *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error) {
+	var res v1.ForgetPeerResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceForgetPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ListPeers is not implemented"))
+func (c *coinShiftServiceClient) ListPeers(ctx context.Context, req *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	var res v1.ListPeersResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceListPeersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.Mine is not implemented"))
+func (c *coinShiftServiceClient) Mine(ctx context.Context, req *v1.MineRequest) (*v1.MineResponse, error) {
+	var res v1.MineResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceMineSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetBlock is not implemented"))
+func (c *coinShiftServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetBestMainchainBlockHash is not implemented"))
+func (c *coinShiftServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	var res v1.GetBestMainchainBlockHashResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetBestMainchainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetBestSidechainBlockHash is not implemented"))
+func (c *coinShiftServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	var res v1.GetBestSidechainBlockHashResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetBestSidechainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetBmmInclusions is not implemented"))
+func (c *coinShiftServiceClient) GetBmmInclusions(ctx context.Context, req *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	var res v1.GetBmmInclusionsResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetBmmInclusionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetWalletUtxos is not implemented"))
+func (c *coinShiftServiceClient) GetWalletUtxos(ctx context.Context, req *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	var res v1.GetWalletUtxosResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetWalletUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ListUtxos is not implemented"))
+func (c *coinShiftServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.RemoveFromMempool is not implemented"))
+func (c *coinShiftServiceClient) RemoveFromMempool(ctx context.Context, req *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	var res v1.RemoveFromMempoolResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceRemoveFromMempoolSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetLatestFailedWithdrawalBundleHeight is not implemented"))
+func (c *coinShiftServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	var res v1.GetLatestFailedWithdrawalBundleHeightResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetLatestFailedWithdrawalBundleHeightSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) GenerateMnemonic(ctx context.Context, req *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	var res v1.GenerateMnemonicResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGenerateMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) SetSeedFromMnemonic(ctx context.Context, req *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	var res v1.SetSeedFromMnemonicResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceSetSeedFromMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) CallRaw(ctx context.Context, req *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	var res v1.CallRawResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceCallRawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) GetWalletAddresses(ctx context.Context, req *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	var res v1.GetWalletAddressesResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetWalletAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) OpenapiSchema(ctx context.Context, req *v1.OpenapiSchemaRequest) (*v1.OpenapiSchemaResponse, error) {
+	var res v1.OpenapiSchemaResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceOpenapiSchemaSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) CreateSwap(ctx context.Context, req *v1.CreateSwapRequest) (*v1.CreateSwapResponse, error) {
+	var res v1.CreateSwapResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceCreateSwapSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) ClaimSwap(ctx context.Context, req *v1.ClaimSwapRequest) (*v1.ClaimSwapResponse, error) {
+	var res v1.ClaimSwapResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceClaimSwapSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) GetSwapStatus(ctx context.Context, req *v1.GetSwapStatusRequest) (*v1.GetSwapStatusResponse, error) {
+	var res v1.GetSwapStatusResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceGetSwapStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) ListSwaps(ctx context.Context, req *v1.ListSwapsRequest) (*v1.ListSwapsResponse, error) {
+	var res v1.ListSwapsResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceListSwapsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) ListSwapsByRecipient(ctx context.Context, req *v1.ListSwapsByRecipientRequest) (*v1.ListSwapsByRecipientResponse, error) {
+	var res v1.ListSwapsByRecipientResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceListSwapsByRecipientSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) UpdateSwapL1Txid(ctx context.Context, req *v1.UpdateSwapL1TxidRequest) (*v1.UpdateSwapL1TxidResponse, error) {
+	var res v1.UpdateSwapL1TxidResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceUpdateSwapL1TxidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *coinShiftServiceClient) ReconstructSwaps(ctx context.Context, req *v1.ReconstructSwapsRequest) (*v1.ReconstructSwapsResponse, error) {
+	var res v1.ReconstructSwapsResponse
+	if err := c.client.CallUnary(ctx, coinShiftServiceReconstructSwapsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type coinShiftServiceHandler struct{ svc CoinShiftServiceHandler }
+
+func (h coinShiftServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) withdraw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WithdrawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Withdraw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) transfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Transfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) getSidechainWealth(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainWealthRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainWealth(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) getPendingWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GenerateMnemonic is not implemented"))
+func (h coinShiftServiceHandler) connectPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.SetSeedFromMnemonic is not implemented"))
+func (h coinShiftServiceHandler) forgetPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ForgetPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ForgetPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.CallRaw is not implemented"))
+func (h coinShiftServiceHandler) listPeers(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPeersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPeers(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetWalletAddresses is not implemented"))
+func (h coinShiftServiceHandler) mine(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MineRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Mine(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) OpenapiSchema(context.Context, *connect.Request[v1.OpenapiSchemaRequest]) (*connect.Response[v1.OpenapiSchemaResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.OpenapiSchema is not implemented"))
+func (h coinShiftServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) CreateSwap(context.Context, *connect.Request[v1.CreateSwapRequest]) (*connect.Response[v1.CreateSwapResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.CreateSwap is not implemented"))
+func (h coinShiftServiceHandler) getBestMainchainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestMainchainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestMainchainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) ClaimSwap(context.Context, *connect.Request[v1.ClaimSwapRequest]) (*connect.Response[v1.ClaimSwapResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ClaimSwap is not implemented"))
+func (h coinShiftServiceHandler) getBestSidechainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestSidechainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestSidechainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) GetSwapStatus(context.Context, *connect.Request[v1.GetSwapStatusRequest]) (*connect.Response[v1.GetSwapStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.GetSwapStatus is not implemented"))
+func (h coinShiftServiceHandler) getBmmInclusions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmInclusionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmInclusions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) ListSwaps(context.Context, *connect.Request[v1.ListSwapsRequest]) (*connect.Response[v1.ListSwapsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ListSwaps is not implemented"))
+func (h coinShiftServiceHandler) getWalletUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) ListSwapsByRecipient(context.Context, *connect.Request[v1.ListSwapsByRecipientRequest]) (*connect.Response[v1.ListSwapsByRecipientResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ListSwapsByRecipient is not implemented"))
+func (h coinShiftServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) removeFromMempool(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RemoveFromMempoolRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RemoveFromMempool(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) getLatestFailedWithdrawalBundleHeight(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetLatestFailedWithdrawalBundleHeightRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetLatestFailedWithdrawalBundleHeight(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) UpdateSwapL1Txid(context.Context, *connect.Request[v1.UpdateSwapL1TxidRequest]) (*connect.Response[v1.UpdateSwapL1TxidResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.UpdateSwapL1Txid is not implemented"))
+func (h coinShiftServiceHandler) generateMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedCoinShiftServiceHandler) ReconstructSwaps(context.Context, *connect.Request[v1.ReconstructSwapsRequest]) (*connect.Response[v1.ReconstructSwapsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("coinshift.v1.CoinShiftService.ReconstructSwaps is not implemented"))
+func (h coinShiftServiceHandler) setSeedFromMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSeedFromMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSeedFromMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) callRaw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CallRawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CallRaw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) getWalletAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) openapiSchema(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.OpenapiSchemaRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.OpenapiSchema(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) createSwap(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateSwapRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateSwap(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) claimSwap(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ClaimSwapRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ClaimSwap(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) getSwapStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSwapStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSwapStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) listSwaps(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSwapsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSwaps(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) listSwapsByRecipient(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSwapsByRecipientRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSwapsByRecipient(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) updateSwapL1Txid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UpdateSwapL1TxidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UpdateSwapL1Txid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h coinShiftServiceHandler) reconstructSwaps(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ReconstructSwapsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ReconstructSwaps(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go b/sidechain-orchestrator/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go
index 3939f1c638..86fab618a5 100644
--- a/sidechain-orchestrator/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go
+++ b/sidechain-orchestrator/gen/cusf/crypto/v1/cryptov1connect/crypto.connect.go
@@ -1,5 +1,3 @@
-// CUSF crypto service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/crypto/v1/crypto.proto
@@ -7,220 +5,240 @@
 package cryptov1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/crypto/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// CryptoServiceName is the fully-qualified name of the CryptoService service.
 	CryptoServiceName = "cusf.crypto.v1.CryptoService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// CryptoServiceHmacSha512Procedure is the fully-qualified name of the CryptoService's HmacSha512
-	// RPC.
+	// CryptoServiceHmacSha512Procedure is the procedure name of the CryptoService's HmacSha512 RPC.
 	CryptoServiceHmacSha512Procedure = "/cusf.crypto.v1.CryptoService/HmacSha512"
-	// CryptoServiceRipemd160Procedure is the fully-qualified name of the CryptoService's Ripemd160 RPC.
+	// CryptoServiceRipemd160Procedure is the procedure name of the CryptoService's Ripemd160 RPC.
 	CryptoServiceRipemd160Procedure = "/cusf.crypto.v1.CryptoService/Ripemd160"
-	// CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure is the fully-qualified name of the
-	// CryptoService's Secp256k1SecretKeyToPublicKey RPC.
+	// CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure is the procedure name of the CryptoService's
+	// Secp256k1SecretKeyToPublicKey RPC.
 	CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure = "/cusf.crypto.v1.CryptoService/Secp256k1SecretKeyToPublicKey"
-	// CryptoServiceSecp256K1SignProcedure is the fully-qualified name of the CryptoService's
-	// Secp256k1Sign RPC.
+	// CryptoServiceSecp256K1SignProcedure is the procedure name of the CryptoService's Secp256k1Sign
+	// RPC.
 	CryptoServiceSecp256K1SignProcedure = "/cusf.crypto.v1.CryptoService/Secp256k1Sign"
-	// CryptoServiceSecp256K1VerifyProcedure is the fully-qualified name of the CryptoService's
+	// CryptoServiceSecp256K1VerifyProcedure is the procedure name of the CryptoService's
 	// Secp256k1Verify RPC.
 	CryptoServiceSecp256K1VerifyProcedure = "/cusf.crypto.v1.CryptoService/Secp256k1Verify"
 )
 
+var (
+	cryptoServiceHmacSha512Spec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("HmacSha512"),
+			Procedure:  CryptoServiceHmacSha512Procedure,
+		}
+	})
+	cryptoServiceRipemd160Spec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Ripemd160"),
+			Procedure:  CryptoServiceRipemd160Procedure,
+		}
+	})
+	cryptoServiceSecp256K1SecretKeyToPublicKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Secp256k1SecretKeyToPublicKey"),
+			Procedure:  CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure,
+		}
+	})
+	cryptoServiceSecp256K1SignSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Secp256k1Sign"),
+			Procedure:  CryptoServiceSecp256K1SignProcedure,
+		}
+	})
+	cryptoServiceSecp256K1VerifySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods().ByName("Secp256k1Verify"),
+			Procedure:  CryptoServiceSecp256K1VerifyProcedure,
+		}
+	})
+)
+
 // CryptoServiceClient is a client for the cusf.crypto.v1.CryptoService service.
 type CryptoServiceClient interface {
-	HmacSha512(context.Context, *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error)
-	Ripemd160(context.Context, *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error)
-	Secp256K1SecretKeyToPublicKey(context.Context, *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error)
-	Secp256K1Sign(context.Context, *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error)
-	Secp256K1Verify(context.Context, *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error)
+	HmacSha512(context.Context, *v1.HmacSha512Request) (*v1.HmacSha512Response, error)
+	Ripemd160(context.Context, *v1.Ripemd160Request) (*v1.Ripemd160Response, error)
+	Secp256K1SecretKeyToPublicKey(context.Context, *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error)
+	Secp256K1Sign(context.Context, *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error)
+	Secp256K1Verify(context.Context, *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error)
 }
 
-// NewCryptoServiceClient constructs a client for the cusf.crypto.v1.CryptoService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewCryptoServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) CryptoServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	cryptoServiceMethods := v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods()
-	return &cryptoServiceClient{
-		hmacSha512: connect.NewClient[v1.HmacSha512Request, v1.HmacSha512Response](
-			httpClient,
-			baseURL+CryptoServiceHmacSha512Procedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("HmacSha512")),
-			connect.WithClientOptions(opts...),
-		),
-		ripemd160: connect.NewClient[v1.Ripemd160Request, v1.Ripemd160Response](
-			httpClient,
-			baseURL+CryptoServiceRipemd160Procedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Ripemd160")),
-			connect.WithClientOptions(opts...),
-		),
-		secp256K1SecretKeyToPublicKey: connect.NewClient[v1.Secp256K1SecretKeyToPublicKeyRequest, v1.Secp256K1SecretKeyToPublicKeyResponse](
-			httpClient,
-			baseURL+CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1SecretKeyToPublicKey")),
-			connect.WithClientOptions(opts...),
-		),
-		secp256K1Sign: connect.NewClient[v1.Secp256K1SignRequest, v1.Secp256K1SignResponse](
-			httpClient,
-			baseURL+CryptoServiceSecp256K1SignProcedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Sign")),
-			connect.WithClientOptions(opts...),
-		),
-		secp256K1Verify: connect.NewClient[v1.Secp256K1VerifyRequest, v1.Secp256K1VerifyResponse](
-			httpClient,
-			baseURL+CryptoServiceSecp256K1VerifyProcedure,
-			connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Verify")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// NewCryptoServiceClient constructs a client for the cusf.crypto.v1.CryptoService service. Multiple
+// service clients may share a single connect.Client.
+func NewCryptoServiceClient(client *connect.Client) CryptoServiceClient {
+	return &cryptoServiceClient{client: client}
 }
 
-// cryptoServiceClient implements CryptoServiceClient.
-type cryptoServiceClient struct {
-	hmacSha512                    *connect.Client[v1.HmacSha512Request, v1.HmacSha512Response]
-	ripemd160                     *connect.Client[v1.Ripemd160Request, v1.Ripemd160Response]
-	secp256K1SecretKeyToPublicKey *connect.Client[v1.Secp256K1SecretKeyToPublicKeyRequest, v1.Secp256K1SecretKeyToPublicKeyResponse]
-	secp256K1Sign                 *connect.Client[v1.Secp256K1SignRequest, v1.Secp256K1SignResponse]
-	secp256K1Verify               *connect.Client[v1.Secp256K1VerifyRequest, v1.Secp256K1VerifyResponse]
+// CryptoServiceHandler is an implementation of the cusf.crypto.v1.CryptoService service.
+type CryptoServiceHandler interface {
+	HmacSha512(context.Context, *v1.HmacSha512Request) (*v1.HmacSha512Response, error)
+	Ripemd160(context.Context, *v1.Ripemd160Request) (*v1.Ripemd160Response, error)
+	Secp256K1SecretKeyToPublicKey(context.Context, *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error)
+	Secp256K1Sign(context.Context, *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error)
+	Secp256K1Verify(context.Context, *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error)
 }
 
-// HmacSha512 calls cusf.crypto.v1.CryptoService.HmacSha512.
-func (c *cryptoServiceClient) HmacSha512(ctx context.Context, req *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error) {
-	return c.hmacSha512.CallUnary(ctx, req)
+// RegisterCryptoServiceHandler registers svc as the cusf.crypto.v1.CryptoService implementation on
+// server.
+func RegisterCryptoServiceHandler(server *connect.Server, svc CryptoServiceHandler) {
+	adapter := cryptoServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: cryptoServiceHmacSha512Spec(), Handler: adapter.hmacSha512},
+		connect.Method{Spec: cryptoServiceRipemd160Spec(), Handler: adapter.ripemd160},
+		connect.Method{Spec: cryptoServiceSecp256K1SecretKeyToPublicKeySpec(), Handler: adapter.secp256K1SecretKeyToPublicKey},
+		connect.Method{Spec: cryptoServiceSecp256K1SignSpec(), Handler: adapter.secp256K1Sign},
+		connect.Method{Spec: cryptoServiceSecp256K1VerifySpec(), Handler: adapter.secp256K1Verify},
+	)
 }
 
-// Ripemd160 calls cusf.crypto.v1.CryptoService.Ripemd160.
-func (c *cryptoServiceClient) Ripemd160(ctx context.Context, req *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error) {
-	return c.ripemd160.CallUnary(ctx, req)
+// UnimplementedCryptoServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedCryptoServiceHandler struct{}
+
+func (UnimplementedCryptoServiceHandler) HmacSha512(context.Context, *v1.HmacSha512Request) (*v1.HmacSha512Response, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.HmacSha512 is not implemented")
 }
 
-// Secp256K1SecretKeyToPublicKey calls cusf.crypto.v1.CryptoService.Secp256k1SecretKeyToPublicKey.
-func (c *cryptoServiceClient) Secp256K1SecretKeyToPublicKey(ctx context.Context, req *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error) {
-	return c.secp256K1SecretKeyToPublicKey.CallUnary(ctx, req)
+func (UnimplementedCryptoServiceHandler) Ripemd160(context.Context, *v1.Ripemd160Request) (*v1.Ripemd160Response, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Ripemd160 is not implemented")
 }
 
-// Secp256K1Sign calls cusf.crypto.v1.CryptoService.Secp256k1Sign.
-func (c *cryptoServiceClient) Secp256K1Sign(ctx context.Context, req *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error) {
-	return c.secp256K1Sign.CallUnary(ctx, req)
+func (UnimplementedCryptoServiceHandler) Secp256K1SecretKeyToPublicKey(context.Context, *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Secp256k1SecretKeyToPublicKey is not implemented")
 }
 
-// Secp256K1Verify calls cusf.crypto.v1.CryptoService.Secp256k1Verify.
-func (c *cryptoServiceClient) Secp256K1Verify(ctx context.Context, req *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error) {
-	return c.secp256K1Verify.CallUnary(ctx, req)
+func (UnimplementedCryptoServiceHandler) Secp256K1Sign(context.Context, *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Secp256k1Sign is not implemented")
 }
 
-// CryptoServiceHandler is an implementation of the cusf.crypto.v1.CryptoService service.
-type CryptoServiceHandler interface {
-	HmacSha512(context.Context, *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error)
-	Ripemd160(context.Context, *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error)
-	Secp256K1SecretKeyToPublicKey(context.Context, *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error)
-	Secp256K1Sign(context.Context, *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error)
-	Secp256K1Verify(context.Context, *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error)
+func (UnimplementedCryptoServiceHandler) Secp256K1Verify(context.Context, *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.crypto.v1.CryptoService.Secp256k1Verify is not implemented")
 }
 
-// NewCryptoServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewCryptoServiceHandler(svc CryptoServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	cryptoServiceMethods := v1.File_cusf_crypto_v1_crypto_proto.Services().ByName("CryptoService").Methods()
-	cryptoServiceHmacSha512Handler := connect.NewUnaryHandler(
-		CryptoServiceHmacSha512Procedure,
-		svc.HmacSha512,
-		connect.WithSchema(cryptoServiceMethods.ByName("HmacSha512")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceRipemd160Handler := connect.NewUnaryHandler(
-		CryptoServiceRipemd160Procedure,
-		svc.Ripemd160,
-		connect.WithSchema(cryptoServiceMethods.ByName("Ripemd160")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceSecp256K1SecretKeyToPublicKeyHandler := connect.NewUnaryHandler(
-		CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure,
-		svc.Secp256K1SecretKeyToPublicKey,
-		connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1SecretKeyToPublicKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceSecp256K1SignHandler := connect.NewUnaryHandler(
-		CryptoServiceSecp256K1SignProcedure,
-		svc.Secp256K1Sign,
-		connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Sign")),
-		connect.WithHandlerOptions(opts...),
-	)
-	cryptoServiceSecp256K1VerifyHandler := connect.NewUnaryHandler(
-		CryptoServiceSecp256K1VerifyProcedure,
-		svc.Secp256K1Verify,
-		connect.WithSchema(cryptoServiceMethods.ByName("Secp256k1Verify")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.crypto.v1.CryptoService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case CryptoServiceHmacSha512Procedure:
-			cryptoServiceHmacSha512Handler.ServeHTTP(w, r)
-		case CryptoServiceRipemd160Procedure:
-			cryptoServiceRipemd160Handler.ServeHTTP(w, r)
-		case CryptoServiceSecp256K1SecretKeyToPublicKeyProcedure:
-			cryptoServiceSecp256K1SecretKeyToPublicKeyHandler.ServeHTTP(w, r)
-		case CryptoServiceSecp256K1SignProcedure:
-			cryptoServiceSecp256K1SignHandler.ServeHTTP(w, r)
-		case CryptoServiceSecp256K1VerifyProcedure:
-			cryptoServiceSecp256K1VerifyHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type cryptoServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedCryptoServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedCryptoServiceHandler struct{}
+func (c *cryptoServiceClient) HmacSha512(ctx context.Context, req *v1.HmacSha512Request) (*v1.HmacSha512Response, error) {
+	var res v1.HmacSha512Response
+	if err := c.client.CallUnary(ctx, cryptoServiceHmacSha512Spec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedCryptoServiceHandler) HmacSha512(context.Context, *connect.Request[v1.HmacSha512Request]) (*connect.Response[v1.HmacSha512Response], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.HmacSha512 is not implemented"))
+func (c *cryptoServiceClient) Ripemd160(ctx context.Context, req *v1.Ripemd160Request) (*v1.Ripemd160Response, error) {
+	var res v1.Ripemd160Response
+	if err := c.client.CallUnary(ctx, cryptoServiceRipemd160Spec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Ripemd160(context.Context, *connect.Request[v1.Ripemd160Request]) (*connect.Response[v1.Ripemd160Response], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Ripemd160 is not implemented"))
+func (c *cryptoServiceClient) Secp256K1SecretKeyToPublicKey(ctx context.Context, req *v1.Secp256K1SecretKeyToPublicKeyRequest) (*v1.Secp256K1SecretKeyToPublicKeyResponse, error) {
+	var res v1.Secp256K1SecretKeyToPublicKeyResponse
+	if err := c.client.CallUnary(ctx, cryptoServiceSecp256K1SecretKeyToPublicKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Secp256K1SecretKeyToPublicKey(context.Context, *connect.Request[v1.Secp256K1SecretKeyToPublicKeyRequest]) (*connect.Response[v1.Secp256K1SecretKeyToPublicKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Secp256k1SecretKeyToPublicKey is not implemented"))
+func (c *cryptoServiceClient) Secp256K1Sign(ctx context.Context, req *v1.Secp256K1SignRequest) (*v1.Secp256K1SignResponse, error) {
+	var res v1.Secp256K1SignResponse
+	if err := c.client.CallUnary(ctx, cryptoServiceSecp256K1SignSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Secp256K1Sign(context.Context, *connect.Request[v1.Secp256K1SignRequest]) (*connect.Response[v1.Secp256K1SignResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Secp256k1Sign is not implemented"))
+func (c *cryptoServiceClient) Secp256K1Verify(ctx context.Context, req *v1.Secp256K1VerifyRequest) (*v1.Secp256K1VerifyResponse, error) {
+	var res v1.Secp256K1VerifyResponse
+	if err := c.client.CallUnary(ctx, cryptoServiceSecp256K1VerifySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedCryptoServiceHandler) Secp256K1Verify(context.Context, *connect.Request[v1.Secp256K1VerifyRequest]) (*connect.Response[v1.Secp256K1VerifyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.crypto.v1.CryptoService.Secp256k1Verify is not implemented"))
+type cryptoServiceHandler struct{ svc CryptoServiceHandler }
+
+func (h cryptoServiceHandler) hmacSha512(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.HmacSha512Request
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.HmacSha512(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) ripemd160(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Ripemd160Request
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Ripemd160(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) secp256K1SecretKeyToPublicKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Secp256K1SecretKeyToPublicKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Secp256K1SecretKeyToPublicKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) secp256K1Sign(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Secp256K1SignRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Secp256K1Sign(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h cryptoServiceHandler) secp256K1Verify(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.Secp256K1VerifyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Secp256K1Verify(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go b/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go
index 017d3291a9..9f1ac30478 100644
--- a/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go
+++ b/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/block_producer.connect.go
@@ -1,5 +1,3 @@
-// CUSF mainchain block producer service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/mainchain/v1/block_producer.proto
@@ -7,365 +5,389 @@
 package mainchainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BlockProducerServiceName is the fully-qualified name of the BlockProducerService service.
 	BlockProducerServiceName = "cusf.mainchain.v1.BlockProducerService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BlockProducerServiceCreateSidechainProposalProcedure is the fully-qualified name of the
+	// BlockProducerServiceCreateSidechainProposalProcedure is the procedure name of the
 	// BlockProducerService's CreateSidechainProposal RPC.
 	BlockProducerServiceCreateSidechainProposalProcedure = "/cusf.mainchain.v1.BlockProducerService/CreateSidechainProposal"
-	// BlockProducerServiceSubmitSidechainProposalProcedure is the fully-qualified name of the
+	// BlockProducerServiceSubmitSidechainProposalProcedure is the procedure name of the
 	// BlockProducerService's SubmitSidechainProposal RPC.
 	BlockProducerServiceSubmitSidechainProposalProcedure = "/cusf.mainchain.v1.BlockProducerService/SubmitSidechainProposal"
-	// BlockProducerServiceSetSidechainAckProcedure is the fully-qualified name of the
-	// BlockProducerService's SetSidechainAck RPC.
+	// BlockProducerServiceSetSidechainAckProcedure is the procedure name of the BlockProducerService's
+	// SetSidechainAck RPC.
 	BlockProducerServiceSetSidechainAckProcedure = "/cusf.mainchain.v1.BlockProducerService/SetSidechainAck"
-	// BlockProducerServiceSetAckAllProposalsProcedure is the fully-qualified name of the
+	// BlockProducerServiceSetAckAllProposalsProcedure is the procedure name of the
 	// BlockProducerService's SetAckAllProposals RPC.
 	BlockProducerServiceSetAckAllProposalsProcedure = "/cusf.mainchain.v1.BlockProducerService/SetAckAllProposals"
-	// BlockProducerServiceSetWithdrawalBundleAckProcedure is the fully-qualified name of the
+	// BlockProducerServiceSetWithdrawalBundleAckProcedure is the procedure name of the
 	// BlockProducerService's SetWithdrawalBundleAck RPC.
 	BlockProducerServiceSetWithdrawalBundleAckProcedure = "/cusf.mainchain.v1.BlockProducerService/SetWithdrawalBundleAck"
-	// BlockProducerServiceSetWithdrawalBundlePolicyProcedure is the fully-qualified name of the
+	// BlockProducerServiceSetWithdrawalBundlePolicyProcedure is the procedure name of the
 	// BlockProducerService's SetWithdrawalBundlePolicy RPC.
 	BlockProducerServiceSetWithdrawalBundlePolicyProcedure = "/cusf.mainchain.v1.BlockProducerService/SetWithdrawalBundlePolicy"
-	// BlockProducerServiceProposeWithdrawalBundleProcedure is the fully-qualified name of the
+	// BlockProducerServiceProposeWithdrawalBundleProcedure is the procedure name of the
 	// BlockProducerService's ProposeWithdrawalBundle RPC.
 	BlockProducerServiceProposeWithdrawalBundleProcedure = "/cusf.mainchain.v1.BlockProducerService/ProposeWithdrawalBundle"
-	// BlockProducerServiceGetBlockProducerStateProcedure is the fully-qualified name of the
+	// BlockProducerServiceGetBlockProducerStateProcedure is the procedure name of the
 	// BlockProducerService's GetBlockProducerState RPC.
 	BlockProducerServiceGetBlockProducerStateProcedure = "/cusf.mainchain.v1.BlockProducerService/GetBlockProducerState"
 )
 
+var (
+	blockProducerServiceCreateSidechainProposalSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("CreateSidechainProposal"),
+			Procedure:  BlockProducerServiceCreateSidechainProposalProcedure,
+		}
+	})
+	blockProducerServiceSubmitSidechainProposalSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SubmitSidechainProposal"),
+			Procedure:  BlockProducerServiceSubmitSidechainProposalProcedure,
+		}
+	})
+	blockProducerServiceSetSidechainAckSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SetSidechainAck"),
+			Procedure:  BlockProducerServiceSetSidechainAckProcedure,
+		}
+	})
+	blockProducerServiceSetAckAllProposalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SetAckAllProposals"),
+			Procedure:  BlockProducerServiceSetAckAllProposalsProcedure,
+		}
+	})
+	blockProducerServiceSetWithdrawalBundleAckSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SetWithdrawalBundleAck"),
+			Procedure:  BlockProducerServiceSetWithdrawalBundleAckProcedure,
+		}
+	})
+	blockProducerServiceSetWithdrawalBundlePolicySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("SetWithdrawalBundlePolicy"),
+			Procedure:  BlockProducerServiceSetWithdrawalBundlePolicyProcedure,
+		}
+	})
+	blockProducerServiceProposeWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("ProposeWithdrawalBundle"),
+			Procedure:        BlockProducerServiceProposeWithdrawalBundleProcedure,
+			IdempotencyLevel: connect.IdempotencyIdempotent,
+		}
+	})
+	blockProducerServiceGetBlockProducerStateSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods().ByName("GetBlockProducerState"),
+			Procedure:        BlockProducerServiceGetBlockProducerStateProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+)
+
 // BlockProducerServiceClient is a client for the cusf.mainchain.v1.BlockProducerService service.
 type BlockProducerServiceClient interface {
-	// Create a new sidechain proposal (M1 in BIP300) and persist to the local
-	// database for further processing.
-	// Sidechain proposals must be included in the coinbase transaction of a
-	// newly mined block, so this proposal is not active until a new block has
-	// been generated.
-	// Returns a stream of (non-)confirmation events for the sidechain proposal.
-	CreateSidechainProposal(context.Context, *connect.Request[v1.CreateSidechainProposalRequest]) (*connect.ServerStreamForClient[v1.CreateSidechainProposalResponse], error)
-	// Unary variant of `CreateSidechainProposal`. Creates a new sidechain
-	// proposal (M1 in BIP300) and persists it to the local database for further
-	// processing, returning immediately once the proposal has been created.
-	SubmitSidechainProposal(context.Context, *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error)
-	// Toggle ACK or NACK policy for a specific sidechain proposal. Redundant for
-	// proposals `SetAckAllProposals` already covers.
-	SetSidechainAck(context.Context, *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error)
-	// Set which sidechain proposals are ACKed without an explicit
-	// `SetSidechainAck`.
-	SetAckAllProposals(context.Context, *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error)
-	// Toggle ACK or NACK for a specific pending withdrawal bundle. An ACKed
-	// bundle is upvoted whatever `SetWithdrawalBundlePolicy` says, and is the
-	// only way to back a bundle under `WITHDRAWAL_BUNDLE_POLICY_NONE`. The ACK
-	// is dropped once the bundle stops being pending for that sidechain.
-	SetWithdrawalBundleAck(context.Context, *connect.Request[v1.SetWithdrawalBundleAckRequest]) (*connect.Response[v1.SetWithdrawalBundleAckResponse], error)
-	// Set which pending withdrawal bundles are upvoted without an explicit
-	// `SetWithdrawalBundleAck`.
-	SetWithdrawalBundlePolicy(context.Context, *connect.Request[v1.SetWithdrawalBundlePolicyRequest]) (*connect.Response[v1.SetWithdrawalBundlePolicyResponse], error)
-	// Store a withdrawal bundle so the block producer proposes it (M3). A bundle
-	// reaches only the block producer database, so a sidechain with no mainchain
-	// wallet still proposes one.
-	ProposeWithdrawalBundle(context.Context, *connect.Request[v1.ProposeWithdrawalBundleRequest]) (*connect.Response[v1.ProposeWithdrawalBundleResponse], error)
-	// Block-producer / operator state that is not (yet) reflected on-chain:
-	// sidechain proposals authored here but not yet mined into a coinbase, plus
-	// the ACK policy. Complements ValidatorService.GetSidechainProposals, which
-	// only reports proposals already on the chain.
-	GetBlockProducerState(context.Context, *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error)
+	CreateSidechainProposal(context.Context, *v1.CreateSidechainProposalRequest) (BlockProducerServiceCreateSidechainProposalClientStream, error)
+	SubmitSidechainProposal(context.Context, *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error)
+	SetSidechainAck(context.Context, *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error)
+	SetAckAllProposals(context.Context, *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error)
+	SetWithdrawalBundleAck(context.Context, *v1.SetWithdrawalBundleAckRequest) (*v1.SetWithdrawalBundleAckResponse, error)
+	SetWithdrawalBundlePolicy(context.Context, *v1.SetWithdrawalBundlePolicyRequest) (*v1.SetWithdrawalBundlePolicyResponse, error)
+	ProposeWithdrawalBundle(context.Context, *v1.ProposeWithdrawalBundleRequest) (*v1.ProposeWithdrawalBundleResponse, error)
+	GetBlockProducerState(context.Context, *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error)
 }
 
 // NewBlockProducerServiceClient constructs a client for the cusf.mainchain.v1.BlockProducerService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBlockProducerServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BlockProducerServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	blockProducerServiceMethods := v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods()
-	return &blockProducerServiceClient{
-		createSidechainProposal: connect.NewClient[v1.CreateSidechainProposalRequest, v1.CreateSidechainProposalResponse](
-			httpClient,
-			baseURL+BlockProducerServiceCreateSidechainProposalProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("CreateSidechainProposal")),
-			connect.WithClientOptions(opts...),
-		),
-		submitSidechainProposal: connect.NewClient[v1.SubmitSidechainProposalRequest, v1.SubmitSidechainProposalResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSubmitSidechainProposalProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SubmitSidechainProposal")),
-			connect.WithClientOptions(opts...),
-		),
-		setSidechainAck: connect.NewClient[v1.SetSidechainAckRequest, v1.SetSidechainAckResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSetSidechainAckProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SetSidechainAck")),
-			connect.WithClientOptions(opts...),
-		),
-		setAckAllProposals: connect.NewClient[v1.SetAckAllProposalsRequest, v1.SetAckAllProposalsResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSetAckAllProposalsProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SetAckAllProposals")),
-			connect.WithClientOptions(opts...),
-		),
-		setWithdrawalBundleAck: connect.NewClient[v1.SetWithdrawalBundleAckRequest, v1.SetWithdrawalBundleAckResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSetWithdrawalBundleAckProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SetWithdrawalBundleAck")),
-			connect.WithClientOptions(opts...),
-		),
-		setWithdrawalBundlePolicy: connect.NewClient[v1.SetWithdrawalBundlePolicyRequest, v1.SetWithdrawalBundlePolicyResponse](
-			httpClient,
-			baseURL+BlockProducerServiceSetWithdrawalBundlePolicyProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("SetWithdrawalBundlePolicy")),
-			connect.WithClientOptions(opts...),
-		),
-		proposeWithdrawalBundle: connect.NewClient[v1.ProposeWithdrawalBundleRequest, v1.ProposeWithdrawalBundleResponse](
-			httpClient,
-			baseURL+BlockProducerServiceProposeWithdrawalBundleProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("ProposeWithdrawalBundle")),
-			connect.WithIdempotency(connect.IdempotencyIdempotent),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockProducerState: connect.NewClient[v1.GetBlockProducerStateRequest, v1.GetBlockProducerStateResponse](
-			httpClient,
-			baseURL+BlockProducerServiceGetBlockProducerStateProcedure,
-			connect.WithSchema(blockProducerServiceMethods.ByName("GetBlockProducerState")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
+// service. Multiple service clients may share a single connect.Client.
+func NewBlockProducerServiceClient(client *connect.Client) BlockProducerServiceClient {
+	return &blockProducerServiceClient{client: client}
+}
+
+// BlockProducerServiceCreateSidechainProposalClientStream is the client stream for the
+// BlockProducerService's CreateSidechainProposal RPC.
+type BlockProducerServiceCreateSidechainProposalClientStream struct {
+	stream connect.ClientStream
+}
+
+// Receive returns the next response message from the server.
+func (s BlockProducerServiceCreateSidechainProposalClientStream) Receive() (*v1.CreateSidechainProposalResponse, error) {
+	var res v1.CreateSidechainProposalResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
 	}
+	return &res, nil
 }
 
-// blockProducerServiceClient implements BlockProducerServiceClient.
-type blockProducerServiceClient struct {
-	createSidechainProposal   *connect.Client[v1.CreateSidechainProposalRequest, v1.CreateSidechainProposalResponse]
-	submitSidechainProposal   *connect.Client[v1.SubmitSidechainProposalRequest, v1.SubmitSidechainProposalResponse]
-	setSidechainAck           *connect.Client[v1.SetSidechainAckRequest, v1.SetSidechainAckResponse]
-	setAckAllProposals        *connect.Client[v1.SetAckAllProposalsRequest, v1.SetAckAllProposalsResponse]
-	setWithdrawalBundleAck    *connect.Client[v1.SetWithdrawalBundleAckRequest, v1.SetWithdrawalBundleAckResponse]
-	setWithdrawalBundlePolicy *connect.Client[v1.SetWithdrawalBundlePolicyRequest, v1.SetWithdrawalBundlePolicyResponse]
-	proposeWithdrawalBundle   *connect.Client[v1.ProposeWithdrawalBundleRequest, v1.ProposeWithdrawalBundleResponse]
-	getBlockProducerState     *connect.Client[v1.GetBlockProducerStateRequest, v1.GetBlockProducerStateResponse]
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s BlockProducerServiceCreateSidechainProposalClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// CreateSidechainProposal calls cusf.mainchain.v1.BlockProducerService.CreateSidechainProposal.
-func (c *blockProducerServiceClient) CreateSidechainProposal(ctx context.Context, req *connect.Request[v1.CreateSidechainProposalRequest]) (*connect.ServerStreamForClient[v1.CreateSidechainProposalResponse], error) {
-	return c.createSidechainProposal.CallServerStream(ctx, req)
+// BlockProducerServiceHandler is an implementation of the cusf.mainchain.v1.BlockProducerService
+// service.
+type BlockProducerServiceHandler interface {
+	CreateSidechainProposal(context.Context, *v1.CreateSidechainProposalRequest, BlockProducerServiceCreateSidechainProposalServerStream) error
+	SubmitSidechainProposal(context.Context, *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error)
+	SetSidechainAck(context.Context, *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error)
+	SetAckAllProposals(context.Context, *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error)
+	SetWithdrawalBundleAck(context.Context, *v1.SetWithdrawalBundleAckRequest) (*v1.SetWithdrawalBundleAckResponse, error)
+	SetWithdrawalBundlePolicy(context.Context, *v1.SetWithdrawalBundlePolicyRequest) (*v1.SetWithdrawalBundlePolicyResponse, error)
+	ProposeWithdrawalBundle(context.Context, *v1.ProposeWithdrawalBundleRequest) (*v1.ProposeWithdrawalBundleResponse, error)
+	GetBlockProducerState(context.Context, *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error)
 }
 
-// SubmitSidechainProposal calls cusf.mainchain.v1.BlockProducerService.SubmitSidechainProposal.
-func (c *blockProducerServiceClient) SubmitSidechainProposal(ctx context.Context, req *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error) {
-	return c.submitSidechainProposal.CallUnary(ctx, req)
+// RegisterBlockProducerServiceHandler registers svc as the cusf.mainchain.v1.BlockProducerService
+// implementation on server.
+func RegisterBlockProducerServiceHandler(server *connect.Server, svc BlockProducerServiceHandler) {
+	adapter := blockProducerServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: blockProducerServiceCreateSidechainProposalSpec(), Handler: adapter.createSidechainProposal},
+		connect.Method{Spec: blockProducerServiceSubmitSidechainProposalSpec(), Handler: adapter.submitSidechainProposal},
+		connect.Method{Spec: blockProducerServiceSetSidechainAckSpec(), Handler: adapter.setSidechainAck},
+		connect.Method{Spec: blockProducerServiceSetAckAllProposalsSpec(), Handler: adapter.setAckAllProposals},
+		connect.Method{Spec: blockProducerServiceSetWithdrawalBundleAckSpec(), Handler: adapter.setWithdrawalBundleAck},
+		connect.Method{Spec: blockProducerServiceSetWithdrawalBundlePolicySpec(), Handler: adapter.setWithdrawalBundlePolicy},
+		connect.Method{Spec: blockProducerServiceProposeWithdrawalBundleSpec(), Handler: adapter.proposeWithdrawalBundle},
+		connect.Method{Spec: blockProducerServiceGetBlockProducerStateSpec(), Handler: adapter.getBlockProducerState},
+	)
 }
 
-// SetSidechainAck calls cusf.mainchain.v1.BlockProducerService.SetSidechainAck.
-func (c *blockProducerServiceClient) SetSidechainAck(ctx context.Context, req *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error) {
-	return c.setSidechainAck.CallUnary(ctx, req)
+// BlockProducerServiceCreateSidechainProposalServerStream is the server stream for the
+// BlockProducerService's CreateSidechainProposal RPC.
+type BlockProducerServiceCreateSidechainProposalServerStream struct {
+	stream connect.ServerStream
 }
 
-// SetAckAllProposals calls cusf.mainchain.v1.BlockProducerService.SetAckAllProposals.
-func (c *blockProducerServiceClient) SetAckAllProposals(ctx context.Context, req *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error) {
-	return c.setAckAllProposals.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s BlockProducerServiceCreateSidechainProposalServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// SetWithdrawalBundleAck calls cusf.mainchain.v1.BlockProducerService.SetWithdrawalBundleAck.
-func (c *blockProducerServiceClient) SetWithdrawalBundleAck(ctx context.Context, req *connect.Request[v1.SetWithdrawalBundleAckRequest]) (*connect.Response[v1.SetWithdrawalBundleAckResponse], error) {
-	return c.setWithdrawalBundleAck.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s BlockProducerServiceCreateSidechainProposalServerStream) Send(res *v1.CreateSidechainProposalResponse) error {
+	return s.stream.Send(res)
 }
 
-// SetWithdrawalBundlePolicy calls cusf.mainchain.v1.BlockProducerService.SetWithdrawalBundlePolicy.
-func (c *blockProducerServiceClient) SetWithdrawalBundlePolicy(ctx context.Context, req *connect.Request[v1.SetWithdrawalBundlePolicyRequest]) (*connect.Response[v1.SetWithdrawalBundlePolicyResponse], error) {
-	return c.setWithdrawalBundlePolicy.CallUnary(ctx, req)
+// UnimplementedBlockProducerServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBlockProducerServiceHandler struct{}
+
+func (UnimplementedBlockProducerServiceHandler) CreateSidechainProposal(context.Context, *v1.CreateSidechainProposalRequest, BlockProducerServiceCreateSidechainProposalServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.CreateSidechainProposal is not implemented")
 }
 
-// ProposeWithdrawalBundle calls cusf.mainchain.v1.BlockProducerService.ProposeWithdrawalBundle.
-func (c *blockProducerServiceClient) ProposeWithdrawalBundle(ctx context.Context, req *connect.Request[v1.ProposeWithdrawalBundleRequest]) (*connect.Response[v1.ProposeWithdrawalBundleResponse], error) {
-	return c.proposeWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedBlockProducerServiceHandler) SubmitSidechainProposal(context.Context, *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SubmitSidechainProposal is not implemented")
 }
 
-// GetBlockProducerState calls cusf.mainchain.v1.BlockProducerService.GetBlockProducerState.
-func (c *blockProducerServiceClient) GetBlockProducerState(ctx context.Context, req *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error) {
-	return c.getBlockProducerState.CallUnary(ctx, req)
+func (UnimplementedBlockProducerServiceHandler) SetSidechainAck(context.Context, *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SetSidechainAck is not implemented")
 }
 
-// BlockProducerServiceHandler is an implementation of the cusf.mainchain.v1.BlockProducerService
-// service.
-type BlockProducerServiceHandler interface {
-	// Create a new sidechain proposal (M1 in BIP300) and persist to the local
-	// database for further processing.
-	// Sidechain proposals must be included in the coinbase transaction of a
-	// newly mined block, so this proposal is not active until a new block has
-	// been generated.
-	// Returns a stream of (non-)confirmation events for the sidechain proposal.
-	CreateSidechainProposal(context.Context, *connect.Request[v1.CreateSidechainProposalRequest], *connect.ServerStream[v1.CreateSidechainProposalResponse]) error
-	// Unary variant of `CreateSidechainProposal`. Creates a new sidechain
-	// proposal (M1 in BIP300) and persists it to the local database for further
-	// processing, returning immediately once the proposal has been created.
-	SubmitSidechainProposal(context.Context, *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error)
-	// Toggle ACK or NACK policy for a specific sidechain proposal. Redundant for
-	// proposals `SetAckAllProposals` already covers.
-	SetSidechainAck(context.Context, *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error)
-	// Set which sidechain proposals are ACKed without an explicit
-	// `SetSidechainAck`.
-	SetAckAllProposals(context.Context, *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error)
-	// Toggle ACK or NACK for a specific pending withdrawal bundle. An ACKed
-	// bundle is upvoted whatever `SetWithdrawalBundlePolicy` says, and is the
-	// only way to back a bundle under `WITHDRAWAL_BUNDLE_POLICY_NONE`. The ACK
-	// is dropped once the bundle stops being pending for that sidechain.
-	SetWithdrawalBundleAck(context.Context, *connect.Request[v1.SetWithdrawalBundleAckRequest]) (*connect.Response[v1.SetWithdrawalBundleAckResponse], error)
-	// Set which pending withdrawal bundles are upvoted without an explicit
-	// `SetWithdrawalBundleAck`.
-	SetWithdrawalBundlePolicy(context.Context, *connect.Request[v1.SetWithdrawalBundlePolicyRequest]) (*connect.Response[v1.SetWithdrawalBundlePolicyResponse], error)
-	// Store a withdrawal bundle so the block producer proposes it (M3). A bundle
-	// reaches only the block producer database, so a sidechain with no mainchain
-	// wallet still proposes one.
-	ProposeWithdrawalBundle(context.Context, *connect.Request[v1.ProposeWithdrawalBundleRequest]) (*connect.Response[v1.ProposeWithdrawalBundleResponse], error)
-	// Block-producer / operator state that is not (yet) reflected on-chain:
-	// sidechain proposals authored here but not yet mined into a coinbase, plus
-	// the ACK policy. Complements ValidatorService.GetSidechainProposals, which
-	// only reports proposals already on the chain.
-	GetBlockProducerState(context.Context, *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error)
-}
-
-// NewBlockProducerServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBlockProducerServiceHandler(svc BlockProducerServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	blockProducerServiceMethods := v1.File_cusf_mainchain_v1_block_producer_proto.Services().ByName("BlockProducerService").Methods()
-	blockProducerServiceCreateSidechainProposalHandler := connect.NewServerStreamHandler(
-		BlockProducerServiceCreateSidechainProposalProcedure,
-		svc.CreateSidechainProposal,
-		connect.WithSchema(blockProducerServiceMethods.ByName("CreateSidechainProposal")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSubmitSidechainProposalHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSubmitSidechainProposalProcedure,
-		svc.SubmitSidechainProposal,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SubmitSidechainProposal")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSetSidechainAckHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSetSidechainAckProcedure,
-		svc.SetSidechainAck,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SetSidechainAck")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSetAckAllProposalsHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSetAckAllProposalsProcedure,
-		svc.SetAckAllProposals,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SetAckAllProposals")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSetWithdrawalBundleAckHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSetWithdrawalBundleAckProcedure,
-		svc.SetWithdrawalBundleAck,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SetWithdrawalBundleAck")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceSetWithdrawalBundlePolicyHandler := connect.NewUnaryHandler(
-		BlockProducerServiceSetWithdrawalBundlePolicyProcedure,
-		svc.SetWithdrawalBundlePolicy,
-		connect.WithSchema(blockProducerServiceMethods.ByName("SetWithdrawalBundlePolicy")),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceProposeWithdrawalBundleHandler := connect.NewUnaryHandler(
-		BlockProducerServiceProposeWithdrawalBundleProcedure,
-		svc.ProposeWithdrawalBundle,
-		connect.WithSchema(blockProducerServiceMethods.ByName("ProposeWithdrawalBundle")),
-		connect.WithIdempotency(connect.IdempotencyIdempotent),
-		connect.WithHandlerOptions(opts...),
-	)
-	blockProducerServiceGetBlockProducerStateHandler := connect.NewUnaryHandler(
-		BlockProducerServiceGetBlockProducerStateProcedure,
-		svc.GetBlockProducerState,
-		connect.WithSchema(blockProducerServiceMethods.ByName("GetBlockProducerState")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.mainchain.v1.BlockProducerService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BlockProducerServiceCreateSidechainProposalProcedure:
-			blockProducerServiceCreateSidechainProposalHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSubmitSidechainProposalProcedure:
-			blockProducerServiceSubmitSidechainProposalHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSetSidechainAckProcedure:
-			blockProducerServiceSetSidechainAckHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSetAckAllProposalsProcedure:
-			blockProducerServiceSetAckAllProposalsHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSetWithdrawalBundleAckProcedure:
-			blockProducerServiceSetWithdrawalBundleAckHandler.ServeHTTP(w, r)
-		case BlockProducerServiceSetWithdrawalBundlePolicyProcedure:
-			blockProducerServiceSetWithdrawalBundlePolicyHandler.ServeHTTP(w, r)
-		case BlockProducerServiceProposeWithdrawalBundleProcedure:
-			blockProducerServiceProposeWithdrawalBundleHandler.ServeHTTP(w, r)
-		case BlockProducerServiceGetBlockProducerStateProcedure:
-			blockProducerServiceGetBlockProducerStateHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedBlockProducerServiceHandler) SetAckAllProposals(context.Context, *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SetAckAllProposals is not implemented")
 }
 
-// UnimplementedBlockProducerServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBlockProducerServiceHandler struct{}
+func (UnimplementedBlockProducerServiceHandler) SetWithdrawalBundleAck(context.Context, *v1.SetWithdrawalBundleAckRequest) (*v1.SetWithdrawalBundleAckResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SetWithdrawalBundleAck is not implemented")
+}
 
-func (UnimplementedBlockProducerServiceHandler) CreateSidechainProposal(context.Context, *connect.Request[v1.CreateSidechainProposalRequest], *connect.ServerStream[v1.CreateSidechainProposalResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.CreateSidechainProposal is not implemented"))
+func (UnimplementedBlockProducerServiceHandler) SetWithdrawalBundlePolicy(context.Context, *v1.SetWithdrawalBundlePolicyRequest) (*v1.SetWithdrawalBundlePolicyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.SetWithdrawalBundlePolicy is not implemented")
 }
 
-func (UnimplementedBlockProducerServiceHandler) SubmitSidechainProposal(context.Context, *connect.Request[v1.SubmitSidechainProposalRequest]) (*connect.Response[v1.SubmitSidechainProposalResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SubmitSidechainProposal is not implemented"))
+func (UnimplementedBlockProducerServiceHandler) ProposeWithdrawalBundle(context.Context, *v1.ProposeWithdrawalBundleRequest) (*v1.ProposeWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.ProposeWithdrawalBundle is not implemented")
 }
 
-func (UnimplementedBlockProducerServiceHandler) SetSidechainAck(context.Context, *connect.Request[v1.SetSidechainAckRequest]) (*connect.Response[v1.SetSidechainAckResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SetSidechainAck is not implemented"))
+func (UnimplementedBlockProducerServiceHandler) GetBlockProducerState(context.Context, *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.BlockProducerService.GetBlockProducerState is not implemented")
 }
 
-func (UnimplementedBlockProducerServiceHandler) SetAckAllProposals(context.Context, *connect.Request[v1.SetAckAllProposalsRequest]) (*connect.Response[v1.SetAckAllProposalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SetAckAllProposals is not implemented"))
+type blockProducerServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedBlockProducerServiceHandler) SetWithdrawalBundleAck(context.Context, *connect.Request[v1.SetWithdrawalBundleAckRequest]) (*connect.Response[v1.SetWithdrawalBundleAckResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SetWithdrawalBundleAck is not implemented"))
+func (c *blockProducerServiceClient) CreateSidechainProposal(ctx context.Context, req *v1.CreateSidechainProposalRequest) (BlockProducerServiceCreateSidechainProposalClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, blockProducerServiceCreateSidechainProposalSpec(), req)
+	if err != nil {
+		return BlockProducerServiceCreateSidechainProposalClientStream{}, err
+	}
+	return BlockProducerServiceCreateSidechainProposalClientStream{stream: stream}, nil
 }
 
-func (UnimplementedBlockProducerServiceHandler) SetWithdrawalBundlePolicy(context.Context, *connect.Request[v1.SetWithdrawalBundlePolicyRequest]) (*connect.Response[v1.SetWithdrawalBundlePolicyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.SetWithdrawalBundlePolicy is not implemented"))
+func (c *blockProducerServiceClient) SubmitSidechainProposal(ctx context.Context, req *v1.SubmitSidechainProposalRequest) (*v1.SubmitSidechainProposalResponse, error) {
+	var res v1.SubmitSidechainProposalResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSubmitSidechainProposalSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBlockProducerServiceHandler) ProposeWithdrawalBundle(context.Context, *connect.Request[v1.ProposeWithdrawalBundleRequest]) (*connect.Response[v1.ProposeWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.ProposeWithdrawalBundle is not implemented"))
+func (c *blockProducerServiceClient) SetSidechainAck(ctx context.Context, req *v1.SetSidechainAckRequest) (*v1.SetSidechainAckResponse, error) {
+	var res v1.SetSidechainAckResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSetSidechainAckSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *blockProducerServiceClient) SetAckAllProposals(ctx context.Context, req *v1.SetAckAllProposalsRequest) (*v1.SetAckAllProposalsResponse, error) {
+	var res v1.SetAckAllProposalsResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSetAckAllProposalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *blockProducerServiceClient) SetWithdrawalBundleAck(ctx context.Context, req *v1.SetWithdrawalBundleAckRequest) (*v1.SetWithdrawalBundleAckResponse, error) {
+	var res v1.SetWithdrawalBundleAckResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSetWithdrawalBundleAckSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *blockProducerServiceClient) SetWithdrawalBundlePolicy(ctx context.Context, req *v1.SetWithdrawalBundlePolicyRequest) (*v1.SetWithdrawalBundlePolicyResponse, error) {
+	var res v1.SetWithdrawalBundlePolicyResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceSetWithdrawalBundlePolicySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBlockProducerServiceHandler) GetBlockProducerState(context.Context, *connect.Request[v1.GetBlockProducerStateRequest]) (*connect.Response[v1.GetBlockProducerStateResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.BlockProducerService.GetBlockProducerState is not implemented"))
+func (c *blockProducerServiceClient) ProposeWithdrawalBundle(ctx context.Context, req *v1.ProposeWithdrawalBundleRequest) (*v1.ProposeWithdrawalBundleResponse, error) {
+	var res v1.ProposeWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceProposeWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *blockProducerServiceClient) GetBlockProducerState(ctx context.Context, req *v1.GetBlockProducerStateRequest) (*v1.GetBlockProducerStateResponse, error) {
+	var res v1.GetBlockProducerStateResponse
+	if err := c.client.CallUnary(ctx, blockProducerServiceGetBlockProducerStateSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type blockProducerServiceHandler struct{ svc BlockProducerServiceHandler }
+
+func (h blockProducerServiceHandler) createSidechainProposal(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateSidechainProposalRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.CreateSidechainProposal(ctx, &req, BlockProducerServiceCreateSidechainProposalServerStream{stream: stream})
+}
+
+func (h blockProducerServiceHandler) submitSidechainProposal(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubmitSidechainProposalRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SubmitSidechainProposal(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) setSidechainAck(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSidechainAckRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSidechainAck(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) setAckAllProposals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetAckAllProposalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetAckAllProposals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) setWithdrawalBundleAck(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetWithdrawalBundleAckRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetWithdrawalBundleAck(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) setWithdrawalBundlePolicy(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetWithdrawalBundlePolicyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetWithdrawalBundlePolicy(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) proposeWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ProposeWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ProposeWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h blockProducerServiceHandler) getBlockProducerState(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockProducerStateRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockProducerState(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/mining.connect.go b/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/mining.connect.go
index 327fe94b52..08032d3e62 100644
--- a/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/mining.connect.go
+++ b/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/mining.connect.go
@@ -1,5 +1,3 @@
-// CUSF mainchain mining service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/mainchain/v1/mining.proto
@@ -7,127 +5,94 @@
 package mainchainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// MiningServiceName is the fully-qualified name of the MiningService service.
 	MiningServiceName = "cusf.mainchain.v1.MiningService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// MiningServiceGenerateToAddressProcedure is the fully-qualified name of the MiningService's
+	// MiningServiceGenerateToAddressProcedure is the procedure name of the MiningService's
 	// GenerateToAddress RPC.
 	MiningServiceGenerateToAddressProcedure = "/cusf.mainchain.v1.MiningService/GenerateToAddress"
 )
 
+var (
+	miningServiceGenerateToAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_cusf_mainchain_v1_mining_proto.Services().ByName("MiningService").Methods().ByName("GenerateToAddress"),
+			Procedure:  MiningServiceGenerateToAddressProcedure,
+		}
+	})
+)
+
 // MiningServiceClient is a client for the cusf.mainchain.v1.MiningService service.
 type MiningServiceClient interface {
-	// Mine blocks immediately to a specified address, returning the hashes of
-	// the mined blocks. Analogous to Bitcoin Core's `generatetoaddress` RPC.
-	//
-	// The ACK policy for sidechain proposals is the persisted block producer
-	// policy (see BlockProducerService.SetSidechainAck / SetAckAllProposals).
-	//
-	// On signet, blocks are produced by the signet miner, which sources its
-	// template from the enforcer's own block template server. Signet therefore
-	// requires the enforcer to run with `--enable-block-template-server`, and
-	// only one block can be generated per call. The Bitcoin Core node's wallet
-	// must also be able to solve the signet challenge.
-	GenerateToAddress(context.Context, *connect.Request[v1.GenerateToAddressRequest]) (*connect.Response[v1.GenerateToAddressResponse], error)
-}
-
-// NewMiningServiceClient constructs a client for the cusf.mainchain.v1.MiningService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewMiningServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) MiningServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	miningServiceMethods := v1.File_cusf_mainchain_v1_mining_proto.Services().ByName("MiningService").Methods()
-	return &miningServiceClient{
-		generateToAddress: connect.NewClient[v1.GenerateToAddressRequest, v1.GenerateToAddressResponse](
-			httpClient,
-			baseURL+MiningServiceGenerateToAddressProcedure,
-			connect.WithSchema(miningServiceMethods.ByName("GenerateToAddress")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+	GenerateToAddress(context.Context, *v1.GenerateToAddressRequest) (*v1.GenerateToAddressResponse, error)
 }
 
-// miningServiceClient implements MiningServiceClient.
-type miningServiceClient struct {
-	generateToAddress *connect.Client[v1.GenerateToAddressRequest, v1.GenerateToAddressResponse]
-}
-
-// GenerateToAddress calls cusf.mainchain.v1.MiningService.GenerateToAddress.
-func (c *miningServiceClient) GenerateToAddress(ctx context.Context, req *connect.Request[v1.GenerateToAddressRequest]) (*connect.Response[v1.GenerateToAddressResponse], error) {
-	return c.generateToAddress.CallUnary(ctx, req)
+// NewMiningServiceClient constructs a client for the cusf.mainchain.v1.MiningService service.
+// Multiple service clients may share a single connect.Client.
+func NewMiningServiceClient(client *connect.Client) MiningServiceClient {
+	return &miningServiceClient{client: client}
 }
 
 // MiningServiceHandler is an implementation of the cusf.mainchain.v1.MiningService service.
 type MiningServiceHandler interface {
-	// Mine blocks immediately to a specified address, returning the hashes of
-	// the mined blocks. Analogous to Bitcoin Core's `generatetoaddress` RPC.
-	//
-	// The ACK policy for sidechain proposals is the persisted block producer
-	// policy (see BlockProducerService.SetSidechainAck / SetAckAllProposals).
-	//
-	// On signet, blocks are produced by the signet miner, which sources its
-	// template from the enforcer's own block template server. Signet therefore
-	// requires the enforcer to run with `--enable-block-template-server`, and
-	// only one block can be generated per call. The Bitcoin Core node's wallet
-	// must also be able to solve the signet challenge.
-	GenerateToAddress(context.Context, *connect.Request[v1.GenerateToAddressRequest]) (*connect.Response[v1.GenerateToAddressResponse], error)
+	GenerateToAddress(context.Context, *v1.GenerateToAddressRequest) (*v1.GenerateToAddressResponse, error)
 }
 
-// NewMiningServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewMiningServiceHandler(svc MiningServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	miningServiceMethods := v1.File_cusf_mainchain_v1_mining_proto.Services().ByName("MiningService").Methods()
-	miningServiceGenerateToAddressHandler := connect.NewUnaryHandler(
-		MiningServiceGenerateToAddressProcedure,
-		svc.GenerateToAddress,
-		connect.WithSchema(miningServiceMethods.ByName("GenerateToAddress")),
-		connect.WithHandlerOptions(opts...),
+// RegisterMiningServiceHandler registers svc as the cusf.mainchain.v1.MiningService implementation
+// on server.
+func RegisterMiningServiceHandler(server *connect.Server, svc MiningServiceHandler) {
+	adapter := miningServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: miningServiceGenerateToAddressSpec(), Handler: adapter.generateToAddress},
 	)
-	return "/cusf.mainchain.v1.MiningService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case MiningServiceGenerateToAddressProcedure:
-			miningServiceGenerateToAddressHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
 }
 
 // UnimplementedMiningServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedMiningServiceHandler struct{}
 
-func (UnimplementedMiningServiceHandler) GenerateToAddress(context.Context, *connect.Request[v1.GenerateToAddressRequest]) (*connect.Response[v1.GenerateToAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.MiningService.GenerateToAddress is not implemented"))
+func (UnimplementedMiningServiceHandler) GenerateToAddress(context.Context, *v1.GenerateToAddressRequest) (*v1.GenerateToAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.MiningService.GenerateToAddress is not implemented")
+}
+
+type miningServiceClient struct {
+	client *connect.Client
+}
+
+func (c *miningServiceClient) GenerateToAddress(ctx context.Context, req *v1.GenerateToAddressRequest) (*v1.GenerateToAddressResponse, error) {
+	var res v1.GenerateToAddressResponse
+	if err := c.client.CallUnary(ctx, miningServiceGenerateToAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type miningServiceHandler struct{ svc MiningServiceHandler }
+
+func (h miningServiceHandler) generateToAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateToAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateToAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go b/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go
index 1302de1624..1c2c5cae19 100644
--- a/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go
+++ b/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect/validator.connect.go
@@ -1,5 +1,3 @@
-// CUSF mainchain validator service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/mainchain/v1/validator.proto
@@ -7,569 +5,691 @@
 package mainchainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ValidatorServiceName is the fully-qualified name of the ValidatorService service.
 	ValidatorServiceName = "cusf.mainchain.v1.ValidatorService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ValidatorServiceGetBlockHeaderInfoProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetBlockHeaderInfoProcedure is the procedure name of the ValidatorService's
 	// GetBlockHeaderInfo RPC.
 	ValidatorServiceGetBlockHeaderInfoProcedure = "/cusf.mainchain.v1.ValidatorService/GetBlockHeaderInfo"
-	// ValidatorServiceGetBlockInfoProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetBlockInfoProcedure is the procedure name of the ValidatorService's
 	// GetBlockInfo RPC.
 	ValidatorServiceGetBlockInfoProcedure = "/cusf.mainchain.v1.ValidatorService/GetBlockInfo"
-	// ValidatorServiceGetBmmHStarCommitmentProcedure is the fully-qualified name of the
-	// ValidatorService's GetBmmHStarCommitment RPC.
+	// ValidatorServiceGetBmmHStarCommitmentProcedure is the procedure name of the ValidatorService's
+	// GetBmmHStarCommitment RPC.
 	ValidatorServiceGetBmmHStarCommitmentProcedure = "/cusf.mainchain.v1.ValidatorService/GetBmmHStarCommitment"
-	// ValidatorServiceGetChainInfoProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetChainInfoProcedure is the procedure name of the ValidatorService's
 	// GetChainInfo RPC.
 	ValidatorServiceGetChainInfoProcedure = "/cusf.mainchain.v1.ValidatorService/GetChainInfo"
-	// ValidatorServiceGetChainTipProcedure is the fully-qualified name of the ValidatorService's
-	// GetChainTip RPC.
+	// ValidatorServiceGetChainTipProcedure is the procedure name of the ValidatorService's GetChainTip
+	// RPC.
 	ValidatorServiceGetChainTipProcedure = "/cusf.mainchain.v1.ValidatorService/GetChainTip"
-	// ValidatorServiceGetCoinbasePSBTProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetCoinbasePSBTProcedure is the procedure name of the ValidatorService's
 	// GetCoinbasePSBT RPC.
 	ValidatorServiceGetCoinbasePSBTProcedure = "/cusf.mainchain.v1.ValidatorService/GetCoinbasePSBT"
-	// ValidatorServiceGetCtipProcedure is the fully-qualified name of the ValidatorService's GetCtip
-	// RPC.
+	// ValidatorServiceGetCtipProcedure is the procedure name of the ValidatorService's GetCtip RPC.
 	ValidatorServiceGetCtipProcedure = "/cusf.mainchain.v1.ValidatorService/GetCtip"
-	// ValidatorServiceGetSeenBmmRequestsProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetSeenBmmRequestsProcedure is the procedure name of the ValidatorService's
 	// GetSeenBmmRequests RPC.
 	ValidatorServiceGetSeenBmmRequestsProcedure = "/cusf.mainchain.v1.ValidatorService/GetSeenBmmRequests"
-	// ValidatorServiceGetSidechainProposalsProcedure is the fully-qualified name of the
-	// ValidatorService's GetSidechainProposals RPC.
+	// ValidatorServiceGetSidechainProposalsProcedure is the procedure name of the ValidatorService's
+	// GetSidechainProposals RPC.
 	ValidatorServiceGetSidechainProposalsProcedure = "/cusf.mainchain.v1.ValidatorService/GetSidechainProposals"
-	// ValidatorServiceGetSidechainsProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetSidechainsProcedure is the procedure name of the ValidatorService's
 	// GetSidechains RPC.
 	ValidatorServiceGetSidechainsProcedure = "/cusf.mainchain.v1.ValidatorService/GetSidechains"
-	// ValidatorServiceGetTwoWayPegDataProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceGetTwoWayPegDataProcedure is the procedure name of the ValidatorService's
 	// GetTwoWayPegData RPC.
 	ValidatorServiceGetTwoWayPegDataProcedure = "/cusf.mainchain.v1.ValidatorService/GetTwoWayPegData"
-	// ValidatorServiceGetWithdrawalBundleProposalsProcedure is the fully-qualified name of the
+	// ValidatorServiceGetWithdrawalBundleProposalsProcedure is the procedure name of the
 	// ValidatorService's GetWithdrawalBundleProposals RPC.
 	ValidatorServiceGetWithdrawalBundleProposalsProcedure = "/cusf.mainchain.v1.ValidatorService/GetWithdrawalBundleProposals"
-	// ValidatorServiceSubscribeEventsProcedure is the fully-qualified name of the ValidatorService's
+	// ValidatorServiceSubscribeEventsProcedure is the procedure name of the ValidatorService's
 	// SubscribeEvents RPC.
 	ValidatorServiceSubscribeEventsProcedure = "/cusf.mainchain.v1.ValidatorService/SubscribeEvents"
-	// ValidatorServiceSubscribeHeaderSyncProgressProcedure is the fully-qualified name of the
+	// ValidatorServiceSubscribeHeaderSyncProgressProcedure is the procedure name of the
 	// ValidatorService's SubscribeHeaderSyncProgress RPC.
 	ValidatorServiceSubscribeHeaderSyncProgressProcedure = "/cusf.mainchain.v1.ValidatorService/SubscribeHeaderSyncProgress"
-	// ValidatorServiceStopProcedure is the fully-qualified name of the ValidatorService's Stop RPC.
+	// ValidatorServiceStopProcedure is the procedure name of the ValidatorService's Stop RPC.
 	ValidatorServiceStopProcedure = "/cusf.mainchain.v1.ValidatorService/Stop"
 )
 
+var (
+	validatorServiceGetBlockHeaderInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetBlockHeaderInfo"),
+			Procedure:        ValidatorServiceGetBlockHeaderInfoProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetBlockInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetBlockInfo"),
+			Procedure:        ValidatorServiceGetBlockInfoProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetBmmHStarCommitmentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetBmmHStarCommitment"),
+			Procedure:        ValidatorServiceGetBmmHStarCommitmentProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetChainInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetChainInfo"),
+			Procedure:        ValidatorServiceGetChainInfoProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetChainTipSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetChainTip"),
+			Procedure:        ValidatorServiceGetChainTipProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetCoinbasePSBTSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetCoinbasePSBT"),
+			Procedure:        ValidatorServiceGetCoinbasePSBTProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetCtipSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetCtip"),
+			Procedure:        ValidatorServiceGetCtipProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetSeenBmmRequestsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetSeenBmmRequests"),
+			Procedure:        ValidatorServiceGetSeenBmmRequestsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetSidechainProposalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetSidechainProposals"),
+			Procedure:        ValidatorServiceGetSidechainProposalsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetSidechainsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetSidechains"),
+			Procedure:        ValidatorServiceGetSidechainsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetTwoWayPegDataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetTwoWayPegData"),
+			Procedure:        ValidatorServiceGetTwoWayPegDataProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceGetWithdrawalBundleProposalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("GetWithdrawalBundleProposals"),
+			Procedure:        ValidatorServiceGetWithdrawalBundleProposalsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceSubscribeEventsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeServer,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("SubscribeEvents"),
+			Procedure:        ValidatorServiceSubscribeEventsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceSubscribeHeaderSyncProgressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeServer,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("SubscribeHeaderSyncProgress"),
+			Procedure:        ValidatorServiceSubscribeHeaderSyncProgressProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	validatorServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods().ByName("Stop"),
+			Procedure:        ValidatorServiceStopProcedure,
+			IdempotencyLevel: connect.IdempotencyIdempotent,
+		}
+	})
+)
+
 // ValidatorServiceClient is a client for the cusf.mainchain.v1.ValidatorService service.
 type ValidatorServiceClient interface {
-	// Fetches information about a specific mainchain block header,
-	// and optionally, it's ancestors
-	GetBlockHeaderInfo(context.Context, *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error)
-	// Fetches information about a specific mainchain block (and optionally,
-	// it's ancestors), regarding how it pertains to events happening on a
-	// specific sidechain.
-	GetBlockInfo(context.Context, *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error)
-	// Fetches BMM h* commitment for a specific mainchain block,
-	// and optionally, it's ancestors
-	GetBmmHStarCommitment(context.Context, *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error)
-	GetChainInfo(context.Context, *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error)
-	GetChainTip(context.Context, *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error)
-	GetCoinbasePSBT(context.Context, *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error)
-	GetCtip(context.Context, *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error)
-	// Fetches the BMM requests (M8) that the mempool holds for a mainchain
-	// block. A request whose transaction left the mempool is left out, so a
-	// replaced bid never appears.
-	GetSeenBmmRequests(context.Context, *connect.Request[v1.GetSeenBmmRequestsRequest]) (*connect.Response[v1.GetSeenBmmRequestsResponse], error)
-	GetSidechainProposals(context.Context, *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error)
-	GetSidechains(context.Context, *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error)
-	GetTwoWayPegData(context.Context, *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error)
-	GetWithdrawalBundleProposals(context.Context, *connect.Request[v1.GetWithdrawalBundleProposalsRequest]) (*connect.Response[v1.GetWithdrawalBundleProposalsResponse], error)
-	SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.SubscribeEventsResponse], error)
-	// Stream header sync progress updates
-	SubscribeHeaderSyncProgress(context.Context, *connect.Request[v1.SubscribeHeaderSyncProgressRequest]) (*connect.ServerStreamForClient[v1.SubscribeHeaderSyncProgressResponse], error)
-	// Safely shutdown the validator. This is equivalent to sending a SIGINT
-	// to the validator process, and can be used to trigger a graceful shutdown
-	// in cases where you don't have access to the validator process.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
+	GetBlockHeaderInfo(context.Context, *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error)
+	GetBlockInfo(context.Context, *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error)
+	GetBmmHStarCommitment(context.Context, *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error)
+	GetChainInfo(context.Context, *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error)
+	GetChainTip(context.Context, *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error)
+	GetCoinbasePSBT(context.Context, *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error)
+	GetCtip(context.Context, *v1.GetCtipRequest) (*v1.GetCtipResponse, error)
+	GetSeenBmmRequests(context.Context, *v1.GetSeenBmmRequestsRequest) (*v1.GetSeenBmmRequestsResponse, error)
+	GetSidechainProposals(context.Context, *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error)
+	GetSidechains(context.Context, *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error)
+	GetTwoWayPegData(context.Context, *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error)
+	GetWithdrawalBundleProposals(context.Context, *v1.GetWithdrawalBundleProposalsRequest) (*v1.GetWithdrawalBundleProposalsResponse, error)
+	SubscribeEvents(context.Context, *v1.SubscribeEventsRequest) (ValidatorServiceSubscribeEventsClientStream, error)
+	SubscribeHeaderSyncProgress(context.Context, *v1.SubscribeHeaderSyncProgressRequest) (ValidatorServiceSubscribeHeaderSyncProgressClientStream, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
 }
 
 // NewValidatorServiceClient constructs a client for the cusf.mainchain.v1.ValidatorService service.
-// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped
-// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewValidatorServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ValidatorServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	validatorServiceMethods := v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods()
-	return &validatorServiceClient{
-		getBlockHeaderInfo: connect.NewClient[v1.GetBlockHeaderInfoRequest, v1.GetBlockHeaderInfoResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetBlockHeaderInfoProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetBlockHeaderInfo")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockInfo: connect.NewClient[v1.GetBlockInfoRequest, v1.GetBlockInfoResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetBlockInfoProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetBlockInfo")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmHStarCommitment: connect.NewClient[v1.GetBmmHStarCommitmentRequest, v1.GetBmmHStarCommitmentResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetBmmHStarCommitmentProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetBmmHStarCommitment")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getChainInfo: connect.NewClient[v1.GetChainInfoRequest, v1.GetChainInfoResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetChainInfoProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetChainInfo")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getChainTip: connect.NewClient[v1.GetChainTipRequest, v1.GetChainTipResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetChainTipProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetChainTip")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getCoinbasePSBT: connect.NewClient[v1.GetCoinbasePSBTRequest, v1.GetCoinbasePSBTResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetCoinbasePSBTProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetCoinbasePSBT")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getCtip: connect.NewClient[v1.GetCtipRequest, v1.GetCtipResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetCtipProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetCtip")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getSeenBmmRequests: connect.NewClient[v1.GetSeenBmmRequestsRequest, v1.GetSeenBmmRequestsResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetSeenBmmRequestsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetSeenBmmRequests")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainProposals: connect.NewClient[v1.GetSidechainProposalsRequest, v1.GetSidechainProposalsResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetSidechainProposalsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetSidechainProposals")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechains: connect.NewClient[v1.GetSidechainsRequest, v1.GetSidechainsResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetSidechainsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetSidechains")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getTwoWayPegData: connect.NewClient[v1.GetTwoWayPegDataRequest, v1.GetTwoWayPegDataResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetTwoWayPegDataProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetTwoWayPegData")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getWithdrawalBundleProposals: connect.NewClient[v1.GetWithdrawalBundleProposalsRequest, v1.GetWithdrawalBundleProposalsResponse](
-			httpClient,
-			baseURL+ValidatorServiceGetWithdrawalBundleProposalsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("GetWithdrawalBundleProposals")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		subscribeEvents: connect.NewClient[v1.SubscribeEventsRequest, v1.SubscribeEventsResponse](
-			httpClient,
-			baseURL+ValidatorServiceSubscribeEventsProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("SubscribeEvents")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		subscribeHeaderSyncProgress: connect.NewClient[v1.SubscribeHeaderSyncProgressRequest, v1.SubscribeHeaderSyncProgressResponse](
-			httpClient,
-			baseURL+ValidatorServiceSubscribeHeaderSyncProgressProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("SubscribeHeaderSyncProgress")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+ValidatorServiceStopProcedure,
-			connect.WithSchema(validatorServiceMethods.ByName("Stop")),
-			connect.WithIdempotency(connect.IdempotencyIdempotent),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// validatorServiceClient implements ValidatorServiceClient.
-type validatorServiceClient struct {
-	getBlockHeaderInfo           *connect.Client[v1.GetBlockHeaderInfoRequest, v1.GetBlockHeaderInfoResponse]
-	getBlockInfo                 *connect.Client[v1.GetBlockInfoRequest, v1.GetBlockInfoResponse]
-	getBmmHStarCommitment        *connect.Client[v1.GetBmmHStarCommitmentRequest, v1.GetBmmHStarCommitmentResponse]
-	getChainInfo                 *connect.Client[v1.GetChainInfoRequest, v1.GetChainInfoResponse]
-	getChainTip                  *connect.Client[v1.GetChainTipRequest, v1.GetChainTipResponse]
-	getCoinbasePSBT              *connect.Client[v1.GetCoinbasePSBTRequest, v1.GetCoinbasePSBTResponse]
-	getCtip                      *connect.Client[v1.GetCtipRequest, v1.GetCtipResponse]
-	getSeenBmmRequests           *connect.Client[v1.GetSeenBmmRequestsRequest, v1.GetSeenBmmRequestsResponse]
-	getSidechainProposals        *connect.Client[v1.GetSidechainProposalsRequest, v1.GetSidechainProposalsResponse]
-	getSidechains                *connect.Client[v1.GetSidechainsRequest, v1.GetSidechainsResponse]
-	getTwoWayPegData             *connect.Client[v1.GetTwoWayPegDataRequest, v1.GetTwoWayPegDataResponse]
-	getWithdrawalBundleProposals *connect.Client[v1.GetWithdrawalBundleProposalsRequest, v1.GetWithdrawalBundleProposalsResponse]
-	subscribeEvents              *connect.Client[v1.SubscribeEventsRequest, v1.SubscribeEventsResponse]
-	subscribeHeaderSyncProgress  *connect.Client[v1.SubscribeHeaderSyncProgressRequest, v1.SubscribeHeaderSyncProgressResponse]
-	stop                         *connect.Client[v1.StopRequest, v1.StopResponse]
+// Multiple service clients may share a single connect.Client.
+func NewValidatorServiceClient(client *connect.Client) ValidatorServiceClient {
+	return &validatorServiceClient{client: client}
+}
+
+// ValidatorServiceSubscribeEventsClientStream is the client stream for the ValidatorService's
+// SubscribeEvents RPC.
+type ValidatorServiceSubscribeEventsClientStream struct {
+	stream connect.ClientStream
+}
+
+// Receive returns the next response message from the server.
+func (s ValidatorServiceSubscribeEventsClientStream) Receive() (*v1.SubscribeEventsResponse, error) {
+	var res v1.SubscribeEventsResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// GetBlockHeaderInfo calls cusf.mainchain.v1.ValidatorService.GetBlockHeaderInfo.
-func (c *validatorServiceClient) GetBlockHeaderInfo(ctx context.Context, req *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error) {
-	return c.getBlockHeaderInfo.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s ValidatorServiceSubscribeEventsClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// GetBlockInfo calls cusf.mainchain.v1.ValidatorService.GetBlockInfo.
-func (c *validatorServiceClient) GetBlockInfo(ctx context.Context, req *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error) {
-	return c.getBlockInfo.CallUnary(ctx, req)
+// ValidatorServiceSubscribeHeaderSyncProgressClientStream is the client stream for the
+// ValidatorService's SubscribeHeaderSyncProgress RPC.
+type ValidatorServiceSubscribeHeaderSyncProgressClientStream struct {
+	stream connect.ClientStream
 }
 
-// GetBmmHStarCommitment calls cusf.mainchain.v1.ValidatorService.GetBmmHStarCommitment.
-func (c *validatorServiceClient) GetBmmHStarCommitment(ctx context.Context, req *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error) {
-	return c.getBmmHStarCommitment.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s ValidatorServiceSubscribeHeaderSyncProgressClientStream) Receive() (*v1.SubscribeHeaderSyncProgressResponse, error) {
+	var res v1.SubscribeHeaderSyncProgressResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// GetChainInfo calls cusf.mainchain.v1.ValidatorService.GetChainInfo.
-func (c *validatorServiceClient) GetChainInfo(ctx context.Context, req *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error) {
-	return c.getChainInfo.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s ValidatorServiceSubscribeHeaderSyncProgressClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// GetChainTip calls cusf.mainchain.v1.ValidatorService.GetChainTip.
-func (c *validatorServiceClient) GetChainTip(ctx context.Context, req *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error) {
-	return c.getChainTip.CallUnary(ctx, req)
+// ValidatorServiceHandler is an implementation of the cusf.mainchain.v1.ValidatorService service.
+type ValidatorServiceHandler interface {
+	GetBlockHeaderInfo(context.Context, *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error)
+	GetBlockInfo(context.Context, *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error)
+	GetBmmHStarCommitment(context.Context, *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error)
+	GetChainInfo(context.Context, *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error)
+	GetChainTip(context.Context, *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error)
+	GetCoinbasePSBT(context.Context, *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error)
+	GetCtip(context.Context, *v1.GetCtipRequest) (*v1.GetCtipResponse, error)
+	GetSeenBmmRequests(context.Context, *v1.GetSeenBmmRequestsRequest) (*v1.GetSeenBmmRequestsResponse, error)
+	GetSidechainProposals(context.Context, *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error)
+	GetSidechains(context.Context, *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error)
+	GetTwoWayPegData(context.Context, *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error)
+	GetWithdrawalBundleProposals(context.Context, *v1.GetWithdrawalBundleProposalsRequest) (*v1.GetWithdrawalBundleProposalsResponse, error)
+	SubscribeEvents(context.Context, *v1.SubscribeEventsRequest, ValidatorServiceSubscribeEventsServerStream) error
+	SubscribeHeaderSyncProgress(context.Context, *v1.SubscribeHeaderSyncProgressRequest, ValidatorServiceSubscribeHeaderSyncProgressServerStream) error
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+}
+
+// RegisterValidatorServiceHandler registers svc as the cusf.mainchain.v1.ValidatorService
+// implementation on server.
+func RegisterValidatorServiceHandler(server *connect.Server, svc ValidatorServiceHandler) {
+	adapter := validatorServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: validatorServiceGetBlockHeaderInfoSpec(), Handler: adapter.getBlockHeaderInfo},
+		connect.Method{Spec: validatorServiceGetBlockInfoSpec(), Handler: adapter.getBlockInfo},
+		connect.Method{Spec: validatorServiceGetBmmHStarCommitmentSpec(), Handler: adapter.getBmmHStarCommitment},
+		connect.Method{Spec: validatorServiceGetChainInfoSpec(), Handler: adapter.getChainInfo},
+		connect.Method{Spec: validatorServiceGetChainTipSpec(), Handler: adapter.getChainTip},
+		connect.Method{Spec: validatorServiceGetCoinbasePSBTSpec(), Handler: adapter.getCoinbasePSBT},
+		connect.Method{Spec: validatorServiceGetCtipSpec(), Handler: adapter.getCtip},
+		connect.Method{Spec: validatorServiceGetSeenBmmRequestsSpec(), Handler: adapter.getSeenBmmRequests},
+		connect.Method{Spec: validatorServiceGetSidechainProposalsSpec(), Handler: adapter.getSidechainProposals},
+		connect.Method{Spec: validatorServiceGetSidechainsSpec(), Handler: adapter.getSidechains},
+		connect.Method{Spec: validatorServiceGetTwoWayPegDataSpec(), Handler: adapter.getTwoWayPegData},
+		connect.Method{Spec: validatorServiceGetWithdrawalBundleProposalsSpec(), Handler: adapter.getWithdrawalBundleProposals},
+		connect.Method{Spec: validatorServiceSubscribeEventsSpec(), Handler: adapter.subscribeEvents},
+		connect.Method{Spec: validatorServiceSubscribeHeaderSyncProgressSpec(), Handler: adapter.subscribeHeaderSyncProgress},
+		connect.Method{Spec: validatorServiceStopSpec(), Handler: adapter.stop},
+	)
 }
 
-// GetCoinbasePSBT calls cusf.mainchain.v1.ValidatorService.GetCoinbasePSBT.
-func (c *validatorServiceClient) GetCoinbasePSBT(ctx context.Context, req *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error) {
-	return c.getCoinbasePSBT.CallUnary(ctx, req)
+// ValidatorServiceSubscribeEventsServerStream is the server stream for the ValidatorService's
+// SubscribeEvents RPC.
+type ValidatorServiceSubscribeEventsServerStream struct {
+	stream connect.ServerStream
 }
 
-// GetCtip calls cusf.mainchain.v1.ValidatorService.GetCtip.
-func (c *validatorServiceClient) GetCtip(ctx context.Context, req *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error) {
-	return c.getCtip.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s ValidatorServiceSubscribeEventsServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// GetSeenBmmRequests calls cusf.mainchain.v1.ValidatorService.GetSeenBmmRequests.
-func (c *validatorServiceClient) GetSeenBmmRequests(ctx context.Context, req *connect.Request[v1.GetSeenBmmRequestsRequest]) (*connect.Response[v1.GetSeenBmmRequestsResponse], error) {
-	return c.getSeenBmmRequests.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s ValidatorServiceSubscribeEventsServerStream) Send(res *v1.SubscribeEventsResponse) error {
+	return s.stream.Send(res)
 }
 
-// GetSidechainProposals calls cusf.mainchain.v1.ValidatorService.GetSidechainProposals.
-func (c *validatorServiceClient) GetSidechainProposals(ctx context.Context, req *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error) {
-	return c.getSidechainProposals.CallUnary(ctx, req)
+// ValidatorServiceSubscribeHeaderSyncProgressServerStream is the server stream for the
+// ValidatorService's SubscribeHeaderSyncProgress RPC.
+type ValidatorServiceSubscribeHeaderSyncProgressServerStream struct {
+	stream connect.ServerStream
 }
 
-// GetSidechains calls cusf.mainchain.v1.ValidatorService.GetSidechains.
-func (c *validatorServiceClient) GetSidechains(ctx context.Context, req *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error) {
-	return c.getSidechains.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s ValidatorServiceSubscribeHeaderSyncProgressServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// GetTwoWayPegData calls cusf.mainchain.v1.ValidatorService.GetTwoWayPegData.
-func (c *validatorServiceClient) GetTwoWayPegData(ctx context.Context, req *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error) {
-	return c.getTwoWayPegData.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s ValidatorServiceSubscribeHeaderSyncProgressServerStream) Send(res *v1.SubscribeHeaderSyncProgressResponse) error {
+	return s.stream.Send(res)
 }
 
-// GetWithdrawalBundleProposals calls
-// cusf.mainchain.v1.ValidatorService.GetWithdrawalBundleProposals.
-func (c *validatorServiceClient) GetWithdrawalBundleProposals(ctx context.Context, req *connect.Request[v1.GetWithdrawalBundleProposalsRequest]) (*connect.Response[v1.GetWithdrawalBundleProposalsResponse], error) {
-	return c.getWithdrawalBundleProposals.CallUnary(ctx, req)
+// UnimplementedValidatorServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedValidatorServiceHandler struct{}
+
+func (UnimplementedValidatorServiceHandler) GetBlockHeaderInfo(context.Context, *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetBlockHeaderInfo is not implemented")
 }
 
-// SubscribeEvents calls cusf.mainchain.v1.ValidatorService.SubscribeEvents.
-func (c *validatorServiceClient) SubscribeEvents(ctx context.Context, req *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.SubscribeEventsResponse], error) {
-	return c.subscribeEvents.CallServerStream(ctx, req)
+func (UnimplementedValidatorServiceHandler) GetBlockInfo(context.Context, *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetBlockInfo is not implemented")
 }
 
-// SubscribeHeaderSyncProgress calls cusf.mainchain.v1.ValidatorService.SubscribeHeaderSyncProgress.
-func (c *validatorServiceClient) SubscribeHeaderSyncProgress(ctx context.Context, req *connect.Request[v1.SubscribeHeaderSyncProgressRequest]) (*connect.ServerStreamForClient[v1.SubscribeHeaderSyncProgressResponse], error) {
-	return c.subscribeHeaderSyncProgress.CallServerStream(ctx, req)
+func (UnimplementedValidatorServiceHandler) GetBmmHStarCommitment(context.Context, *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetBmmHStarCommitment is not implemented")
 }
 
-// Stop calls cusf.mainchain.v1.ValidatorService.Stop.
-func (c *validatorServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedValidatorServiceHandler) GetChainInfo(context.Context, *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetChainInfo is not implemented")
 }
 
-// ValidatorServiceHandler is an implementation of the cusf.mainchain.v1.ValidatorService service.
-type ValidatorServiceHandler interface {
-	// Fetches information about a specific mainchain block header,
-	// and optionally, it's ancestors
-	GetBlockHeaderInfo(context.Context, *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error)
-	// Fetches information about a specific mainchain block (and optionally,
-	// it's ancestors), regarding how it pertains to events happening on a
-	// specific sidechain.
-	GetBlockInfo(context.Context, *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error)
-	// Fetches BMM h* commitment for a specific mainchain block,
-	// and optionally, it's ancestors
-	GetBmmHStarCommitment(context.Context, *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error)
-	GetChainInfo(context.Context, *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error)
-	GetChainTip(context.Context, *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error)
-	GetCoinbasePSBT(context.Context, *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error)
-	GetCtip(context.Context, *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error)
-	// Fetches the BMM requests (M8) that the mempool holds for a mainchain
-	// block. A request whose transaction left the mempool is left out, so a
-	// replaced bid never appears.
-	GetSeenBmmRequests(context.Context, *connect.Request[v1.GetSeenBmmRequestsRequest]) (*connect.Response[v1.GetSeenBmmRequestsResponse], error)
-	GetSidechainProposals(context.Context, *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error)
-	GetSidechains(context.Context, *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error)
-	GetTwoWayPegData(context.Context, *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error)
-	GetWithdrawalBundleProposals(context.Context, *connect.Request[v1.GetWithdrawalBundleProposalsRequest]) (*connect.Response[v1.GetWithdrawalBundleProposalsResponse], error)
-	SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.SubscribeEventsResponse]) error
-	// Stream header sync progress updates
-	SubscribeHeaderSyncProgress(context.Context, *connect.Request[v1.SubscribeHeaderSyncProgressRequest], *connect.ServerStream[v1.SubscribeHeaderSyncProgressResponse]) error
-	// Safely shutdown the validator. This is equivalent to sending a SIGINT
-	// to the validator process, and can be used to trigger a graceful shutdown
-	// in cases where you don't have access to the validator process.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-}
-
-// NewValidatorServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewValidatorServiceHandler(svc ValidatorServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	validatorServiceMethods := v1.File_cusf_mainchain_v1_validator_proto.Services().ByName("ValidatorService").Methods()
-	validatorServiceGetBlockHeaderInfoHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetBlockHeaderInfoProcedure,
-		svc.GetBlockHeaderInfo,
-		connect.WithSchema(validatorServiceMethods.ByName("GetBlockHeaderInfo")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetBlockInfoHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetBlockInfoProcedure,
-		svc.GetBlockInfo,
-		connect.WithSchema(validatorServiceMethods.ByName("GetBlockInfo")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetBmmHStarCommitmentHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetBmmHStarCommitmentProcedure,
-		svc.GetBmmHStarCommitment,
-		connect.WithSchema(validatorServiceMethods.ByName("GetBmmHStarCommitment")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetChainInfoHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetChainInfoProcedure,
-		svc.GetChainInfo,
-		connect.WithSchema(validatorServiceMethods.ByName("GetChainInfo")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetChainTipHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetChainTipProcedure,
-		svc.GetChainTip,
-		connect.WithSchema(validatorServiceMethods.ByName("GetChainTip")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetCoinbasePSBTHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetCoinbasePSBTProcedure,
-		svc.GetCoinbasePSBT,
-		connect.WithSchema(validatorServiceMethods.ByName("GetCoinbasePSBT")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetCtipHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetCtipProcedure,
-		svc.GetCtip,
-		connect.WithSchema(validatorServiceMethods.ByName("GetCtip")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetSeenBmmRequestsHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetSeenBmmRequestsProcedure,
-		svc.GetSeenBmmRequests,
-		connect.WithSchema(validatorServiceMethods.ByName("GetSeenBmmRequests")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetSidechainProposalsHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetSidechainProposalsProcedure,
-		svc.GetSidechainProposals,
-		connect.WithSchema(validatorServiceMethods.ByName("GetSidechainProposals")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetSidechainsHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetSidechainsProcedure,
-		svc.GetSidechains,
-		connect.WithSchema(validatorServiceMethods.ByName("GetSidechains")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetTwoWayPegDataHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetTwoWayPegDataProcedure,
-		svc.GetTwoWayPegData,
-		connect.WithSchema(validatorServiceMethods.ByName("GetTwoWayPegData")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceGetWithdrawalBundleProposalsHandler := connect.NewUnaryHandler(
-		ValidatorServiceGetWithdrawalBundleProposalsProcedure,
-		svc.GetWithdrawalBundleProposals,
-		connect.WithSchema(validatorServiceMethods.ByName("GetWithdrawalBundleProposals")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceSubscribeEventsHandler := connect.NewServerStreamHandler(
-		ValidatorServiceSubscribeEventsProcedure,
-		svc.SubscribeEvents,
-		connect.WithSchema(validatorServiceMethods.ByName("SubscribeEvents")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceSubscribeHeaderSyncProgressHandler := connect.NewServerStreamHandler(
-		ValidatorServiceSubscribeHeaderSyncProgressProcedure,
-		svc.SubscribeHeaderSyncProgress,
-		connect.WithSchema(validatorServiceMethods.ByName("SubscribeHeaderSyncProgress")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	validatorServiceStopHandler := connect.NewUnaryHandler(
-		ValidatorServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(validatorServiceMethods.ByName("Stop")),
-		connect.WithIdempotency(connect.IdempotencyIdempotent),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.mainchain.v1.ValidatorService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ValidatorServiceGetBlockHeaderInfoProcedure:
-			validatorServiceGetBlockHeaderInfoHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetBlockInfoProcedure:
-			validatorServiceGetBlockInfoHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetBmmHStarCommitmentProcedure:
-			validatorServiceGetBmmHStarCommitmentHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetChainInfoProcedure:
-			validatorServiceGetChainInfoHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetChainTipProcedure:
-			validatorServiceGetChainTipHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetCoinbasePSBTProcedure:
-			validatorServiceGetCoinbasePSBTHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetCtipProcedure:
-			validatorServiceGetCtipHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetSeenBmmRequestsProcedure:
-			validatorServiceGetSeenBmmRequestsHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetSidechainProposalsProcedure:
-			validatorServiceGetSidechainProposalsHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetSidechainsProcedure:
-			validatorServiceGetSidechainsHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetTwoWayPegDataProcedure:
-			validatorServiceGetTwoWayPegDataHandler.ServeHTTP(w, r)
-		case ValidatorServiceGetWithdrawalBundleProposalsProcedure:
-			validatorServiceGetWithdrawalBundleProposalsHandler.ServeHTTP(w, r)
-		case ValidatorServiceSubscribeEventsProcedure:
-			validatorServiceSubscribeEventsHandler.ServeHTTP(w, r)
-		case ValidatorServiceSubscribeHeaderSyncProgressProcedure:
-			validatorServiceSubscribeHeaderSyncProgressHandler.ServeHTTP(w, r)
-		case ValidatorServiceStopProcedure:
-			validatorServiceStopHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedValidatorServiceHandler) GetChainTip(context.Context, *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetChainTip is not implemented")
 }
 
-// UnimplementedValidatorServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedValidatorServiceHandler struct{}
+func (UnimplementedValidatorServiceHandler) GetCoinbasePSBT(context.Context, *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetCoinbasePSBT is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetCtip(context.Context, *v1.GetCtipRequest) (*v1.GetCtipResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetCtip is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetSeenBmmRequests(context.Context, *v1.GetSeenBmmRequestsRequest) (*v1.GetSeenBmmRequestsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetSeenBmmRequests is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetSidechainProposals(context.Context, *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetSidechainProposals is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetSidechains(context.Context, *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetSidechains is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetTwoWayPegData(context.Context, *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetTwoWayPegData is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) GetWithdrawalBundleProposals(context.Context, *v1.GetWithdrawalBundleProposalsRequest) (*v1.GetWithdrawalBundleProposalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.GetWithdrawalBundleProposals is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) SubscribeEvents(context.Context, *v1.SubscribeEventsRequest, ValidatorServiceSubscribeEventsServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.SubscribeEvents is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) SubscribeHeaderSyncProgress(context.Context, *v1.SubscribeHeaderSyncProgressRequest, ValidatorServiceSubscribeHeaderSyncProgressServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.SubscribeHeaderSyncProgress is not implemented")
+}
+
+func (UnimplementedValidatorServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.mainchain.v1.ValidatorService.Stop is not implemented")
+}
+
+type validatorServiceClient struct {
+	client *connect.Client
+}
+
+func (c *validatorServiceClient) GetBlockHeaderInfo(ctx context.Context, req *v1.GetBlockHeaderInfoRequest) (*v1.GetBlockHeaderInfoResponse, error) {
+	var res v1.GetBlockHeaderInfoResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetBlockHeaderInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetBlockInfo(ctx context.Context, req *v1.GetBlockInfoRequest) (*v1.GetBlockInfoResponse, error) {
+	var res v1.GetBlockInfoResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetBlockInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetBmmHStarCommitment(ctx context.Context, req *v1.GetBmmHStarCommitmentRequest) (*v1.GetBmmHStarCommitmentResponse, error) {
+	var res v1.GetBmmHStarCommitmentResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetBmmHStarCommitmentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetChainInfo(ctx context.Context, req *v1.GetChainInfoRequest) (*v1.GetChainInfoResponse, error) {
+	var res v1.GetChainInfoResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetChainInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetChainTip(ctx context.Context, req *v1.GetChainTipRequest) (*v1.GetChainTipResponse, error) {
+	var res v1.GetChainTipResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetChainTipSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetCoinbasePSBT(ctx context.Context, req *v1.GetCoinbasePSBTRequest) (*v1.GetCoinbasePSBTResponse, error) {
+	var res v1.GetCoinbasePSBTResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetCoinbasePSBTSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetCtip(ctx context.Context, req *v1.GetCtipRequest) (*v1.GetCtipResponse, error) {
+	var res v1.GetCtipResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetCtipSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetSeenBmmRequests(ctx context.Context, req *v1.GetSeenBmmRequestsRequest) (*v1.GetSeenBmmRequestsResponse, error) {
+	var res v1.GetSeenBmmRequestsResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetSeenBmmRequestsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetSidechainProposals(ctx context.Context, req *v1.GetSidechainProposalsRequest) (*v1.GetSidechainProposalsResponse, error) {
+	var res v1.GetSidechainProposalsResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetSidechainProposalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetSidechains(ctx context.Context, req *v1.GetSidechainsRequest) (*v1.GetSidechainsResponse, error) {
+	var res v1.GetSidechainsResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetSidechainsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *validatorServiceClient) GetTwoWayPegData(ctx context.Context, req *v1.GetTwoWayPegDataRequest) (*v1.GetTwoWayPegDataResponse, error) {
+	var res v1.GetTwoWayPegDataResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetTwoWayPegDataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedValidatorServiceHandler) GetBlockHeaderInfo(context.Context, *connect.Request[v1.GetBlockHeaderInfoRequest]) (*connect.Response[v1.GetBlockHeaderInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetBlockHeaderInfo is not implemented"))
+func (c *validatorServiceClient) GetWithdrawalBundleProposals(ctx context.Context, req *v1.GetWithdrawalBundleProposalsRequest) (*v1.GetWithdrawalBundleProposalsResponse, error) {
+	var res v1.GetWithdrawalBundleProposalsResponse
+	if err := c.client.CallUnary(ctx, validatorServiceGetWithdrawalBundleProposalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetBlockInfo(context.Context, *connect.Request[v1.GetBlockInfoRequest]) (*connect.Response[v1.GetBlockInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetBlockInfo is not implemented"))
+func (c *validatorServiceClient) SubscribeEvents(ctx context.Context, req *v1.SubscribeEventsRequest) (ValidatorServiceSubscribeEventsClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, validatorServiceSubscribeEventsSpec(), req)
+	if err != nil {
+		return ValidatorServiceSubscribeEventsClientStream{}, err
+	}
+	return ValidatorServiceSubscribeEventsClientStream{stream: stream}, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetBmmHStarCommitment(context.Context, *connect.Request[v1.GetBmmHStarCommitmentRequest]) (*connect.Response[v1.GetBmmHStarCommitmentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetBmmHStarCommitment is not implemented"))
+func (c *validatorServiceClient) SubscribeHeaderSyncProgress(ctx context.Context, req *v1.SubscribeHeaderSyncProgressRequest) (ValidatorServiceSubscribeHeaderSyncProgressClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, validatorServiceSubscribeHeaderSyncProgressSpec(), req)
+	if err != nil {
+		return ValidatorServiceSubscribeHeaderSyncProgressClientStream{}, err
+	}
+	return ValidatorServiceSubscribeHeaderSyncProgressClientStream{stream: stream}, nil
 }
 
-func (UnimplementedValidatorServiceHandler) GetChainInfo(context.Context, *connect.Request[v1.GetChainInfoRequest]) (*connect.Response[v1.GetChainInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetChainInfo is not implemented"))
+func (c *validatorServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, validatorServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type validatorServiceHandler struct{ svc ValidatorServiceHandler }
+
+func (h validatorServiceHandler) getBlockHeaderInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockHeaderInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockHeaderInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getBlockInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getBmmHStarCommitment(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmHStarCommitmentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmHStarCommitment(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h validatorServiceHandler) getChainInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetChainInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetChainInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetChainTip(context.Context, *connect.Request[v1.GetChainTipRequest]) (*connect.Response[v1.GetChainTipResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetChainTip is not implemented"))
+func (h validatorServiceHandler) getChainTip(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetChainTipRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetChainTip(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetCoinbasePSBT(context.Context, *connect.Request[v1.GetCoinbasePSBTRequest]) (*connect.Response[v1.GetCoinbasePSBTResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetCoinbasePSBT is not implemented"))
+func (h validatorServiceHandler) getCoinbasePSBT(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetCoinbasePSBTRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCoinbasePSBT(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetCtip(context.Context, *connect.Request[v1.GetCtipRequest]) (*connect.Response[v1.GetCtipResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetCtip is not implemented"))
+func (h validatorServiceHandler) getCtip(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetCtipRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCtip(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetSeenBmmRequests(context.Context, *connect.Request[v1.GetSeenBmmRequestsRequest]) (*connect.Response[v1.GetSeenBmmRequestsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetSeenBmmRequests is not implemented"))
+func (h validatorServiceHandler) getSeenBmmRequests(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSeenBmmRequestsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSeenBmmRequests(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetSidechainProposals(context.Context, *connect.Request[v1.GetSidechainProposalsRequest]) (*connect.Response[v1.GetSidechainProposalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetSidechainProposals is not implemented"))
+func (h validatorServiceHandler) getSidechainProposals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainProposalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainProposals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetSidechains(context.Context, *connect.Request[v1.GetSidechainsRequest]) (*connect.Response[v1.GetSidechainsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetSidechains is not implemented"))
+func (h validatorServiceHandler) getSidechains(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechains(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetTwoWayPegData(context.Context, *connect.Request[v1.GetTwoWayPegDataRequest]) (*connect.Response[v1.GetTwoWayPegDataResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetTwoWayPegData is not implemented"))
+func (h validatorServiceHandler) getTwoWayPegData(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTwoWayPegDataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTwoWayPegData(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) GetWithdrawalBundleProposals(context.Context, *connect.Request[v1.GetWithdrawalBundleProposalsRequest]) (*connect.Response[v1.GetWithdrawalBundleProposalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.GetWithdrawalBundleProposals is not implemented"))
+func (h validatorServiceHandler) getWithdrawalBundleProposals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWithdrawalBundleProposalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWithdrawalBundleProposals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedValidatorServiceHandler) SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.SubscribeEventsResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.SubscribeEvents is not implemented"))
+func (h validatorServiceHandler) subscribeEvents(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubscribeEventsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.SubscribeEvents(ctx, &req, ValidatorServiceSubscribeEventsServerStream{stream: stream})
 }
 
-func (UnimplementedValidatorServiceHandler) SubscribeHeaderSyncProgress(context.Context, *connect.Request[v1.SubscribeHeaderSyncProgressRequest], *connect.ServerStream[v1.SubscribeHeaderSyncProgressResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.SubscribeHeaderSyncProgress is not implemented"))
+func (h validatorServiceHandler) subscribeHeaderSyncProgress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubscribeHeaderSyncProgressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.SubscribeHeaderSyncProgress(ctx, &req, ValidatorServiceSubscribeHeaderSyncProgressServerStream{stream: stream})
 }
 
-func (UnimplementedValidatorServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.mainchain.v1.ValidatorService.Stop is not implemented"))
+func (h validatorServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/cusf/sidechain/v1/sidechainv1connect/sidechain.connect.go b/sidechain-orchestrator/gen/cusf/sidechain/v1/sidechainv1connect/sidechain.connect.go
index 9197ea84e7..f8f5b18bcb 100644
--- a/sidechain-orchestrator/gen/cusf/sidechain/v1/sidechainv1connect/sidechain.connect.go
+++ b/sidechain-orchestrator/gen/cusf/sidechain/v1/sidechainv1connect/sidechain.connect.go
@@ -1,5 +1,3 @@
-// CUSF sidechain node service
-
 // Code generated by protoc-gen-connect-go. DO NOT EDIT.
 //
 // Source: cusf/sidechain/v1/sidechain.proto
@@ -7,200 +5,241 @@
 package sidechainv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/sidechain/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// SidechainServiceName is the fully-qualified name of the SidechainService service.
 	SidechainServiceName = "cusf.sidechain.v1.SidechainService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// SidechainServiceGetMempoolTxsProcedure is the fully-qualified name of the SidechainService's
+	// SidechainServiceGetMempoolTxsProcedure is the procedure name of the SidechainService's
 	// GetMempoolTxs RPC.
 	SidechainServiceGetMempoolTxsProcedure = "/cusf.sidechain.v1.SidechainService/GetMempoolTxs"
-	// SidechainServiceGetUtxosProcedure is the fully-qualified name of the SidechainService's GetUtxos
-	// RPC.
+	// SidechainServiceGetUtxosProcedure is the procedure name of the SidechainService's GetUtxos RPC.
 	SidechainServiceGetUtxosProcedure = "/cusf.sidechain.v1.SidechainService/GetUtxos"
-	// SidechainServiceSubmitTransactionProcedure is the fully-qualified name of the SidechainService's
+	// SidechainServiceSubmitTransactionProcedure is the procedure name of the SidechainService's
 	// SubmitTransaction RPC.
 	SidechainServiceSubmitTransactionProcedure = "/cusf.sidechain.v1.SidechainService/SubmitTransaction"
-	// SidechainServiceSubscribeEventsProcedure is the fully-qualified name of the SidechainService's
+	// SidechainServiceSubscribeEventsProcedure is the procedure name of the SidechainService's
 	// SubscribeEvents RPC.
 	SidechainServiceSubscribeEventsProcedure = "/cusf.sidechain.v1.SidechainService/SubscribeEvents"
 )
 
+var (
+	sidechainServiceGetMempoolTxsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods().ByName("GetMempoolTxs"),
+			Procedure:        SidechainServiceGetMempoolTxsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	sidechainServiceGetUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods().ByName("GetUtxos"),
+			Procedure:        SidechainServiceGetUtxosProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+	sidechainServiceSubmitTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeUnary,
+			Schema:           v1.File_cusf_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods().ByName("SubmitTransaction"),
+			Procedure:        SidechainServiceSubmitTransactionProcedure,
+			IdempotencyLevel: connect.IdempotencyIdempotent,
+		}
+	})
+	sidechainServiceSubscribeEventsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType:       connect.StreamTypeServer,
+			Schema:           v1.File_cusf_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods().ByName("SubscribeEvents"),
+			Procedure:        SidechainServiceSubscribeEventsProcedure,
+			IdempotencyLevel: connect.IdempotencyNoSideEffects,
+		}
+	})
+)
+
 // SidechainServiceClient is a client for the cusf.sidechain.v1.SidechainService service.
 type SidechainServiceClient interface {
-	GetMempoolTxs(context.Context, *connect.Request[v1.GetMempoolTxsRequest]) (*connect.Response[v1.GetMempoolTxsResponse], error)
-	GetUtxos(context.Context, *connect.Request[v1.GetUtxosRequest]) (*connect.Response[v1.GetUtxosResponse], error)
-	SubmitTransaction(context.Context, *connect.Request[v1.SubmitTransactionRequest]) (*connect.Response[v1.SubmitTransactionResponse], error)
-	SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.SubscribeEventsResponse], error)
+	GetMempoolTxs(context.Context, *v1.GetMempoolTxsRequest) (*v1.GetMempoolTxsResponse, error)
+	GetUtxos(context.Context, *v1.GetUtxosRequest) (*v1.GetUtxosResponse, error)
+	SubmitTransaction(context.Context, *v1.SubmitTransactionRequest) (*v1.SubmitTransactionResponse, error)
+	SubscribeEvents(context.Context, *v1.SubscribeEventsRequest) (SidechainServiceSubscribeEventsClientStream, error)
 }
 
 // NewSidechainServiceClient constructs a client for the cusf.sidechain.v1.SidechainService service.
-// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped
-// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewSidechainServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) SidechainServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	sidechainServiceMethods := v1.File_cusf_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods()
-	return &sidechainServiceClient{
-		getMempoolTxs: connect.NewClient[v1.GetMempoolTxsRequest, v1.GetMempoolTxsResponse](
-			httpClient,
-			baseURL+SidechainServiceGetMempoolTxsProcedure,
-			connect.WithSchema(sidechainServiceMethods.ByName("GetMempoolTxs")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		getUtxos: connect.NewClient[v1.GetUtxosRequest, v1.GetUtxosResponse](
-			httpClient,
-			baseURL+SidechainServiceGetUtxosProcedure,
-			connect.WithSchema(sidechainServiceMethods.ByName("GetUtxos")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-		submitTransaction: connect.NewClient[v1.SubmitTransactionRequest, v1.SubmitTransactionResponse](
-			httpClient,
-			baseURL+SidechainServiceSubmitTransactionProcedure,
-			connect.WithSchema(sidechainServiceMethods.ByName("SubmitTransaction")),
-			connect.WithIdempotency(connect.IdempotencyIdempotent),
-			connect.WithClientOptions(opts...),
-		),
-		subscribeEvents: connect.NewClient[v1.SubscribeEventsRequest, v1.SubscribeEventsResponse](
-			httpClient,
-			baseURL+SidechainServiceSubscribeEventsProcedure,
-			connect.WithSchema(sidechainServiceMethods.ByName("SubscribeEvents")),
-			connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// Multiple service clients may share a single connect.Client.
+func NewSidechainServiceClient(client *connect.Client) SidechainServiceClient {
+	return &sidechainServiceClient{client: client}
 }
 
-// sidechainServiceClient implements SidechainServiceClient.
-type sidechainServiceClient struct {
-	getMempoolTxs     *connect.Client[v1.GetMempoolTxsRequest, v1.GetMempoolTxsResponse]
-	getUtxos          *connect.Client[v1.GetUtxosRequest, v1.GetUtxosResponse]
-	submitTransaction *connect.Client[v1.SubmitTransactionRequest, v1.SubmitTransactionResponse]
-	subscribeEvents   *connect.Client[v1.SubscribeEventsRequest, v1.SubscribeEventsResponse]
+// SidechainServiceSubscribeEventsClientStream is the client stream for the SidechainService's
+// SubscribeEvents RPC.
+type SidechainServiceSubscribeEventsClientStream struct {
+	stream connect.ClientStream
 }
 
-// GetMempoolTxs calls cusf.sidechain.v1.SidechainService.GetMempoolTxs.
-func (c *sidechainServiceClient) GetMempoolTxs(ctx context.Context, req *connect.Request[v1.GetMempoolTxsRequest]) (*connect.Response[v1.GetMempoolTxsResponse], error) {
-	return c.getMempoolTxs.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s SidechainServiceSubscribeEventsClientStream) Receive() (*v1.SubscribeEventsResponse, error) {
+	var res v1.SubscribeEventsResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// GetUtxos calls cusf.sidechain.v1.SidechainService.GetUtxos.
-func (c *sidechainServiceClient) GetUtxos(ctx context.Context, req *connect.Request[v1.GetUtxosRequest]) (*connect.Response[v1.GetUtxosResponse], error) {
-	return c.getUtxos.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s SidechainServiceSubscribeEventsClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// SubmitTransaction calls cusf.sidechain.v1.SidechainService.SubmitTransaction.
-func (c *sidechainServiceClient) SubmitTransaction(ctx context.Context, req *connect.Request[v1.SubmitTransactionRequest]) (*connect.Response[v1.SubmitTransactionResponse], error) {
-	return c.submitTransaction.CallUnary(ctx, req)
+// SidechainServiceHandler is an implementation of the cusf.sidechain.v1.SidechainService service.
+type SidechainServiceHandler interface {
+	GetMempoolTxs(context.Context, *v1.GetMempoolTxsRequest) (*v1.GetMempoolTxsResponse, error)
+	GetUtxos(context.Context, *v1.GetUtxosRequest) (*v1.GetUtxosResponse, error)
+	SubmitTransaction(context.Context, *v1.SubmitTransactionRequest) (*v1.SubmitTransactionResponse, error)
+	SubscribeEvents(context.Context, *v1.SubscribeEventsRequest, SidechainServiceSubscribeEventsServerStream) error
 }
 
-// SubscribeEvents calls cusf.sidechain.v1.SidechainService.SubscribeEvents.
-func (c *sidechainServiceClient) SubscribeEvents(ctx context.Context, req *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.SubscribeEventsResponse], error) {
-	return c.subscribeEvents.CallServerStream(ctx, req)
+// RegisterSidechainServiceHandler registers svc as the cusf.sidechain.v1.SidechainService
+// implementation on server.
+func RegisterSidechainServiceHandler(server *connect.Server, svc SidechainServiceHandler) {
+	adapter := sidechainServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: sidechainServiceGetMempoolTxsSpec(), Handler: adapter.getMempoolTxs},
+		connect.Method{Spec: sidechainServiceGetUtxosSpec(), Handler: adapter.getUtxos},
+		connect.Method{Spec: sidechainServiceSubmitTransactionSpec(), Handler: adapter.submitTransaction},
+		connect.Method{Spec: sidechainServiceSubscribeEventsSpec(), Handler: adapter.subscribeEvents},
+	)
 }
 
-// SidechainServiceHandler is an implementation of the cusf.sidechain.v1.SidechainService service.
-type SidechainServiceHandler interface {
-	GetMempoolTxs(context.Context, *connect.Request[v1.GetMempoolTxsRequest]) (*connect.Response[v1.GetMempoolTxsResponse], error)
-	GetUtxos(context.Context, *connect.Request[v1.GetUtxosRequest]) (*connect.Response[v1.GetUtxosResponse], error)
-	SubmitTransaction(context.Context, *connect.Request[v1.SubmitTransactionRequest]) (*connect.Response[v1.SubmitTransactionResponse], error)
-	SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.SubscribeEventsResponse]) error
+// SidechainServiceSubscribeEventsServerStream is the server stream for the SidechainService's
+// SubscribeEvents RPC.
+type SidechainServiceSubscribeEventsServerStream struct {
+	stream connect.ServerStream
 }
 
-// NewSidechainServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewSidechainServiceHandler(svc SidechainServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	sidechainServiceMethods := v1.File_cusf_sidechain_v1_sidechain_proto.Services().ByName("SidechainService").Methods()
-	sidechainServiceGetMempoolTxsHandler := connect.NewUnaryHandler(
-		SidechainServiceGetMempoolTxsProcedure,
-		svc.GetMempoolTxs,
-		connect.WithSchema(sidechainServiceMethods.ByName("GetMempoolTxs")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	sidechainServiceGetUtxosHandler := connect.NewUnaryHandler(
-		SidechainServiceGetUtxosProcedure,
-		svc.GetUtxos,
-		connect.WithSchema(sidechainServiceMethods.ByName("GetUtxos")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	sidechainServiceSubmitTransactionHandler := connect.NewUnaryHandler(
-		SidechainServiceSubmitTransactionProcedure,
-		svc.SubmitTransaction,
-		connect.WithSchema(sidechainServiceMethods.ByName("SubmitTransaction")),
-		connect.WithIdempotency(connect.IdempotencyIdempotent),
-		connect.WithHandlerOptions(opts...),
-	)
-	sidechainServiceSubscribeEventsHandler := connect.NewServerStreamHandler(
-		SidechainServiceSubscribeEventsProcedure,
-		svc.SubscribeEvents,
-		connect.WithSchema(sidechainServiceMethods.ByName("SubscribeEvents")),
-		connect.WithIdempotency(connect.IdempotencyNoSideEffects),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/cusf.sidechain.v1.SidechainService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case SidechainServiceGetMempoolTxsProcedure:
-			sidechainServiceGetMempoolTxsHandler.ServeHTTP(w, r)
-		case SidechainServiceGetUtxosProcedure:
-			sidechainServiceGetUtxosHandler.ServeHTTP(w, r)
-		case SidechainServiceSubmitTransactionProcedure:
-			sidechainServiceSubmitTransactionHandler.ServeHTTP(w, r)
-		case SidechainServiceSubscribeEventsProcedure:
-			sidechainServiceSubscribeEventsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s SidechainServiceSubscribeEventsServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
+}
+
+// Send sends a response message to the client.
+func (s SidechainServiceSubscribeEventsServerStream) Send(res *v1.SubscribeEventsResponse) error {
+	return s.stream.Send(res)
 }
 
 // UnimplementedSidechainServiceHandler returns CodeUnimplemented from all methods.
 type UnimplementedSidechainServiceHandler struct{}
 
-func (UnimplementedSidechainServiceHandler) GetMempoolTxs(context.Context, *connect.Request[v1.GetMempoolTxsRequest]) (*connect.Response[v1.GetMempoolTxsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.sidechain.v1.SidechainService.GetMempoolTxs is not implemented"))
+func (UnimplementedSidechainServiceHandler) GetMempoolTxs(context.Context, *v1.GetMempoolTxsRequest) (*v1.GetMempoolTxsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.sidechain.v1.SidechainService.GetMempoolTxs is not implemented")
 }
 
-func (UnimplementedSidechainServiceHandler) GetUtxos(context.Context, *connect.Request[v1.GetUtxosRequest]) (*connect.Response[v1.GetUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.sidechain.v1.SidechainService.GetUtxos is not implemented"))
+func (UnimplementedSidechainServiceHandler) GetUtxos(context.Context, *v1.GetUtxosRequest) (*v1.GetUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.sidechain.v1.SidechainService.GetUtxos is not implemented")
 }
 
-func (UnimplementedSidechainServiceHandler) SubmitTransaction(context.Context, *connect.Request[v1.SubmitTransactionRequest]) (*connect.Response[v1.SubmitTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("cusf.sidechain.v1.SidechainService.SubmitTransaction is not implemented"))
+func (UnimplementedSidechainServiceHandler) SubmitTransaction(context.Context, *v1.SubmitTransactionRequest) (*v1.SubmitTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "cusf.sidechain.v1.SidechainService.SubmitTransaction is not implemented")
 }
 
-func (UnimplementedSidechainServiceHandler) SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.SubscribeEventsResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("cusf.sidechain.v1.SidechainService.SubscribeEvents is not implemented"))
+func (UnimplementedSidechainServiceHandler) SubscribeEvents(context.Context, *v1.SubscribeEventsRequest, SidechainServiceSubscribeEventsServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "cusf.sidechain.v1.SidechainService.SubscribeEvents is not implemented")
+}
+
+type sidechainServiceClient struct {
+	client *connect.Client
+}
+
+func (c *sidechainServiceClient) GetMempoolTxs(ctx context.Context, req *v1.GetMempoolTxsRequest) (*v1.GetMempoolTxsResponse, error) {
+	var res v1.GetMempoolTxsResponse
+	if err := c.client.CallUnary(ctx, sidechainServiceGetMempoolTxsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *sidechainServiceClient) GetUtxos(ctx context.Context, req *v1.GetUtxosRequest) (*v1.GetUtxosResponse, error) {
+	var res v1.GetUtxosResponse
+	if err := c.client.CallUnary(ctx, sidechainServiceGetUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *sidechainServiceClient) SubmitTransaction(ctx context.Context, req *v1.SubmitTransactionRequest) (*v1.SubmitTransactionResponse, error) {
+	var res v1.SubmitTransactionResponse
+	if err := c.client.CallUnary(ctx, sidechainServiceSubmitTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *sidechainServiceClient) SubscribeEvents(ctx context.Context, req *v1.SubscribeEventsRequest) (SidechainServiceSubscribeEventsClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, sidechainServiceSubscribeEventsSpec(), req)
+	if err != nil {
+		return SidechainServiceSubscribeEventsClientStream{}, err
+	}
+	return SidechainServiceSubscribeEventsClientStream{stream: stream}, nil
+}
+
+type sidechainServiceHandler struct{ svc SidechainServiceHandler }
+
+func (h sidechainServiceHandler) getMempoolTxs(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetMempoolTxsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetMempoolTxs(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h sidechainServiceHandler) getUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h sidechainServiceHandler) submitTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubmitTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SubmitTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h sidechainServiceHandler) subscribeEvents(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SubscribeEventsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.SubscribeEvents(ctx, &req, SidechainServiceSubscribeEventsServerStream{stream: stream})
 }
diff --git a/sidechain-orchestrator/gen/explorer/v1/explorerv1connect/explorer.connect.go b/sidechain-orchestrator/gen/explorer/v1/explorerv1connect/explorer.connect.go
index 6d8ffe7e5c..ee1197b18c 100644
--- a/sidechain-orchestrator/gen/explorer/v1/explorerv1connect/explorer.connect.go
+++ b/sidechain-orchestrator/gen/explorer/v1/explorerv1connect/explorer.connect.go
@@ -5,363 +5,387 @@
 package explorerv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/explorer/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ExplorerServiceName is the fully-qualified name of the ExplorerService service.
 	ExplorerServiceName = "explorer.v1.ExplorerService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ExplorerServiceGetOverviewProcedure is the fully-qualified name of the ExplorerService's
-	// GetOverview RPC.
-	ExplorerServiceGetOverviewProcedure = "/explorer.v1.ExplorerService/GetOverview"
-	// ExplorerServiceGetBlockProcedure is the fully-qualified name of the ExplorerService's GetBlock
+	// ExplorerServiceGetOverviewProcedure is the procedure name of the ExplorerService's GetOverview
 	// RPC.
+	ExplorerServiceGetOverviewProcedure = "/explorer.v1.ExplorerService/GetOverview"
+	// ExplorerServiceGetBlockProcedure is the procedure name of the ExplorerService's GetBlock RPC.
 	ExplorerServiceGetBlockProcedure = "/explorer.v1.ExplorerService/GetBlock"
-	// ExplorerServiceListBlocksProcedure is the fully-qualified name of the ExplorerService's
-	// ListBlocks RPC.
+	// ExplorerServiceListBlocksProcedure is the procedure name of the ExplorerService's ListBlocks RPC.
 	ExplorerServiceListBlocksProcedure = "/explorer.v1.ExplorerService/ListBlocks"
-	// ExplorerServiceGetTransactionProcedure is the fully-qualified name of the ExplorerService's
+	// ExplorerServiceGetTransactionProcedure is the procedure name of the ExplorerService's
 	// GetTransaction RPC.
 	ExplorerServiceGetTransactionProcedure = "/explorer.v1.ExplorerService/GetTransaction"
-	// ExplorerServiceGetSignedTransactionProcedure is the fully-qualified name of the ExplorerService's
+	// ExplorerServiceGetSignedTransactionProcedure is the procedure name of the ExplorerService's
 	// GetSignedTransaction RPC.
 	ExplorerServiceGetSignedTransactionProcedure = "/explorer.v1.ExplorerService/GetSignedTransaction"
-	// ExplorerServiceRebroadcastTransactionProcedure is the fully-qualified name of the
-	// ExplorerService's RebroadcastTransaction RPC.
+	// ExplorerServiceRebroadcastTransactionProcedure is the procedure name of the ExplorerService's
+	// RebroadcastTransaction RPC.
 	ExplorerServiceRebroadcastTransactionProcedure = "/explorer.v1.ExplorerService/RebroadcastTransaction"
-	// ExplorerServiceBroadcastTransactionProcedure is the fully-qualified name of the ExplorerService's
+	// ExplorerServiceBroadcastTransactionProcedure is the procedure name of the ExplorerService's
 	// BroadcastTransaction RPC.
 	ExplorerServiceBroadcastTransactionProcedure = "/explorer.v1.ExplorerService/BroadcastTransaction"
-	// ExplorerServiceGetAddressProcedure is the fully-qualified name of the ExplorerService's
-	// GetAddress RPC.
+	// ExplorerServiceGetAddressProcedure is the procedure name of the ExplorerService's GetAddress RPC.
 	ExplorerServiceGetAddressProcedure = "/explorer.v1.ExplorerService/GetAddress"
-	// ExplorerServiceGetWithdrawalsProcedure is the fully-qualified name of the ExplorerService's
+	// ExplorerServiceGetWithdrawalsProcedure is the procedure name of the ExplorerService's
 	// GetWithdrawals RPC.
 	ExplorerServiceGetWithdrawalsProcedure = "/explorer.v1.ExplorerService/GetWithdrawals"
 )
 
+var (
+	explorerServiceGetOverviewSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("GetOverview"),
+			Procedure:  ExplorerServiceGetOverviewProcedure,
+		}
+	})
+	explorerServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("GetBlock"),
+			Procedure:  ExplorerServiceGetBlockProcedure,
+		}
+	})
+	explorerServiceListBlocksSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("ListBlocks"),
+			Procedure:  ExplorerServiceListBlocksProcedure,
+		}
+	})
+	explorerServiceGetTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("GetTransaction"),
+			Procedure:  ExplorerServiceGetTransactionProcedure,
+		}
+	})
+	explorerServiceGetSignedTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("GetSignedTransaction"),
+			Procedure:  ExplorerServiceGetSignedTransactionProcedure,
+		}
+	})
+	explorerServiceRebroadcastTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("RebroadcastTransaction"),
+			Procedure:  ExplorerServiceRebroadcastTransactionProcedure,
+		}
+	})
+	explorerServiceBroadcastTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("BroadcastTransaction"),
+			Procedure:  ExplorerServiceBroadcastTransactionProcedure,
+		}
+	})
+	explorerServiceGetAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("GetAddress"),
+			Procedure:  ExplorerServiceGetAddressProcedure,
+		}
+	})
+	explorerServiceGetWithdrawalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods().ByName("GetWithdrawals"),
+			Procedure:  ExplorerServiceGetWithdrawalsProcedure,
+		}
+	})
+)
+
 // ExplorerServiceClient is a client for the explorer.v1.ExplorerService service.
 type ExplorerServiceClient interface {
-	// GetOverview answers the explorer landing page: the newest blocks, what
-	// happened last, and what the treasury holds.
-	GetOverview(context.Context, *connect.Request[v1.GetOverviewRequest]) (*connect.Response[v1.GetOverviewResponse], error)
-	// GetBlock reads one block and what it carried. The request names either a
-	// hash or a height.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// ListBlocks reads a page of block headers, newest first, so a reader can
-	// walk back to the genesis block.
-	ListBlocks(context.Context, *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error)
-	// GetTransaction reads one transaction, with the coins on both sides.
-	GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error)
-	// GetSignedTransaction exports a transaction with its stored signatures.
-	GetSignedTransaction(context.Context, *connect.Request[v1.GetSignedTransactionRequest]) (*connect.Response[v1.GetSignedTransactionResponse], error)
-	// RebroadcastTransaction sends a pending transaction to connected peers.
-	RebroadcastTransaction(context.Context, *connect.Request[v1.RebroadcastTransactionRequest]) (*connect.Response[v1.RebroadcastTransactionResponse], error)
-	// BroadcastTransaction submits a signed transaction to the sidechain node.
-	BroadcastTransaction(context.Context, *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error)
-	// GetAddress reads what an address holds and what it did. It needs an index,
-	// because no sidechain node keeps an address history.
-	GetAddress(context.Context, *connect.Request[v1.GetAddressRequest]) (*connect.Response[v1.GetAddressResponse], error)
-	// GetWithdrawals reads the bundle the chain proposes to the mainchain.
-	GetWithdrawals(context.Context, *connect.Request[v1.GetWithdrawalsRequest]) (*connect.Response[v1.GetWithdrawalsResponse], error)
-}
-
-// NewExplorerServiceClient constructs a client for the explorer.v1.ExplorerService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewExplorerServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ExplorerServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	explorerServiceMethods := v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods()
-	return &explorerServiceClient{
-		getOverview: connect.NewClient[v1.GetOverviewRequest, v1.GetOverviewResponse](
-			httpClient,
-			baseURL+ExplorerServiceGetOverviewProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("GetOverview")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+ExplorerServiceGetBlockProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		listBlocks: connect.NewClient[v1.ListBlocksRequest, v1.ListBlocksResponse](
-			httpClient,
-			baseURL+ExplorerServiceListBlocksProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("ListBlocks")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransaction: connect.NewClient[v1.GetTransactionRequest, v1.GetTransactionResponse](
-			httpClient,
-			baseURL+ExplorerServiceGetTransactionProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("GetTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		getSignedTransaction: connect.NewClient[v1.GetSignedTransactionRequest, v1.GetSignedTransactionResponse](
-			httpClient,
-			baseURL+ExplorerServiceGetSignedTransactionProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("GetSignedTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		rebroadcastTransaction: connect.NewClient[v1.RebroadcastTransactionRequest, v1.RebroadcastTransactionResponse](
-			httpClient,
-			baseURL+ExplorerServiceRebroadcastTransactionProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("RebroadcastTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		broadcastTransaction: connect.NewClient[v1.BroadcastTransactionRequest, v1.BroadcastTransactionResponse](
-			httpClient,
-			baseURL+ExplorerServiceBroadcastTransactionProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("BroadcastTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		getAddress: connect.NewClient[v1.GetAddressRequest, v1.GetAddressResponse](
-			httpClient,
-			baseURL+ExplorerServiceGetAddressProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("GetAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		getWithdrawals: connect.NewClient[v1.GetWithdrawalsRequest, v1.GetWithdrawalsResponse](
-			httpClient,
-			baseURL+ExplorerServiceGetWithdrawalsProcedure,
-			connect.WithSchema(explorerServiceMethods.ByName("GetWithdrawals")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+	GetOverview(context.Context, *v1.GetOverviewRequest) (*v1.GetOverviewResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	ListBlocks(context.Context, *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error)
+	GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error)
+	GetSignedTransaction(context.Context, *v1.GetSignedTransactionRequest) (*v1.GetSignedTransactionResponse, error)
+	RebroadcastTransaction(context.Context, *v1.RebroadcastTransactionRequest) (*v1.RebroadcastTransactionResponse, error)
+	BroadcastTransaction(context.Context, *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error)
+	GetAddress(context.Context, *v1.GetAddressRequest) (*v1.GetAddressResponse, error)
+	GetWithdrawals(context.Context, *v1.GetWithdrawalsRequest) (*v1.GetWithdrawalsResponse, error)
 }
 
-// explorerServiceClient implements ExplorerServiceClient.
-type explorerServiceClient struct {
-	getOverview            *connect.Client[v1.GetOverviewRequest, v1.GetOverviewResponse]
-	getBlock               *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	listBlocks             *connect.Client[v1.ListBlocksRequest, v1.ListBlocksResponse]
-	getTransaction         *connect.Client[v1.GetTransactionRequest, v1.GetTransactionResponse]
-	getSignedTransaction   *connect.Client[v1.GetSignedTransactionRequest, v1.GetSignedTransactionResponse]
-	rebroadcastTransaction *connect.Client[v1.RebroadcastTransactionRequest, v1.RebroadcastTransactionResponse]
-	broadcastTransaction   *connect.Client[v1.BroadcastTransactionRequest, v1.BroadcastTransactionResponse]
-	getAddress             *connect.Client[v1.GetAddressRequest, v1.GetAddressResponse]
-	getWithdrawals         *connect.Client[v1.GetWithdrawalsRequest, v1.GetWithdrawalsResponse]
+// NewExplorerServiceClient constructs a client for the explorer.v1.ExplorerService service.
+// Multiple service clients may share a single connect.Client.
+func NewExplorerServiceClient(client *connect.Client) ExplorerServiceClient {
+	return &explorerServiceClient{client: client}
 }
 
-// GetOverview calls explorer.v1.ExplorerService.GetOverview.
-func (c *explorerServiceClient) GetOverview(ctx context.Context, req *connect.Request[v1.GetOverviewRequest]) (*connect.Response[v1.GetOverviewResponse], error) {
-	return c.getOverview.CallUnary(ctx, req)
+// ExplorerServiceHandler is an implementation of the explorer.v1.ExplorerService service.
+type ExplorerServiceHandler interface {
+	GetOverview(context.Context, *v1.GetOverviewRequest) (*v1.GetOverviewResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	ListBlocks(context.Context, *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error)
+	GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error)
+	GetSignedTransaction(context.Context, *v1.GetSignedTransactionRequest) (*v1.GetSignedTransactionResponse, error)
+	RebroadcastTransaction(context.Context, *v1.RebroadcastTransactionRequest) (*v1.RebroadcastTransactionResponse, error)
+	BroadcastTransaction(context.Context, *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error)
+	GetAddress(context.Context, *v1.GetAddressRequest) (*v1.GetAddressResponse, error)
+	GetWithdrawals(context.Context, *v1.GetWithdrawalsRequest) (*v1.GetWithdrawalsResponse, error)
 }
 
-// GetBlock calls explorer.v1.ExplorerService.GetBlock.
-func (c *explorerServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+// RegisterExplorerServiceHandler registers svc as the explorer.v1.ExplorerService implementation on
+// server.
+func RegisterExplorerServiceHandler(server *connect.Server, svc ExplorerServiceHandler) {
+	adapter := explorerServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: explorerServiceGetOverviewSpec(), Handler: adapter.getOverview},
+		connect.Method{Spec: explorerServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: explorerServiceListBlocksSpec(), Handler: adapter.listBlocks},
+		connect.Method{Spec: explorerServiceGetTransactionSpec(), Handler: adapter.getTransaction},
+		connect.Method{Spec: explorerServiceGetSignedTransactionSpec(), Handler: adapter.getSignedTransaction},
+		connect.Method{Spec: explorerServiceRebroadcastTransactionSpec(), Handler: adapter.rebroadcastTransaction},
+		connect.Method{Spec: explorerServiceBroadcastTransactionSpec(), Handler: adapter.broadcastTransaction},
+		connect.Method{Spec: explorerServiceGetAddressSpec(), Handler: adapter.getAddress},
+		connect.Method{Spec: explorerServiceGetWithdrawalsSpec(), Handler: adapter.getWithdrawals},
+	)
 }
 
-// ListBlocks calls explorer.v1.ExplorerService.ListBlocks.
-func (c *explorerServiceClient) ListBlocks(ctx context.Context, req *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error) {
-	return c.listBlocks.CallUnary(ctx, req)
+// UnimplementedExplorerServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedExplorerServiceHandler struct{}
+
+func (UnimplementedExplorerServiceHandler) GetOverview(context.Context, *v1.GetOverviewRequest) (*v1.GetOverviewResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.GetOverview is not implemented")
 }
 
-// GetTransaction calls explorer.v1.ExplorerService.GetTransaction.
-func (c *explorerServiceClient) GetTransaction(ctx context.Context, req *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error) {
-	return c.getTransaction.CallUnary(ctx, req)
+func (UnimplementedExplorerServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.GetBlock is not implemented")
 }
 
-// GetSignedTransaction calls explorer.v1.ExplorerService.GetSignedTransaction.
-func (c *explorerServiceClient) GetSignedTransaction(ctx context.Context, req *connect.Request[v1.GetSignedTransactionRequest]) (*connect.Response[v1.GetSignedTransactionResponse], error) {
-	return c.getSignedTransaction.CallUnary(ctx, req)
+func (UnimplementedExplorerServiceHandler) ListBlocks(context.Context, *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.ListBlocks is not implemented")
 }
 
-// RebroadcastTransaction calls explorer.v1.ExplorerService.RebroadcastTransaction.
-func (c *explorerServiceClient) RebroadcastTransaction(ctx context.Context, req *connect.Request[v1.RebroadcastTransactionRequest]) (*connect.Response[v1.RebroadcastTransactionResponse], error) {
-	return c.rebroadcastTransaction.CallUnary(ctx, req)
+func (UnimplementedExplorerServiceHandler) GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.GetTransaction is not implemented")
 }
 
-// BroadcastTransaction calls explorer.v1.ExplorerService.BroadcastTransaction.
-func (c *explorerServiceClient) BroadcastTransaction(ctx context.Context, req *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error) {
-	return c.broadcastTransaction.CallUnary(ctx, req)
+func (UnimplementedExplorerServiceHandler) GetSignedTransaction(context.Context, *v1.GetSignedTransactionRequest) (*v1.GetSignedTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.GetSignedTransaction is not implemented")
 }
 
-// GetAddress calls explorer.v1.ExplorerService.GetAddress.
-func (c *explorerServiceClient) GetAddress(ctx context.Context, req *connect.Request[v1.GetAddressRequest]) (*connect.Response[v1.GetAddressResponse], error) {
-	return c.getAddress.CallUnary(ctx, req)
+func (UnimplementedExplorerServiceHandler) RebroadcastTransaction(context.Context, *v1.RebroadcastTransactionRequest) (*v1.RebroadcastTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.RebroadcastTransaction is not implemented")
 }
 
-// GetWithdrawals calls explorer.v1.ExplorerService.GetWithdrawals.
-func (c *explorerServiceClient) GetWithdrawals(ctx context.Context, req *connect.Request[v1.GetWithdrawalsRequest]) (*connect.Response[v1.GetWithdrawalsResponse], error) {
-	return c.getWithdrawals.CallUnary(ctx, req)
+func (UnimplementedExplorerServiceHandler) BroadcastTransaction(context.Context, *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.BroadcastTransaction is not implemented")
 }
 
-// ExplorerServiceHandler is an implementation of the explorer.v1.ExplorerService service.
-type ExplorerServiceHandler interface {
-	// GetOverview answers the explorer landing page: the newest blocks, what
-	// happened last, and what the treasury holds.
-	GetOverview(context.Context, *connect.Request[v1.GetOverviewRequest]) (*connect.Response[v1.GetOverviewResponse], error)
-	// GetBlock reads one block and what it carried. The request names either a
-	// hash or a height.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// ListBlocks reads a page of block headers, newest first, so a reader can
-	// walk back to the genesis block.
-	ListBlocks(context.Context, *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error)
-	// GetTransaction reads one transaction, with the coins on both sides.
-	GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error)
-	// GetSignedTransaction exports a transaction with its stored signatures.
-	GetSignedTransaction(context.Context, *connect.Request[v1.GetSignedTransactionRequest]) (*connect.Response[v1.GetSignedTransactionResponse], error)
-	// RebroadcastTransaction sends a pending transaction to connected peers.
-	RebroadcastTransaction(context.Context, *connect.Request[v1.RebroadcastTransactionRequest]) (*connect.Response[v1.RebroadcastTransactionResponse], error)
-	// BroadcastTransaction submits a signed transaction to the sidechain node.
-	BroadcastTransaction(context.Context, *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error)
-	// GetAddress reads what an address holds and what it did. It needs an index,
-	// because no sidechain node keeps an address history.
-	GetAddress(context.Context, *connect.Request[v1.GetAddressRequest]) (*connect.Response[v1.GetAddressResponse], error)
-	// GetWithdrawals reads the bundle the chain proposes to the mainchain.
-	GetWithdrawals(context.Context, *connect.Request[v1.GetWithdrawalsRequest]) (*connect.Response[v1.GetWithdrawalsResponse], error)
-}
-
-// NewExplorerServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewExplorerServiceHandler(svc ExplorerServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	explorerServiceMethods := v1.File_explorer_v1_explorer_proto.Services().ByName("ExplorerService").Methods()
-	explorerServiceGetOverviewHandler := connect.NewUnaryHandler(
-		ExplorerServiceGetOverviewProcedure,
-		svc.GetOverview,
-		connect.WithSchema(explorerServiceMethods.ByName("GetOverview")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceGetBlockHandler := connect.NewUnaryHandler(
-		ExplorerServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(explorerServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceListBlocksHandler := connect.NewUnaryHandler(
-		ExplorerServiceListBlocksProcedure,
-		svc.ListBlocks,
-		connect.WithSchema(explorerServiceMethods.ByName("ListBlocks")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceGetTransactionHandler := connect.NewUnaryHandler(
-		ExplorerServiceGetTransactionProcedure,
-		svc.GetTransaction,
-		connect.WithSchema(explorerServiceMethods.ByName("GetTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceGetSignedTransactionHandler := connect.NewUnaryHandler(
-		ExplorerServiceGetSignedTransactionProcedure,
-		svc.GetSignedTransaction,
-		connect.WithSchema(explorerServiceMethods.ByName("GetSignedTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceRebroadcastTransactionHandler := connect.NewUnaryHandler(
-		ExplorerServiceRebroadcastTransactionProcedure,
-		svc.RebroadcastTransaction,
-		connect.WithSchema(explorerServiceMethods.ByName("RebroadcastTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceBroadcastTransactionHandler := connect.NewUnaryHandler(
-		ExplorerServiceBroadcastTransactionProcedure,
-		svc.BroadcastTransaction,
-		connect.WithSchema(explorerServiceMethods.ByName("BroadcastTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceGetAddressHandler := connect.NewUnaryHandler(
-		ExplorerServiceGetAddressProcedure,
-		svc.GetAddress,
-		connect.WithSchema(explorerServiceMethods.ByName("GetAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	explorerServiceGetWithdrawalsHandler := connect.NewUnaryHandler(
-		ExplorerServiceGetWithdrawalsProcedure,
-		svc.GetWithdrawals,
-		connect.WithSchema(explorerServiceMethods.ByName("GetWithdrawals")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/explorer.v1.ExplorerService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ExplorerServiceGetOverviewProcedure:
-			explorerServiceGetOverviewHandler.ServeHTTP(w, r)
-		case ExplorerServiceGetBlockProcedure:
-			explorerServiceGetBlockHandler.ServeHTTP(w, r)
-		case ExplorerServiceListBlocksProcedure:
-			explorerServiceListBlocksHandler.ServeHTTP(w, r)
-		case ExplorerServiceGetTransactionProcedure:
-			explorerServiceGetTransactionHandler.ServeHTTP(w, r)
-		case ExplorerServiceGetSignedTransactionProcedure:
-			explorerServiceGetSignedTransactionHandler.ServeHTTP(w, r)
-		case ExplorerServiceRebroadcastTransactionProcedure:
-			explorerServiceRebroadcastTransactionHandler.ServeHTTP(w, r)
-		case ExplorerServiceBroadcastTransactionProcedure:
-			explorerServiceBroadcastTransactionHandler.ServeHTTP(w, r)
-		case ExplorerServiceGetAddressProcedure:
-			explorerServiceGetAddressHandler.ServeHTTP(w, r)
-		case ExplorerServiceGetWithdrawalsProcedure:
-			explorerServiceGetWithdrawalsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedExplorerServiceHandler) GetAddress(context.Context, *v1.GetAddressRequest) (*v1.GetAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.GetAddress is not implemented")
 }
 
-// UnimplementedExplorerServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedExplorerServiceHandler struct{}
+func (UnimplementedExplorerServiceHandler) GetWithdrawals(context.Context, *v1.GetWithdrawalsRequest) (*v1.GetWithdrawalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "explorer.v1.ExplorerService.GetWithdrawals is not implemented")
+}
 
-func (UnimplementedExplorerServiceHandler) GetOverview(context.Context, *connect.Request[v1.GetOverviewRequest]) (*connect.Response[v1.GetOverviewResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.GetOverview is not implemented"))
+type explorerServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedExplorerServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.GetBlock is not implemented"))
+func (c *explorerServiceClient) GetOverview(ctx context.Context, req *v1.GetOverviewRequest) (*v1.GetOverviewResponse, error) {
+	var res v1.GetOverviewResponse
+	if err := c.client.CallUnary(ctx, explorerServiceGetOverviewSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) ListBlocks(context.Context, *connect.Request[v1.ListBlocksRequest]) (*connect.Response[v1.ListBlocksResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.ListBlocks is not implemented"))
+func (c *explorerServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, explorerServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.GetTransaction is not implemented"))
+func (c *explorerServiceClient) ListBlocks(ctx context.Context, req *v1.ListBlocksRequest) (*v1.ListBlocksResponse, error) {
+	var res v1.ListBlocksResponse
+	if err := c.client.CallUnary(ctx, explorerServiceListBlocksSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) GetSignedTransaction(context.Context, *connect.Request[v1.GetSignedTransactionRequest]) (*connect.Response[v1.GetSignedTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.GetSignedTransaction is not implemented"))
+func (c *explorerServiceClient) GetTransaction(ctx context.Context, req *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error) {
+	var res v1.GetTransactionResponse
+	if err := c.client.CallUnary(ctx, explorerServiceGetTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) RebroadcastTransaction(context.Context, *connect.Request[v1.RebroadcastTransactionRequest]) (*connect.Response[v1.RebroadcastTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.RebroadcastTransaction is not implemented"))
+func (c *explorerServiceClient) GetSignedTransaction(ctx context.Context, req *v1.GetSignedTransactionRequest) (*v1.GetSignedTransactionResponse, error) {
+	var res v1.GetSignedTransactionResponse
+	if err := c.client.CallUnary(ctx, explorerServiceGetSignedTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) BroadcastTransaction(context.Context, *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.BroadcastTransaction is not implemented"))
+func (c *explorerServiceClient) RebroadcastTransaction(ctx context.Context, req *v1.RebroadcastTransactionRequest) (*v1.RebroadcastTransactionResponse, error) {
+	var res v1.RebroadcastTransactionResponse
+	if err := c.client.CallUnary(ctx, explorerServiceRebroadcastTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) GetAddress(context.Context, *connect.Request[v1.GetAddressRequest]) (*connect.Response[v1.GetAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.GetAddress is not implemented"))
+func (c *explorerServiceClient) BroadcastTransaction(ctx context.Context, req *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error) {
+	var res v1.BroadcastTransactionResponse
+	if err := c.client.CallUnary(ctx, explorerServiceBroadcastTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *explorerServiceClient) GetAddress(ctx context.Context, req *v1.GetAddressRequest) (*v1.GetAddressResponse, error) {
+	var res v1.GetAddressResponse
+	if err := c.client.CallUnary(ctx, explorerServiceGetAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedExplorerServiceHandler) GetWithdrawals(context.Context, *connect.Request[v1.GetWithdrawalsRequest]) (*connect.Response[v1.GetWithdrawalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("explorer.v1.ExplorerService.GetWithdrawals is not implemented"))
+func (c *explorerServiceClient) GetWithdrawals(ctx context.Context, req *v1.GetWithdrawalsRequest) (*v1.GetWithdrawalsResponse, error) {
+	var res v1.GetWithdrawalsResponse
+	if err := c.client.CallUnary(ctx, explorerServiceGetWithdrawalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type explorerServiceHandler struct{ svc ExplorerServiceHandler }
+
+func (h explorerServiceHandler) getOverview(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetOverviewRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetOverview(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) listBlocks(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListBlocksRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListBlocks(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) getTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) getSignedTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSignedTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSignedTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) rebroadcastTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RebroadcastTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RebroadcastTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) broadcastTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BroadcastTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BroadcastTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) getAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h explorerServiceHandler) getWithdrawals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWithdrawalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWithdrawals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/multisiglounge/v1/multisigloungev1connect/multisiglounge.connect.go b/sidechain-orchestrator/gen/multisiglounge/v1/multisigloungev1connect/multisiglounge.connect.go
index a22a511a72..73cc2961b4 100644
--- a/sidechain-orchestrator/gen/multisiglounge/v1/multisigloungev1connect/multisiglounge.connect.go
+++ b/sidechain-orchestrator/gen/multisiglounge/v1/multisigloungev1connect/multisiglounge.connect.go
@@ -5,382 +5,392 @@
 package multisigloungev1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/multisiglounge/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// MultisigLoungeServiceName is the fully-qualified name of the MultisigLoungeService service.
 	MultisigLoungeServiceName = "multisiglounge.v1.MultisigLoungeService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// MultisigLoungeServiceBuildDescriptorsProcedure is the fully-qualified name of the
+	// MultisigLoungeServiceBuildDescriptorsProcedure is the procedure name of the
 	// MultisigLoungeService's BuildDescriptors RPC.
 	MultisigLoungeServiceBuildDescriptorsProcedure = "/multisiglounge.v1.MultisigLoungeService/BuildDescriptors"
-	// MultisigLoungeServiceValidatePsbtProcedure is the fully-qualified name of the
-	// MultisigLoungeService's ValidatePsbt RPC.
+	// MultisigLoungeServiceValidatePsbtProcedure is the procedure name of the MultisigLoungeService's
+	// ValidatePsbt RPC.
 	MultisigLoungeServiceValidatePsbtProcedure = "/multisiglounge.v1.MultisigLoungeService/ValidatePsbt"
-	// MultisigLoungeServicePublishGroupProcedure is the fully-qualified name of the
-	// MultisigLoungeService's PublishGroup RPC.
+	// MultisigLoungeServicePublishGroupProcedure is the procedure name of the MultisigLoungeService's
+	// PublishGroup RPC.
 	MultisigLoungeServicePublishGroupProcedure = "/multisiglounge.v1.MultisigLoungeService/PublishGroup"
-	// MultisigLoungeServiceImportGroupFromTxidProcedure is the fully-qualified name of the
+	// MultisigLoungeServiceImportGroupFromTxidProcedure is the procedure name of the
 	// MultisigLoungeService's ImportGroupFromTxid RPC.
 	MultisigLoungeServiceImportGroupFromTxidProcedure = "/multisiglounge.v1.MultisigLoungeService/ImportGroupFromTxid"
-	// MultisigLoungeServiceSignTransactionProcedure is the fully-qualified name of the
+	// MultisigLoungeServiceSignTransactionProcedure is the procedure name of the
 	// MultisigLoungeService's SignTransaction RPC.
 	MultisigLoungeServiceSignTransactionProcedure = "/multisiglounge.v1.MultisigLoungeService/SignTransaction"
-	// MultisigLoungeServiceCombineAndBroadcastProcedure is the fully-qualified name of the
+	// MultisigLoungeServiceCombineAndBroadcastProcedure is the procedure name of the
 	// MultisigLoungeService's CombineAndBroadcast RPC.
 	MultisigLoungeServiceCombineAndBroadcastProcedure = "/multisiglounge.v1.MultisigLoungeService/CombineAndBroadcast"
-	// MultisigLoungeServiceSyncGroupProcedure is the fully-qualified name of the
-	// MultisigLoungeService's SyncGroup RPC.
+	// MultisigLoungeServiceSyncGroupProcedure is the procedure name of the MultisigLoungeService's
+	// SyncGroup RPC.
 	MultisigLoungeServiceSyncGroupProcedure = "/multisiglounge.v1.MultisigLoungeService/SyncGroup"
-	// MultisigLoungeServiceRestoreHistoryProcedure is the fully-qualified name of the
-	// MultisigLoungeService's RestoreHistory RPC.
+	// MultisigLoungeServiceRestoreHistoryProcedure is the procedure name of the MultisigLoungeService's
+	// RestoreHistory RPC.
 	MultisigLoungeServiceRestoreHistoryProcedure = "/multisiglounge.v1.MultisigLoungeService/RestoreHistory"
-	// MultisigLoungeServiceCreateSpendPsbtProcedure is the fully-qualified name of the
+	// MultisigLoungeServiceCreateSpendPsbtProcedure is the procedure name of the
 	// MultisigLoungeService's CreateSpendPsbt RPC.
 	MultisigLoungeServiceCreateSpendPsbtProcedure = "/multisiglounge.v1.MultisigLoungeService/CreateSpendPsbt"
 )
 
+var (
+	multisigLoungeServiceBuildDescriptorsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("BuildDescriptors"),
+			Procedure:  MultisigLoungeServiceBuildDescriptorsProcedure,
+		}
+	})
+	multisigLoungeServiceValidatePsbtSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("ValidatePsbt"),
+			Procedure:  MultisigLoungeServiceValidatePsbtProcedure,
+		}
+	})
+	multisigLoungeServicePublishGroupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("PublishGroup"),
+			Procedure:  MultisigLoungeServicePublishGroupProcedure,
+		}
+	})
+	multisigLoungeServiceImportGroupFromTxidSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("ImportGroupFromTxid"),
+			Procedure:  MultisigLoungeServiceImportGroupFromTxidProcedure,
+		}
+	})
+	multisigLoungeServiceSignTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("SignTransaction"),
+			Procedure:  MultisigLoungeServiceSignTransactionProcedure,
+		}
+	})
+	multisigLoungeServiceCombineAndBroadcastSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("CombineAndBroadcast"),
+			Procedure:  MultisigLoungeServiceCombineAndBroadcastProcedure,
+		}
+	})
+	multisigLoungeServiceSyncGroupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("SyncGroup"),
+			Procedure:  MultisigLoungeServiceSyncGroupProcedure,
+		}
+	})
+	multisigLoungeServiceRestoreHistorySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("RestoreHistory"),
+			Procedure:  MultisigLoungeServiceRestoreHistoryProcedure,
+		}
+	})
+	multisigLoungeServiceCreateSpendPsbtSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods().ByName("CreateSpendPsbt"),
+			Procedure:  MultisigLoungeServiceCreateSpendPsbtProcedure,
+		}
+	})
+)
+
 // MultisigLoungeServiceClient is a client for the multisiglounge.v1.MultisigLoungeService service.
 type MultisigLoungeServiceClient interface {
-	// BuildDescriptors builds the receive (/0/*) and change (/1/*) watch-only
-	// wsh(sortedmulti) descriptors for a multisig group, with checksums.
-	BuildDescriptors(context.Context, *connect.Request[v1.BuildDescriptorsRequest]) (*connect.Response[v1.BuildDescriptorsResponse], error)
-	// ValidatePsbt parses a base64 PSBT and reports signature progress. When a
-	// group is supplied, inputs whose script does not belong to the group's
-	// descriptor are rejected.
-	ValidatePsbt(context.Context, *connect.Request[v1.ValidatePsbtRequest]) (*connect.Response[v1.ValidatePsbtResponse], error)
-	// PublishGroup encodes a multisig group as an OP_RETURN payload (the
-	// BitWindow wire format) and broadcasts it, funding a fresh own address.
-	// Returns the broadcast txid.
-	PublishGroup(context.Context, *connect.Request[v1.PublishGroupRequest]) (*connect.Response[v1.PublishGroupResponse], error)
-	// ImportGroupFromTxid fetches the OP_RETURN at the given txid, decodes the
-	// multisig group, and reports which of the group's keys belong to the wallet.
-	ImportGroupFromTxid(context.Context, *connect.Request[v1.ImportGroupFromTxidRequest]) (*connect.Response[v1.ImportGroupFromTxidResponse], error)
-	// SignTransaction adds the wallet's signature(s) to a multisig PSBT,
-	// deriving the wallet's keys server-side from its seed. The PSBT must belong
-	// to the group (foreign inputs are rejected).
-	SignTransaction(context.Context, *connect.Request[v1.SignTransactionRequest]) (*connect.Response[v1.SignTransactionResponse], error)
-	// CombineAndBroadcast merges partial PSBTs, finalizes, and broadcasts — but
-	// only if the combined PSBT reaches the threshold. A non-finalizable PSBT is
-	// never broadcast.
-	CombineAndBroadcast(context.Context, *connect.Request[v1.CombineAndBroadcastRequest]) (*connect.Response[v1.CombineAndBroadcastResponse], error)
-	// SyncGroup ensures the group's watch-only wallet exists (creating it from the
-	// Phase-1 descriptors if missing) and returns its balance and UTXOs.
-	SyncGroup(context.Context, *connect.Request[v1.SyncGroupRequest]) (*connect.Response[v1.SyncGroupResponse], error)
-	// RestoreHistory scans the watch-only wallet's transactions and reconstructs
-	// the group's spend/receive records with per-tx signature counts and status.
-	RestoreHistory(context.Context, *connect.Request[v1.RestoreHistoryRequest]) (*connect.Response[v1.RestoreHistoryResponse], error)
-	// CreateSpendPsbt builds an unsigned funded PSBT spending from the group's
-	// watch-only wallet to the given destinations (ensuring the wallet exists).
-	CreateSpendPsbt(context.Context, *connect.Request[v1.CreateSpendPsbtRequest]) (*connect.Response[v1.CreateSpendPsbtResponse], error)
+	BuildDescriptors(context.Context, *v1.BuildDescriptorsRequest) (*v1.BuildDescriptorsResponse, error)
+	ValidatePsbt(context.Context, *v1.ValidatePsbtRequest) (*v1.ValidatePsbtResponse, error)
+	PublishGroup(context.Context, *v1.PublishGroupRequest) (*v1.PublishGroupResponse, error)
+	ImportGroupFromTxid(context.Context, *v1.ImportGroupFromTxidRequest) (*v1.ImportGroupFromTxidResponse, error)
+	SignTransaction(context.Context, *v1.SignTransactionRequest) (*v1.SignTransactionResponse, error)
+	CombineAndBroadcast(context.Context, *v1.CombineAndBroadcastRequest) (*v1.CombineAndBroadcastResponse, error)
+	SyncGroup(context.Context, *v1.SyncGroupRequest) (*v1.SyncGroupResponse, error)
+	RestoreHistory(context.Context, *v1.RestoreHistoryRequest) (*v1.RestoreHistoryResponse, error)
+	CreateSpendPsbt(context.Context, *v1.CreateSpendPsbtRequest) (*v1.CreateSpendPsbtResponse, error)
 }
 
 // NewMultisigLoungeServiceClient constructs a client for the
-// multisiglounge.v1.MultisigLoungeService service. By default, it uses the Connect protocol with
-// the binary Protobuf Codec, asks for gzipped responses, and sends uncompressed requests. To use
-// the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewMultisigLoungeServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) MultisigLoungeServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	multisigLoungeServiceMethods := v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods()
-	return &multisigLoungeServiceClient{
-		buildDescriptors: connect.NewClient[v1.BuildDescriptorsRequest, v1.BuildDescriptorsResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceBuildDescriptorsProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("BuildDescriptors")),
-			connect.WithClientOptions(opts...),
-		),
-		validatePsbt: connect.NewClient[v1.ValidatePsbtRequest, v1.ValidatePsbtResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceValidatePsbtProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("ValidatePsbt")),
-			connect.WithClientOptions(opts...),
-		),
-		publishGroup: connect.NewClient[v1.PublishGroupRequest, v1.PublishGroupResponse](
-			httpClient,
-			baseURL+MultisigLoungeServicePublishGroupProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("PublishGroup")),
-			connect.WithClientOptions(opts...),
-		),
-		importGroupFromTxid: connect.NewClient[v1.ImportGroupFromTxidRequest, v1.ImportGroupFromTxidResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceImportGroupFromTxidProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("ImportGroupFromTxid")),
-			connect.WithClientOptions(opts...),
-		),
-		signTransaction: connect.NewClient[v1.SignTransactionRequest, v1.SignTransactionResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceSignTransactionProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("SignTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		combineAndBroadcast: connect.NewClient[v1.CombineAndBroadcastRequest, v1.CombineAndBroadcastResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceCombineAndBroadcastProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("CombineAndBroadcast")),
-			connect.WithClientOptions(opts...),
-		),
-		syncGroup: connect.NewClient[v1.SyncGroupRequest, v1.SyncGroupResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceSyncGroupProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("SyncGroup")),
-			connect.WithClientOptions(opts...),
-		),
-		restoreHistory: connect.NewClient[v1.RestoreHistoryRequest, v1.RestoreHistoryResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceRestoreHistoryProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("RestoreHistory")),
-			connect.WithClientOptions(opts...),
-		),
-		createSpendPsbt: connect.NewClient[v1.CreateSpendPsbtRequest, v1.CreateSpendPsbtResponse](
-			httpClient,
-			baseURL+MultisigLoungeServiceCreateSpendPsbtProcedure,
-			connect.WithSchema(multisigLoungeServiceMethods.ByName("CreateSpendPsbt")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// multisiglounge.v1.MultisigLoungeService service. Multiple service clients may share a single
+// connect.Client.
+func NewMultisigLoungeServiceClient(client *connect.Client) MultisigLoungeServiceClient {
+	return &multisigLoungeServiceClient{client: client}
 }
 
-// multisigLoungeServiceClient implements MultisigLoungeServiceClient.
-type multisigLoungeServiceClient struct {
-	buildDescriptors    *connect.Client[v1.BuildDescriptorsRequest, v1.BuildDescriptorsResponse]
-	validatePsbt        *connect.Client[v1.ValidatePsbtRequest, v1.ValidatePsbtResponse]
-	publishGroup        *connect.Client[v1.PublishGroupRequest, v1.PublishGroupResponse]
-	importGroupFromTxid *connect.Client[v1.ImportGroupFromTxidRequest, v1.ImportGroupFromTxidResponse]
-	signTransaction     *connect.Client[v1.SignTransactionRequest, v1.SignTransactionResponse]
-	combineAndBroadcast *connect.Client[v1.CombineAndBroadcastRequest, v1.CombineAndBroadcastResponse]
-	syncGroup           *connect.Client[v1.SyncGroupRequest, v1.SyncGroupResponse]
-	restoreHistory      *connect.Client[v1.RestoreHistoryRequest, v1.RestoreHistoryResponse]
-	createSpendPsbt     *connect.Client[v1.CreateSpendPsbtRequest, v1.CreateSpendPsbtResponse]
+// MultisigLoungeServiceHandler is an implementation of the multisiglounge.v1.MultisigLoungeService
+// service.
+type MultisigLoungeServiceHandler interface {
+	BuildDescriptors(context.Context, *v1.BuildDescriptorsRequest) (*v1.BuildDescriptorsResponse, error)
+	ValidatePsbt(context.Context, *v1.ValidatePsbtRequest) (*v1.ValidatePsbtResponse, error)
+	PublishGroup(context.Context, *v1.PublishGroupRequest) (*v1.PublishGroupResponse, error)
+	ImportGroupFromTxid(context.Context, *v1.ImportGroupFromTxidRequest) (*v1.ImportGroupFromTxidResponse, error)
+	SignTransaction(context.Context, *v1.SignTransactionRequest) (*v1.SignTransactionResponse, error)
+	CombineAndBroadcast(context.Context, *v1.CombineAndBroadcastRequest) (*v1.CombineAndBroadcastResponse, error)
+	SyncGroup(context.Context, *v1.SyncGroupRequest) (*v1.SyncGroupResponse, error)
+	RestoreHistory(context.Context, *v1.RestoreHistoryRequest) (*v1.RestoreHistoryResponse, error)
+	CreateSpendPsbt(context.Context, *v1.CreateSpendPsbtRequest) (*v1.CreateSpendPsbtResponse, error)
 }
 
-// BuildDescriptors calls multisiglounge.v1.MultisigLoungeService.BuildDescriptors.
-func (c *multisigLoungeServiceClient) BuildDescriptors(ctx context.Context, req *connect.Request[v1.BuildDescriptorsRequest]) (*connect.Response[v1.BuildDescriptorsResponse], error) {
-	return c.buildDescriptors.CallUnary(ctx, req)
+// RegisterMultisigLoungeServiceHandler registers svc as the multisiglounge.v1.MultisigLoungeService
+// implementation on server.
+func RegisterMultisigLoungeServiceHandler(server *connect.Server, svc MultisigLoungeServiceHandler) {
+	adapter := multisigLoungeServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: multisigLoungeServiceBuildDescriptorsSpec(), Handler: adapter.buildDescriptors},
+		connect.Method{Spec: multisigLoungeServiceValidatePsbtSpec(), Handler: adapter.validatePsbt},
+		connect.Method{Spec: multisigLoungeServicePublishGroupSpec(), Handler: adapter.publishGroup},
+		connect.Method{Spec: multisigLoungeServiceImportGroupFromTxidSpec(), Handler: adapter.importGroupFromTxid},
+		connect.Method{Spec: multisigLoungeServiceSignTransactionSpec(), Handler: adapter.signTransaction},
+		connect.Method{Spec: multisigLoungeServiceCombineAndBroadcastSpec(), Handler: adapter.combineAndBroadcast},
+		connect.Method{Spec: multisigLoungeServiceSyncGroupSpec(), Handler: adapter.syncGroup},
+		connect.Method{Spec: multisigLoungeServiceRestoreHistorySpec(), Handler: adapter.restoreHistory},
+		connect.Method{Spec: multisigLoungeServiceCreateSpendPsbtSpec(), Handler: adapter.createSpendPsbt},
+	)
 }
 
-// ValidatePsbt calls multisiglounge.v1.MultisigLoungeService.ValidatePsbt.
-func (c *multisigLoungeServiceClient) ValidatePsbt(ctx context.Context, req *connect.Request[v1.ValidatePsbtRequest]) (*connect.Response[v1.ValidatePsbtResponse], error) {
-	return c.validatePsbt.CallUnary(ctx, req)
+// UnimplementedMultisigLoungeServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedMultisigLoungeServiceHandler struct{}
+
+func (UnimplementedMultisigLoungeServiceHandler) BuildDescriptors(context.Context, *v1.BuildDescriptorsRequest) (*v1.BuildDescriptorsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.BuildDescriptors is not implemented")
 }
 
-// PublishGroup calls multisiglounge.v1.MultisigLoungeService.PublishGroup.
-func (c *multisigLoungeServiceClient) PublishGroup(ctx context.Context, req *connect.Request[v1.PublishGroupRequest]) (*connect.Response[v1.PublishGroupResponse], error) {
-	return c.publishGroup.CallUnary(ctx, req)
+func (UnimplementedMultisigLoungeServiceHandler) ValidatePsbt(context.Context, *v1.ValidatePsbtRequest) (*v1.ValidatePsbtResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.ValidatePsbt is not implemented")
 }
 
-// ImportGroupFromTxid calls multisiglounge.v1.MultisigLoungeService.ImportGroupFromTxid.
-func (c *multisigLoungeServiceClient) ImportGroupFromTxid(ctx context.Context, req *connect.Request[v1.ImportGroupFromTxidRequest]) (*connect.Response[v1.ImportGroupFromTxidResponse], error) {
-	return c.importGroupFromTxid.CallUnary(ctx, req)
+func (UnimplementedMultisigLoungeServiceHandler) PublishGroup(context.Context, *v1.PublishGroupRequest) (*v1.PublishGroupResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.PublishGroup is not implemented")
 }
 
-// SignTransaction calls multisiglounge.v1.MultisigLoungeService.SignTransaction.
-func (c *multisigLoungeServiceClient) SignTransaction(ctx context.Context, req *connect.Request[v1.SignTransactionRequest]) (*connect.Response[v1.SignTransactionResponse], error) {
-	return c.signTransaction.CallUnary(ctx, req)
+func (UnimplementedMultisigLoungeServiceHandler) ImportGroupFromTxid(context.Context, *v1.ImportGroupFromTxidRequest) (*v1.ImportGroupFromTxidResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.ImportGroupFromTxid is not implemented")
 }
 
-// CombineAndBroadcast calls multisiglounge.v1.MultisigLoungeService.CombineAndBroadcast.
-func (c *multisigLoungeServiceClient) CombineAndBroadcast(ctx context.Context, req *connect.Request[v1.CombineAndBroadcastRequest]) (*connect.Response[v1.CombineAndBroadcastResponse], error) {
-	return c.combineAndBroadcast.CallUnary(ctx, req)
+func (UnimplementedMultisigLoungeServiceHandler) SignTransaction(context.Context, *v1.SignTransactionRequest) (*v1.SignTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.SignTransaction is not implemented")
 }
 
-// SyncGroup calls multisiglounge.v1.MultisigLoungeService.SyncGroup.
-func (c *multisigLoungeServiceClient) SyncGroup(ctx context.Context, req *connect.Request[v1.SyncGroupRequest]) (*connect.Response[v1.SyncGroupResponse], error) {
-	return c.syncGroup.CallUnary(ctx, req)
+func (UnimplementedMultisigLoungeServiceHandler) CombineAndBroadcast(context.Context, *v1.CombineAndBroadcastRequest) (*v1.CombineAndBroadcastResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.CombineAndBroadcast is not implemented")
 }
 
-// RestoreHistory calls multisiglounge.v1.MultisigLoungeService.RestoreHistory.
-func (c *multisigLoungeServiceClient) RestoreHistory(ctx context.Context, req *connect.Request[v1.RestoreHistoryRequest]) (*connect.Response[v1.RestoreHistoryResponse], error) {
-	return c.restoreHistory.CallUnary(ctx, req)
+func (UnimplementedMultisigLoungeServiceHandler) SyncGroup(context.Context, *v1.SyncGroupRequest) (*v1.SyncGroupResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.SyncGroup is not implemented")
 }
 
-// CreateSpendPsbt calls multisiglounge.v1.MultisigLoungeService.CreateSpendPsbt.
-func (c *multisigLoungeServiceClient) CreateSpendPsbt(ctx context.Context, req *connect.Request[v1.CreateSpendPsbtRequest]) (*connect.Response[v1.CreateSpendPsbtResponse], error) {
-	return c.createSpendPsbt.CallUnary(ctx, req)
+func (UnimplementedMultisigLoungeServiceHandler) RestoreHistory(context.Context, *v1.RestoreHistoryRequest) (*v1.RestoreHistoryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.RestoreHistory is not implemented")
 }
 
-// MultisigLoungeServiceHandler is an implementation of the multisiglounge.v1.MultisigLoungeService
-// service.
-type MultisigLoungeServiceHandler interface {
-	// BuildDescriptors builds the receive (/0/*) and change (/1/*) watch-only
-	// wsh(sortedmulti) descriptors for a multisig group, with checksums.
-	BuildDescriptors(context.Context, *connect.Request[v1.BuildDescriptorsRequest]) (*connect.Response[v1.BuildDescriptorsResponse], error)
-	// ValidatePsbt parses a base64 PSBT and reports signature progress. When a
-	// group is supplied, inputs whose script does not belong to the group's
-	// descriptor are rejected.
-	ValidatePsbt(context.Context, *connect.Request[v1.ValidatePsbtRequest]) (*connect.Response[v1.ValidatePsbtResponse], error)
-	// PublishGroup encodes a multisig group as an OP_RETURN payload (the
-	// BitWindow wire format) and broadcasts it, funding a fresh own address.
-	// Returns the broadcast txid.
-	PublishGroup(context.Context, *connect.Request[v1.PublishGroupRequest]) (*connect.Response[v1.PublishGroupResponse], error)
-	// ImportGroupFromTxid fetches the OP_RETURN at the given txid, decodes the
-	// multisig group, and reports which of the group's keys belong to the wallet.
-	ImportGroupFromTxid(context.Context, *connect.Request[v1.ImportGroupFromTxidRequest]) (*connect.Response[v1.ImportGroupFromTxidResponse], error)
-	// SignTransaction adds the wallet's signature(s) to a multisig PSBT,
-	// deriving the wallet's keys server-side from its seed. The PSBT must belong
-	// to the group (foreign inputs are rejected).
-	SignTransaction(context.Context, *connect.Request[v1.SignTransactionRequest]) (*connect.Response[v1.SignTransactionResponse], error)
-	// CombineAndBroadcast merges partial PSBTs, finalizes, and broadcasts — but
-	// only if the combined PSBT reaches the threshold. A non-finalizable PSBT is
-	// never broadcast.
-	CombineAndBroadcast(context.Context, *connect.Request[v1.CombineAndBroadcastRequest]) (*connect.Response[v1.CombineAndBroadcastResponse], error)
-	// SyncGroup ensures the group's watch-only wallet exists (creating it from the
-	// Phase-1 descriptors if missing) and returns its balance and UTXOs.
-	SyncGroup(context.Context, *connect.Request[v1.SyncGroupRequest]) (*connect.Response[v1.SyncGroupResponse], error)
-	// RestoreHistory scans the watch-only wallet's transactions and reconstructs
-	// the group's spend/receive records with per-tx signature counts and status.
-	RestoreHistory(context.Context, *connect.Request[v1.RestoreHistoryRequest]) (*connect.Response[v1.RestoreHistoryResponse], error)
-	// CreateSpendPsbt builds an unsigned funded PSBT spending from the group's
-	// watch-only wallet to the given destinations (ensuring the wallet exists).
-	CreateSpendPsbt(context.Context, *connect.Request[v1.CreateSpendPsbtRequest]) (*connect.Response[v1.CreateSpendPsbtResponse], error)
-}
-
-// NewMultisigLoungeServiceHandler builds an HTTP handler from the service implementation. It
-// returns the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewMultisigLoungeServiceHandler(svc MultisigLoungeServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	multisigLoungeServiceMethods := v1.File_multisiglounge_v1_multisiglounge_proto.Services().ByName("MultisigLoungeService").Methods()
-	multisigLoungeServiceBuildDescriptorsHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceBuildDescriptorsProcedure,
-		svc.BuildDescriptors,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("BuildDescriptors")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServiceValidatePsbtHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceValidatePsbtProcedure,
-		svc.ValidatePsbt,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("ValidatePsbt")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServicePublishGroupHandler := connect.NewUnaryHandler(
-		MultisigLoungeServicePublishGroupProcedure,
-		svc.PublishGroup,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("PublishGroup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServiceImportGroupFromTxidHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceImportGroupFromTxidProcedure,
-		svc.ImportGroupFromTxid,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("ImportGroupFromTxid")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServiceSignTransactionHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceSignTransactionProcedure,
-		svc.SignTransaction,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("SignTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServiceCombineAndBroadcastHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceCombineAndBroadcastProcedure,
-		svc.CombineAndBroadcast,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("CombineAndBroadcast")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServiceSyncGroupHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceSyncGroupProcedure,
-		svc.SyncGroup,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("SyncGroup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServiceRestoreHistoryHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceRestoreHistoryProcedure,
-		svc.RestoreHistory,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("RestoreHistory")),
-		connect.WithHandlerOptions(opts...),
-	)
-	multisigLoungeServiceCreateSpendPsbtHandler := connect.NewUnaryHandler(
-		MultisigLoungeServiceCreateSpendPsbtProcedure,
-		svc.CreateSpendPsbt,
-		connect.WithSchema(multisigLoungeServiceMethods.ByName("CreateSpendPsbt")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/multisiglounge.v1.MultisigLoungeService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case MultisigLoungeServiceBuildDescriptorsProcedure:
-			multisigLoungeServiceBuildDescriptorsHandler.ServeHTTP(w, r)
-		case MultisigLoungeServiceValidatePsbtProcedure:
-			multisigLoungeServiceValidatePsbtHandler.ServeHTTP(w, r)
-		case MultisigLoungeServicePublishGroupProcedure:
-			multisigLoungeServicePublishGroupHandler.ServeHTTP(w, r)
-		case MultisigLoungeServiceImportGroupFromTxidProcedure:
-			multisigLoungeServiceImportGroupFromTxidHandler.ServeHTTP(w, r)
-		case MultisigLoungeServiceSignTransactionProcedure:
-			multisigLoungeServiceSignTransactionHandler.ServeHTTP(w, r)
-		case MultisigLoungeServiceCombineAndBroadcastProcedure:
-			multisigLoungeServiceCombineAndBroadcastHandler.ServeHTTP(w, r)
-		case MultisigLoungeServiceSyncGroupProcedure:
-			multisigLoungeServiceSyncGroupHandler.ServeHTTP(w, r)
-		case MultisigLoungeServiceRestoreHistoryProcedure:
-			multisigLoungeServiceRestoreHistoryHandler.ServeHTTP(w, r)
-		case MultisigLoungeServiceCreateSpendPsbtProcedure:
-			multisigLoungeServiceCreateSpendPsbtHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedMultisigLoungeServiceHandler) CreateSpendPsbt(context.Context, *v1.CreateSpendPsbtRequest) (*v1.CreateSpendPsbtResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "multisiglounge.v1.MultisigLoungeService.CreateSpendPsbt is not implemented")
 }
 
-// UnimplementedMultisigLoungeServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedMultisigLoungeServiceHandler struct{}
+type multisigLoungeServiceClient struct {
+	client *connect.Client
+}
+
+func (c *multisigLoungeServiceClient) BuildDescriptors(ctx context.Context, req *v1.BuildDescriptorsRequest) (*v1.BuildDescriptorsResponse, error) {
+	var res v1.BuildDescriptorsResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceBuildDescriptorsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) ValidatePsbt(ctx context.Context, req *v1.ValidatePsbtRequest) (*v1.ValidatePsbtResponse, error) {
+	var res v1.ValidatePsbtResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceValidatePsbtSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) PublishGroup(ctx context.Context, req *v1.PublishGroupRequest) (*v1.PublishGroupResponse, error) {
+	var res v1.PublishGroupResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServicePublishGroupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) ImportGroupFromTxid(ctx context.Context, req *v1.ImportGroupFromTxidRequest) (*v1.ImportGroupFromTxidResponse, error) {
+	var res v1.ImportGroupFromTxidResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceImportGroupFromTxidSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) SignTransaction(ctx context.Context, req *v1.SignTransactionRequest) (*v1.SignTransactionResponse, error) {
+	var res v1.SignTransactionResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceSignTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) CombineAndBroadcast(ctx context.Context, req *v1.CombineAndBroadcastRequest) (*v1.CombineAndBroadcastResponse, error) {
+	var res v1.CombineAndBroadcastResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceCombineAndBroadcastSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) SyncGroup(ctx context.Context, req *v1.SyncGroupRequest) (*v1.SyncGroupResponse, error) {
+	var res v1.SyncGroupResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceSyncGroupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) RestoreHistory(ctx context.Context, req *v1.RestoreHistoryRequest) (*v1.RestoreHistoryResponse, error) {
+	var res v1.RestoreHistoryResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceRestoreHistorySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *multisigLoungeServiceClient) CreateSpendPsbt(ctx context.Context, req *v1.CreateSpendPsbtRequest) (*v1.CreateSpendPsbtResponse, error) {
+	var res v1.CreateSpendPsbtResponse
+	if err := c.client.CallUnary(ctx, multisigLoungeServiceCreateSpendPsbtSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type multisigLoungeServiceHandler struct{ svc MultisigLoungeServiceHandler }
 
-func (UnimplementedMultisigLoungeServiceHandler) BuildDescriptors(context.Context, *connect.Request[v1.BuildDescriptorsRequest]) (*connect.Response[v1.BuildDescriptorsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.BuildDescriptors is not implemented"))
+func (h multisigLoungeServiceHandler) buildDescriptors(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BuildDescriptorsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BuildDescriptors(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) ValidatePsbt(context.Context, *connect.Request[v1.ValidatePsbtRequest]) (*connect.Response[v1.ValidatePsbtResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.ValidatePsbt is not implemented"))
+func (h multisigLoungeServiceHandler) validatePsbt(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ValidatePsbtRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ValidatePsbt(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) PublishGroup(context.Context, *connect.Request[v1.PublishGroupRequest]) (*connect.Response[v1.PublishGroupResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.PublishGroup is not implemented"))
+func (h multisigLoungeServiceHandler) publishGroup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PublishGroupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PublishGroup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) ImportGroupFromTxid(context.Context, *connect.Request[v1.ImportGroupFromTxidRequest]) (*connect.Response[v1.ImportGroupFromTxidResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.ImportGroupFromTxid is not implemented"))
+func (h multisigLoungeServiceHandler) importGroupFromTxid(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ImportGroupFromTxidRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ImportGroupFromTxid(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) SignTransaction(context.Context, *connect.Request[v1.SignTransactionRequest]) (*connect.Response[v1.SignTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.SignTransaction is not implemented"))
+func (h multisigLoungeServiceHandler) signTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) CombineAndBroadcast(context.Context, *connect.Request[v1.CombineAndBroadcastRequest]) (*connect.Response[v1.CombineAndBroadcastResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.CombineAndBroadcast is not implemented"))
+func (h multisigLoungeServiceHandler) combineAndBroadcast(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CombineAndBroadcastRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CombineAndBroadcast(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) SyncGroup(context.Context, *connect.Request[v1.SyncGroupRequest]) (*connect.Response[v1.SyncGroupResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.SyncGroup is not implemented"))
+func (h multisigLoungeServiceHandler) syncGroup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SyncGroupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SyncGroup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) RestoreHistory(context.Context, *connect.Request[v1.RestoreHistoryRequest]) (*connect.Response[v1.RestoreHistoryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.RestoreHistory is not implemented"))
+func (h multisigLoungeServiceHandler) restoreHistory(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RestoreHistoryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RestoreHistory(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedMultisigLoungeServiceHandler) CreateSpendPsbt(context.Context, *connect.Request[v1.CreateSpendPsbtRequest]) (*connect.Response[v1.CreateSpendPsbtResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("multisiglounge.v1.MultisigLoungeService.CreateSpendPsbt is not implemented"))
+func (h multisigLoungeServiceHandler) createSpendPsbt(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateSpendPsbtRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateSpendPsbt(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/bitcoin_conf.connect.go b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/bitcoin_conf.connect.go
index a0985055ec..6c2821b689 100644
--- a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/bitcoin_conf.connect.go
+++ b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/bitcoin_conf.connect.go
@@ -5,336 +5,353 @@
 package orchestratorv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// BitcoinConfServiceName is the fully-qualified name of the BitcoinConfService service.
 	BitcoinConfServiceName = "orchestrator.v1.BitcoinConfService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// BitcoinConfServiceGetBitcoinConfigProcedure is the fully-qualified name of the
-	// BitcoinConfService's GetBitcoinConfig RPC.
+	// BitcoinConfServiceGetBitcoinConfigProcedure is the procedure name of the BitcoinConfService's
+	// GetBitcoinConfig RPC.
 	BitcoinConfServiceGetBitcoinConfigProcedure = "/orchestrator.v1.BitcoinConfService/GetBitcoinConfig"
-	// BitcoinConfServicePrepareNetworkChangeProcedure is the fully-qualified name of the
-	// BitcoinConfService's PrepareNetworkChange RPC.
+	// BitcoinConfServicePrepareNetworkChangeProcedure is the procedure name of the BitcoinConfService's
+	// PrepareNetworkChange RPC.
 	BitcoinConfServicePrepareNetworkChangeProcedure = "/orchestrator.v1.BitcoinConfService/PrepareNetworkChange"
-	// BitcoinConfServiceListNetworksProcedure is the fully-qualified name of the BitcoinConfService's
+	// BitcoinConfServiceListNetworksProcedure is the procedure name of the BitcoinConfService's
 	// ListNetworks RPC.
 	BitcoinConfServiceListNetworksProcedure = "/orchestrator.v1.BitcoinConfService/ListNetworks"
-	// BitcoinConfServiceTakeNewNetworksProcedure is the fully-qualified name of the
-	// BitcoinConfService's TakeNewNetworks RPC.
+	// BitcoinConfServiceTakeNewNetworksProcedure is the procedure name of the BitcoinConfService's
+	// TakeNewNetworks RPC.
 	BitcoinConfServiceTakeNewNetworksProcedure = "/orchestrator.v1.BitcoinConfService/TakeNewNetworks"
-	// BitcoinConfServicePlanECashSwitchProcedure is the fully-qualified name of the
-	// BitcoinConfService's PlanECashSwitch RPC.
+	// BitcoinConfServicePlanECashSwitchProcedure is the procedure name of the BitcoinConfService's
+	// PlanECashSwitch RPC.
 	BitcoinConfServicePlanECashSwitchProcedure = "/orchestrator.v1.BitcoinConfService/PlanECashSwitch"
-	// BitcoinConfServiceSetBitcoinConfigNetworkProcedure is the fully-qualified name of the
+	// BitcoinConfServiceSetBitcoinConfigNetworkProcedure is the procedure name of the
 	// BitcoinConfService's SetBitcoinConfigNetwork RPC.
 	BitcoinConfServiceSetBitcoinConfigNetworkProcedure = "/orchestrator.v1.BitcoinConfService/SetBitcoinConfigNetwork"
-	// BitcoinConfServiceSetBitcoinConfigDataDirProcedure is the fully-qualified name of the
+	// BitcoinConfServiceSetBitcoinConfigDataDirProcedure is the procedure name of the
 	// BitcoinConfService's SetBitcoinConfigDataDir RPC.
 	BitcoinConfServiceSetBitcoinConfigDataDirProcedure = "/orchestrator.v1.BitcoinConfService/SetBitcoinConfigDataDir"
-	// BitcoinConfServiceWriteBitcoinConfigProcedure is the fully-qualified name of the
-	// BitcoinConfService's WriteBitcoinConfig RPC.
+	// BitcoinConfServiceWriteBitcoinConfigProcedure is the procedure name of the BitcoinConfService's
+	// WriteBitcoinConfig RPC.
 	BitcoinConfServiceWriteBitcoinConfigProcedure = "/orchestrator.v1.BitcoinConfService/WriteBitcoinConfig"
 )
 
+var (
+	bitcoinConfServiceGetBitcoinConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("GetBitcoinConfig"),
+			Procedure:  BitcoinConfServiceGetBitcoinConfigProcedure,
+		}
+	})
+	bitcoinConfServicePrepareNetworkChangeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("PrepareNetworkChange"),
+			Procedure:  BitcoinConfServicePrepareNetworkChangeProcedure,
+		}
+	})
+	bitcoinConfServiceListNetworksSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("ListNetworks"),
+			Procedure:  BitcoinConfServiceListNetworksProcedure,
+		}
+	})
+	bitcoinConfServiceTakeNewNetworksSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("TakeNewNetworks"),
+			Procedure:  BitcoinConfServiceTakeNewNetworksProcedure,
+		}
+	})
+	bitcoinConfServicePlanECashSwitchSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("PlanECashSwitch"),
+			Procedure:  BitcoinConfServicePlanECashSwitchProcedure,
+		}
+	})
+	bitcoinConfServiceSetBitcoinConfigNetworkSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("SetBitcoinConfigNetwork"),
+			Procedure:  BitcoinConfServiceSetBitcoinConfigNetworkProcedure,
+		}
+	})
+	bitcoinConfServiceSetBitcoinConfigDataDirSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("SetBitcoinConfigDataDir"),
+			Procedure:  BitcoinConfServiceSetBitcoinConfigDataDirProcedure,
+		}
+	})
+	bitcoinConfServiceWriteBitcoinConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods().ByName("WriteBitcoinConfig"),
+			Procedure:  BitcoinConfServiceWriteBitcoinConfigProcedure,
+		}
+	})
+)
+
 // BitcoinConfServiceClient is a client for the orchestrator.v1.BitcoinConfService service.
 type BitcoinConfServiceClient interface {
-	// Get current Bitcoin Core configuration state.
-	GetBitcoinConfig(context.Context, *connect.Request[v1.GetBitcoinConfigRequest]) (*connect.Response[v1.GetBitcoinConfigResponse], error)
-	// Report what the user must resolve before a network and/or wallet-backend
-	// change can be applied. Side-effect free.
-	PrepareNetworkChange(context.Context, *connect.Request[v1.PrepareNetworkChangeRequest]) (*connect.Response[v1.NetworkChangePlan], error)
-	// The networks the user can pick, from the published catalog plus regtest.
-	ListNetworks(context.Context, *connect.Request[v1.ListNetworksRequest]) (*connect.Response[v1.ListNetworksResponse], error)
-	// The networks that appeared in the catalog since the last call, so the app
-	// can name them in a notice. Reporting a network also marks it told: a
-	// second call returns it no more. A first run reports nothing.
-	TakeNewNetworks(context.Context, *connect.Request[v1.TakeNewNetworksRequest]) (*connect.Response[v1.TakeNewNetworksResponse], error)
-	// What a move to another eCash network costs. Both fork mainnet, so the
-	// blocks below the lower fork height are shared and the move is a reset
-	// rather than a resync. Side-effect free.
-	PlanECashSwitch(context.Context, *connect.Request[v1.PlanECashSwitchRequest]) (*connect.Response[v1.PlanECashSwitchResponse], error)
-	// Set the Bitcoin Core network. Takes a catalog id ("alphanet") or a slot
-	// name (signet, mainnet, ecash, regtest).
-	SetBitcoinConfigNetwork(context.Context, *connect.Request[v1.SetBitcoinConfigNetworkRequest]) (*connect.Response[v1.SetBitcoinConfigNetworkResponse], error)
-	// Set the Bitcoin Core datadir for a specific network.
-	SetBitcoinConfigDataDir(context.Context, *connect.Request[v1.SetBitcoinConfigDataDirRequest]) (*connect.Response[v1.SetBitcoinConfigDataDirResponse], error)
-	// Write raw Bitcoin Core configuration content.
-	WriteBitcoinConfig(context.Context, *connect.Request[v1.WriteBitcoinConfigRequest]) (*connect.Response[v1.WriteBitcoinConfigResponse], error)
+	GetBitcoinConfig(context.Context, *v1.GetBitcoinConfigRequest) (*v1.GetBitcoinConfigResponse, error)
+	PrepareNetworkChange(context.Context, *v1.PrepareNetworkChangeRequest) (*v1.NetworkChangePlan, error)
+	ListNetworks(context.Context, *v1.ListNetworksRequest) (*v1.ListNetworksResponse, error)
+	TakeNewNetworks(context.Context, *v1.TakeNewNetworksRequest) (*v1.TakeNewNetworksResponse, error)
+	PlanECashSwitch(context.Context, *v1.PlanECashSwitchRequest) (*v1.PlanECashSwitchResponse, error)
+	SetBitcoinConfigNetwork(context.Context, *v1.SetBitcoinConfigNetworkRequest) (*v1.SetBitcoinConfigNetworkResponse, error)
+	SetBitcoinConfigDataDir(context.Context, *v1.SetBitcoinConfigDataDirRequest) (*v1.SetBitcoinConfigDataDirResponse, error)
+	WriteBitcoinConfig(context.Context, *v1.WriteBitcoinConfigRequest) (*v1.WriteBitcoinConfigResponse, error)
 }
 
 // NewBitcoinConfServiceClient constructs a client for the orchestrator.v1.BitcoinConfService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewBitcoinConfServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) BitcoinConfServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	bitcoinConfServiceMethods := v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods()
-	return &bitcoinConfServiceClient{
-		getBitcoinConfig: connect.NewClient[v1.GetBitcoinConfigRequest, v1.GetBitcoinConfigResponse](
-			httpClient,
-			baseURL+BitcoinConfServiceGetBitcoinConfigProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("GetBitcoinConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		prepareNetworkChange: connect.NewClient[v1.PrepareNetworkChangeRequest, v1.NetworkChangePlan](
-			httpClient,
-			baseURL+BitcoinConfServicePrepareNetworkChangeProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("PrepareNetworkChange")),
-			connect.WithClientOptions(opts...),
-		),
-		listNetworks: connect.NewClient[v1.ListNetworksRequest, v1.ListNetworksResponse](
-			httpClient,
-			baseURL+BitcoinConfServiceListNetworksProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("ListNetworks")),
-			connect.WithClientOptions(opts...),
-		),
-		takeNewNetworks: connect.NewClient[v1.TakeNewNetworksRequest, v1.TakeNewNetworksResponse](
-			httpClient,
-			baseURL+BitcoinConfServiceTakeNewNetworksProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("TakeNewNetworks")),
-			connect.WithClientOptions(opts...),
-		),
-		planECashSwitch: connect.NewClient[v1.PlanECashSwitchRequest, v1.PlanECashSwitchResponse](
-			httpClient,
-			baseURL+BitcoinConfServicePlanECashSwitchProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("PlanECashSwitch")),
-			connect.WithClientOptions(opts...),
-		),
-		setBitcoinConfigNetwork: connect.NewClient[v1.SetBitcoinConfigNetworkRequest, v1.SetBitcoinConfigNetworkResponse](
-			httpClient,
-			baseURL+BitcoinConfServiceSetBitcoinConfigNetworkProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("SetBitcoinConfigNetwork")),
-			connect.WithClientOptions(opts...),
-		),
-		setBitcoinConfigDataDir: connect.NewClient[v1.SetBitcoinConfigDataDirRequest, v1.SetBitcoinConfigDataDirResponse](
-			httpClient,
-			baseURL+BitcoinConfServiceSetBitcoinConfigDataDirProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("SetBitcoinConfigDataDir")),
-			connect.WithClientOptions(opts...),
-		),
-		writeBitcoinConfig: connect.NewClient[v1.WriteBitcoinConfigRequest, v1.WriteBitcoinConfigResponse](
-			httpClient,
-			baseURL+BitcoinConfServiceWriteBitcoinConfigProcedure,
-			connect.WithSchema(bitcoinConfServiceMethods.ByName("WriteBitcoinConfig")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// service. Multiple service clients may share a single connect.Client.
+func NewBitcoinConfServiceClient(client *connect.Client) BitcoinConfServiceClient {
+	return &bitcoinConfServiceClient{client: client}
 }
 
-// bitcoinConfServiceClient implements BitcoinConfServiceClient.
-type bitcoinConfServiceClient struct {
-	getBitcoinConfig        *connect.Client[v1.GetBitcoinConfigRequest, v1.GetBitcoinConfigResponse]
-	prepareNetworkChange    *connect.Client[v1.PrepareNetworkChangeRequest, v1.NetworkChangePlan]
-	listNetworks            *connect.Client[v1.ListNetworksRequest, v1.ListNetworksResponse]
-	takeNewNetworks         *connect.Client[v1.TakeNewNetworksRequest, v1.TakeNewNetworksResponse]
-	planECashSwitch         *connect.Client[v1.PlanECashSwitchRequest, v1.PlanECashSwitchResponse]
-	setBitcoinConfigNetwork *connect.Client[v1.SetBitcoinConfigNetworkRequest, v1.SetBitcoinConfigNetworkResponse]
-	setBitcoinConfigDataDir *connect.Client[v1.SetBitcoinConfigDataDirRequest, v1.SetBitcoinConfigDataDirResponse]
-	writeBitcoinConfig      *connect.Client[v1.WriteBitcoinConfigRequest, v1.WriteBitcoinConfigResponse]
+// BitcoinConfServiceHandler is an implementation of the orchestrator.v1.BitcoinConfService service.
+type BitcoinConfServiceHandler interface {
+	GetBitcoinConfig(context.Context, *v1.GetBitcoinConfigRequest) (*v1.GetBitcoinConfigResponse, error)
+	PrepareNetworkChange(context.Context, *v1.PrepareNetworkChangeRequest) (*v1.NetworkChangePlan, error)
+	ListNetworks(context.Context, *v1.ListNetworksRequest) (*v1.ListNetworksResponse, error)
+	TakeNewNetworks(context.Context, *v1.TakeNewNetworksRequest) (*v1.TakeNewNetworksResponse, error)
+	PlanECashSwitch(context.Context, *v1.PlanECashSwitchRequest) (*v1.PlanECashSwitchResponse, error)
+	SetBitcoinConfigNetwork(context.Context, *v1.SetBitcoinConfigNetworkRequest) (*v1.SetBitcoinConfigNetworkResponse, error)
+	SetBitcoinConfigDataDir(context.Context, *v1.SetBitcoinConfigDataDirRequest) (*v1.SetBitcoinConfigDataDirResponse, error)
+	WriteBitcoinConfig(context.Context, *v1.WriteBitcoinConfigRequest) (*v1.WriteBitcoinConfigResponse, error)
 }
 
-// GetBitcoinConfig calls orchestrator.v1.BitcoinConfService.GetBitcoinConfig.
-func (c *bitcoinConfServiceClient) GetBitcoinConfig(ctx context.Context, req *connect.Request[v1.GetBitcoinConfigRequest]) (*connect.Response[v1.GetBitcoinConfigResponse], error) {
-	return c.getBitcoinConfig.CallUnary(ctx, req)
+// RegisterBitcoinConfServiceHandler registers svc as the orchestrator.v1.BitcoinConfService
+// implementation on server.
+func RegisterBitcoinConfServiceHandler(server *connect.Server, svc BitcoinConfServiceHandler) {
+	adapter := bitcoinConfServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: bitcoinConfServiceGetBitcoinConfigSpec(), Handler: adapter.getBitcoinConfig},
+		connect.Method{Spec: bitcoinConfServicePrepareNetworkChangeSpec(), Handler: adapter.prepareNetworkChange},
+		connect.Method{Spec: bitcoinConfServiceListNetworksSpec(), Handler: adapter.listNetworks},
+		connect.Method{Spec: bitcoinConfServiceTakeNewNetworksSpec(), Handler: adapter.takeNewNetworks},
+		connect.Method{Spec: bitcoinConfServicePlanECashSwitchSpec(), Handler: adapter.planECashSwitch},
+		connect.Method{Spec: bitcoinConfServiceSetBitcoinConfigNetworkSpec(), Handler: adapter.setBitcoinConfigNetwork},
+		connect.Method{Spec: bitcoinConfServiceSetBitcoinConfigDataDirSpec(), Handler: adapter.setBitcoinConfigDataDir},
+		connect.Method{Spec: bitcoinConfServiceWriteBitcoinConfigSpec(), Handler: adapter.writeBitcoinConfig},
+	)
 }
 
-// PrepareNetworkChange calls orchestrator.v1.BitcoinConfService.PrepareNetworkChange.
-func (c *bitcoinConfServiceClient) PrepareNetworkChange(ctx context.Context, req *connect.Request[v1.PrepareNetworkChangeRequest]) (*connect.Response[v1.NetworkChangePlan], error) {
-	return c.prepareNetworkChange.CallUnary(ctx, req)
+// UnimplementedBitcoinConfServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedBitcoinConfServiceHandler struct{}
+
+func (UnimplementedBitcoinConfServiceHandler) GetBitcoinConfig(context.Context, *v1.GetBitcoinConfigRequest) (*v1.GetBitcoinConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.GetBitcoinConfig is not implemented")
 }
 
-// ListNetworks calls orchestrator.v1.BitcoinConfService.ListNetworks.
-func (c *bitcoinConfServiceClient) ListNetworks(ctx context.Context, req *connect.Request[v1.ListNetworksRequest]) (*connect.Response[v1.ListNetworksResponse], error) {
-	return c.listNetworks.CallUnary(ctx, req)
+func (UnimplementedBitcoinConfServiceHandler) PrepareNetworkChange(context.Context, *v1.PrepareNetworkChangeRequest) (*v1.NetworkChangePlan, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.PrepareNetworkChange is not implemented")
 }
 
-// TakeNewNetworks calls orchestrator.v1.BitcoinConfService.TakeNewNetworks.
-func (c *bitcoinConfServiceClient) TakeNewNetworks(ctx context.Context, req *connect.Request[v1.TakeNewNetworksRequest]) (*connect.Response[v1.TakeNewNetworksResponse], error) {
-	return c.takeNewNetworks.CallUnary(ctx, req)
+func (UnimplementedBitcoinConfServiceHandler) ListNetworks(context.Context, *v1.ListNetworksRequest) (*v1.ListNetworksResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.ListNetworks is not implemented")
 }
 
-// PlanECashSwitch calls orchestrator.v1.BitcoinConfService.PlanECashSwitch.
-func (c *bitcoinConfServiceClient) PlanECashSwitch(ctx context.Context, req *connect.Request[v1.PlanECashSwitchRequest]) (*connect.Response[v1.PlanECashSwitchResponse], error) {
-	return c.planECashSwitch.CallUnary(ctx, req)
+func (UnimplementedBitcoinConfServiceHandler) TakeNewNetworks(context.Context, *v1.TakeNewNetworksRequest) (*v1.TakeNewNetworksResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.TakeNewNetworks is not implemented")
 }
 
-// SetBitcoinConfigNetwork calls orchestrator.v1.BitcoinConfService.SetBitcoinConfigNetwork.
-func (c *bitcoinConfServiceClient) SetBitcoinConfigNetwork(ctx context.Context, req *connect.Request[v1.SetBitcoinConfigNetworkRequest]) (*connect.Response[v1.SetBitcoinConfigNetworkResponse], error) {
-	return c.setBitcoinConfigNetwork.CallUnary(ctx, req)
+func (UnimplementedBitcoinConfServiceHandler) PlanECashSwitch(context.Context, *v1.PlanECashSwitchRequest) (*v1.PlanECashSwitchResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.PlanECashSwitch is not implemented")
 }
 
-// SetBitcoinConfigDataDir calls orchestrator.v1.BitcoinConfService.SetBitcoinConfigDataDir.
-func (c *bitcoinConfServiceClient) SetBitcoinConfigDataDir(ctx context.Context, req *connect.Request[v1.SetBitcoinConfigDataDirRequest]) (*connect.Response[v1.SetBitcoinConfigDataDirResponse], error) {
-	return c.setBitcoinConfigDataDir.CallUnary(ctx, req)
+func (UnimplementedBitcoinConfServiceHandler) SetBitcoinConfigNetwork(context.Context, *v1.SetBitcoinConfigNetworkRequest) (*v1.SetBitcoinConfigNetworkResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.SetBitcoinConfigNetwork is not implemented")
 }
 
-// WriteBitcoinConfig calls orchestrator.v1.BitcoinConfService.WriteBitcoinConfig.
-func (c *bitcoinConfServiceClient) WriteBitcoinConfig(ctx context.Context, req *connect.Request[v1.WriteBitcoinConfigRequest]) (*connect.Response[v1.WriteBitcoinConfigResponse], error) {
-	return c.writeBitcoinConfig.CallUnary(ctx, req)
+func (UnimplementedBitcoinConfServiceHandler) SetBitcoinConfigDataDir(context.Context, *v1.SetBitcoinConfigDataDirRequest) (*v1.SetBitcoinConfigDataDirResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.SetBitcoinConfigDataDir is not implemented")
 }
 
-// BitcoinConfServiceHandler is an implementation of the orchestrator.v1.BitcoinConfService service.
-type BitcoinConfServiceHandler interface {
-	// Get current Bitcoin Core configuration state.
-	GetBitcoinConfig(context.Context, *connect.Request[v1.GetBitcoinConfigRequest]) (*connect.Response[v1.GetBitcoinConfigResponse], error)
-	// Report what the user must resolve before a network and/or wallet-backend
-	// change can be applied. Side-effect free.
-	PrepareNetworkChange(context.Context, *connect.Request[v1.PrepareNetworkChangeRequest]) (*connect.Response[v1.NetworkChangePlan], error)
-	// The networks the user can pick, from the published catalog plus regtest.
-	ListNetworks(context.Context, *connect.Request[v1.ListNetworksRequest]) (*connect.Response[v1.ListNetworksResponse], error)
-	// The networks that appeared in the catalog since the last call, so the app
-	// can name them in a notice. Reporting a network also marks it told: a
-	// second call returns it no more. A first run reports nothing.
-	TakeNewNetworks(context.Context, *connect.Request[v1.TakeNewNetworksRequest]) (*connect.Response[v1.TakeNewNetworksResponse], error)
-	// What a move to another eCash network costs. Both fork mainnet, so the
-	// blocks below the lower fork height are shared and the move is a reset
-	// rather than a resync. Side-effect free.
-	PlanECashSwitch(context.Context, *connect.Request[v1.PlanECashSwitchRequest]) (*connect.Response[v1.PlanECashSwitchResponse], error)
-	// Set the Bitcoin Core network. Takes a catalog id ("alphanet") or a slot
-	// name (signet, mainnet, ecash, regtest).
-	SetBitcoinConfigNetwork(context.Context, *connect.Request[v1.SetBitcoinConfigNetworkRequest]) (*connect.Response[v1.SetBitcoinConfigNetworkResponse], error)
-	// Set the Bitcoin Core datadir for a specific network.
-	SetBitcoinConfigDataDir(context.Context, *connect.Request[v1.SetBitcoinConfigDataDirRequest]) (*connect.Response[v1.SetBitcoinConfigDataDirResponse], error)
-	// Write raw Bitcoin Core configuration content.
-	WriteBitcoinConfig(context.Context, *connect.Request[v1.WriteBitcoinConfigRequest]) (*connect.Response[v1.WriteBitcoinConfigResponse], error)
+func (UnimplementedBitcoinConfServiceHandler) WriteBitcoinConfig(context.Context, *v1.WriteBitcoinConfigRequest) (*v1.WriteBitcoinConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.BitcoinConfService.WriteBitcoinConfig is not implemented")
 }
 
-// NewBitcoinConfServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewBitcoinConfServiceHandler(svc BitcoinConfServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	bitcoinConfServiceMethods := v1.File_orchestrator_v1_bitcoin_conf_proto.Services().ByName("BitcoinConfService").Methods()
-	bitcoinConfServiceGetBitcoinConfigHandler := connect.NewUnaryHandler(
-		BitcoinConfServiceGetBitcoinConfigProcedure,
-		svc.GetBitcoinConfig,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("GetBitcoinConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitcoinConfServicePrepareNetworkChangeHandler := connect.NewUnaryHandler(
-		BitcoinConfServicePrepareNetworkChangeProcedure,
-		svc.PrepareNetworkChange,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("PrepareNetworkChange")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitcoinConfServiceListNetworksHandler := connect.NewUnaryHandler(
-		BitcoinConfServiceListNetworksProcedure,
-		svc.ListNetworks,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("ListNetworks")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitcoinConfServiceTakeNewNetworksHandler := connect.NewUnaryHandler(
-		BitcoinConfServiceTakeNewNetworksProcedure,
-		svc.TakeNewNetworks,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("TakeNewNetworks")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitcoinConfServicePlanECashSwitchHandler := connect.NewUnaryHandler(
-		BitcoinConfServicePlanECashSwitchProcedure,
-		svc.PlanECashSwitch,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("PlanECashSwitch")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitcoinConfServiceSetBitcoinConfigNetworkHandler := connect.NewUnaryHandler(
-		BitcoinConfServiceSetBitcoinConfigNetworkProcedure,
-		svc.SetBitcoinConfigNetwork,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("SetBitcoinConfigNetwork")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitcoinConfServiceSetBitcoinConfigDataDirHandler := connect.NewUnaryHandler(
-		BitcoinConfServiceSetBitcoinConfigDataDirProcedure,
-		svc.SetBitcoinConfigDataDir,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("SetBitcoinConfigDataDir")),
-		connect.WithHandlerOptions(opts...),
-	)
-	bitcoinConfServiceWriteBitcoinConfigHandler := connect.NewUnaryHandler(
-		BitcoinConfServiceWriteBitcoinConfigProcedure,
-		svc.WriteBitcoinConfig,
-		connect.WithSchema(bitcoinConfServiceMethods.ByName("WriteBitcoinConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/orchestrator.v1.BitcoinConfService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case BitcoinConfServiceGetBitcoinConfigProcedure:
-			bitcoinConfServiceGetBitcoinConfigHandler.ServeHTTP(w, r)
-		case BitcoinConfServicePrepareNetworkChangeProcedure:
-			bitcoinConfServicePrepareNetworkChangeHandler.ServeHTTP(w, r)
-		case BitcoinConfServiceListNetworksProcedure:
-			bitcoinConfServiceListNetworksHandler.ServeHTTP(w, r)
-		case BitcoinConfServiceTakeNewNetworksProcedure:
-			bitcoinConfServiceTakeNewNetworksHandler.ServeHTTP(w, r)
-		case BitcoinConfServicePlanECashSwitchProcedure:
-			bitcoinConfServicePlanECashSwitchHandler.ServeHTTP(w, r)
-		case BitcoinConfServiceSetBitcoinConfigNetworkProcedure:
-			bitcoinConfServiceSetBitcoinConfigNetworkHandler.ServeHTTP(w, r)
-		case BitcoinConfServiceSetBitcoinConfigDataDirProcedure:
-			bitcoinConfServiceSetBitcoinConfigDataDirHandler.ServeHTTP(w, r)
-		case BitcoinConfServiceWriteBitcoinConfigProcedure:
-			bitcoinConfServiceWriteBitcoinConfigHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type bitcoinConfServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedBitcoinConfServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedBitcoinConfServiceHandler struct{}
+func (c *bitcoinConfServiceClient) GetBitcoinConfig(ctx context.Context, req *v1.GetBitcoinConfigRequest) (*v1.GetBitcoinConfigResponse, error) {
+	var res v1.GetBitcoinConfigResponse
+	if err := c.client.CallUnary(ctx, bitcoinConfServiceGetBitcoinConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitcoinConfServiceClient) PrepareNetworkChange(ctx context.Context, req *v1.PrepareNetworkChangeRequest) (*v1.NetworkChangePlan, error) {
+	var res v1.NetworkChangePlan
+	if err := c.client.CallUnary(ctx, bitcoinConfServicePrepareNetworkChangeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitcoinConfServiceClient) ListNetworks(ctx context.Context, req *v1.ListNetworksRequest) (*v1.ListNetworksResponse, error) {
+	var res v1.ListNetworksResponse
+	if err := c.client.CallUnary(ctx, bitcoinConfServiceListNetworksSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitcoinConfServiceClient) TakeNewNetworks(ctx context.Context, req *v1.TakeNewNetworksRequest) (*v1.TakeNewNetworksResponse, error) {
+	var res v1.TakeNewNetworksResponse
+	if err := c.client.CallUnary(ctx, bitcoinConfServiceTakeNewNetworksSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitcoinConfServiceClient) PlanECashSwitch(ctx context.Context, req *v1.PlanECashSwitchRequest) (*v1.PlanECashSwitchResponse, error) {
+	var res v1.PlanECashSwitchResponse
+	if err := c.client.CallUnary(ctx, bitcoinConfServicePlanECashSwitchSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitcoinConfServiceClient) SetBitcoinConfigNetwork(ctx context.Context, req *v1.SetBitcoinConfigNetworkRequest) (*v1.SetBitcoinConfigNetworkResponse, error) {
+	var res v1.SetBitcoinConfigNetworkResponse
+	if err := c.client.CallUnary(ctx, bitcoinConfServiceSetBitcoinConfigNetworkSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *bitcoinConfServiceClient) SetBitcoinConfigDataDir(ctx context.Context, req *v1.SetBitcoinConfigDataDirRequest) (*v1.SetBitcoinConfigDataDirResponse, error) {
+	var res v1.SetBitcoinConfigDataDirResponse
+	if err := c.client.CallUnary(ctx, bitcoinConfServiceSetBitcoinConfigDataDirSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedBitcoinConfServiceHandler) GetBitcoinConfig(context.Context, *connect.Request[v1.GetBitcoinConfigRequest]) (*connect.Response[v1.GetBitcoinConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.GetBitcoinConfig is not implemented"))
+func (c *bitcoinConfServiceClient) WriteBitcoinConfig(ctx context.Context, req *v1.WriteBitcoinConfigRequest) (*v1.WriteBitcoinConfigResponse, error) {
+	var res v1.WriteBitcoinConfigResponse
+	if err := c.client.CallUnary(ctx, bitcoinConfServiceWriteBitcoinConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedBitcoinConfServiceHandler) PrepareNetworkChange(context.Context, *connect.Request[v1.PrepareNetworkChangeRequest]) (*connect.Response[v1.NetworkChangePlan], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.PrepareNetworkChange is not implemented"))
+type bitcoinConfServiceHandler struct{ svc BitcoinConfServiceHandler }
+
+func (h bitcoinConfServiceHandler) getBitcoinConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBitcoinConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBitcoinConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitcoinConfServiceHandler) ListNetworks(context.Context, *connect.Request[v1.ListNetworksRequest]) (*connect.Response[v1.ListNetworksResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.ListNetworks is not implemented"))
+func (h bitcoinConfServiceHandler) prepareNetworkChange(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PrepareNetworkChangeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PrepareNetworkChange(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitcoinConfServiceHandler) TakeNewNetworks(context.Context, *connect.Request[v1.TakeNewNetworksRequest]) (*connect.Response[v1.TakeNewNetworksResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.TakeNewNetworks is not implemented"))
+func (h bitcoinConfServiceHandler) listNetworks(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListNetworksRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListNetworks(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitcoinConfServiceHandler) PlanECashSwitch(context.Context, *connect.Request[v1.PlanECashSwitchRequest]) (*connect.Response[v1.PlanECashSwitchResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.PlanECashSwitch is not implemented"))
+func (h bitcoinConfServiceHandler) takeNewNetworks(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TakeNewNetworksRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.TakeNewNetworks(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitcoinConfServiceHandler) SetBitcoinConfigNetwork(context.Context, *connect.Request[v1.SetBitcoinConfigNetworkRequest]) (*connect.Response[v1.SetBitcoinConfigNetworkResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.SetBitcoinConfigNetwork is not implemented"))
+func (h bitcoinConfServiceHandler) planECashSwitch(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PlanECashSwitchRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PlanECashSwitch(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h bitcoinConfServiceHandler) setBitcoinConfigNetwork(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetBitcoinConfigNetworkRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetBitcoinConfigNetwork(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitcoinConfServiceHandler) SetBitcoinConfigDataDir(context.Context, *connect.Request[v1.SetBitcoinConfigDataDirRequest]) (*connect.Response[v1.SetBitcoinConfigDataDirResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.SetBitcoinConfigDataDir is not implemented"))
+func (h bitcoinConfServiceHandler) setBitcoinConfigDataDir(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetBitcoinConfigDataDirRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetBitcoinConfigDataDir(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedBitcoinConfServiceHandler) WriteBitcoinConfig(context.Context, *connect.Request[v1.WriteBitcoinConfigRequest]) (*connect.Response[v1.WriteBitcoinConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.BitcoinConfService.WriteBitcoinConfig is not implemented"))
+func (h bitcoinConfServiceHandler) writeBitcoinConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WriteBitcoinConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.WriteBitcoinConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/enforcer_conf.connect.go b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/enforcer_conf.connect.go
index 46874f9337..55c4187260 100644
--- a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/enforcer_conf.connect.go
+++ b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/enforcer_conf.connect.go
@@ -5,170 +5,169 @@
 package orchestratorv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// EnforcerConfServiceName is the fully-qualified name of the EnforcerConfService service.
 	EnforcerConfServiceName = "orchestrator.v1.EnforcerConfService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// EnforcerConfServiceGetEnforcerConfigProcedure is the fully-qualified name of the
-	// EnforcerConfService's GetEnforcerConfig RPC.
+	// EnforcerConfServiceGetEnforcerConfigProcedure is the procedure name of the EnforcerConfService's
+	// GetEnforcerConfig RPC.
 	EnforcerConfServiceGetEnforcerConfigProcedure = "/orchestrator.v1.EnforcerConfService/GetEnforcerConfig"
-	// EnforcerConfServiceWriteEnforcerConfigProcedure is the fully-qualified name of the
+	// EnforcerConfServiceWriteEnforcerConfigProcedure is the procedure name of the
 	// EnforcerConfService's WriteEnforcerConfig RPC.
 	EnforcerConfServiceWriteEnforcerConfigProcedure = "/orchestrator.v1.EnforcerConfService/WriteEnforcerConfig"
-	// EnforcerConfServiceSyncNodeRpcFromBitcoinConfProcedure is the fully-qualified name of the
+	// EnforcerConfServiceSyncNodeRpcFromBitcoinConfProcedure is the procedure name of the
 	// EnforcerConfService's SyncNodeRpcFromBitcoinConf RPC.
 	EnforcerConfServiceSyncNodeRpcFromBitcoinConfProcedure = "/orchestrator.v1.EnforcerConfService/SyncNodeRpcFromBitcoinConf"
 )
 
+var (
+	enforcerConfServiceGetEnforcerConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_enforcer_conf_proto.Services().ByName("EnforcerConfService").Methods().ByName("GetEnforcerConfig"),
+			Procedure:  EnforcerConfServiceGetEnforcerConfigProcedure,
+		}
+	})
+	enforcerConfServiceWriteEnforcerConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_enforcer_conf_proto.Services().ByName("EnforcerConfService").Methods().ByName("WriteEnforcerConfig"),
+			Procedure:  EnforcerConfServiceWriteEnforcerConfigProcedure,
+		}
+	})
+	enforcerConfServiceSyncNodeRpcFromBitcoinConfSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_enforcer_conf_proto.Services().ByName("EnforcerConfService").Methods().ByName("SyncNodeRpcFromBitcoinConf"),
+			Procedure:  EnforcerConfServiceSyncNodeRpcFromBitcoinConfProcedure,
+		}
+	})
+)
+
 // EnforcerConfServiceClient is a client for the orchestrator.v1.EnforcerConfService service.
 type EnforcerConfServiceClient interface {
-	// Get current Enforcer configuration state.
-	GetEnforcerConfig(context.Context, *connect.Request[v1.GetEnforcerConfigRequest]) (*connect.Response[v1.GetEnforcerConfigResponse], error)
-	// Write Enforcer configuration content.
-	WriteEnforcerConfig(context.Context, *connect.Request[v1.WriteEnforcerConfigRequest]) (*connect.Response[v1.WriteEnforcerConfigResponse], error)
-	// Sync node-rpc settings from Bitcoin Core config.
-	SyncNodeRpcFromBitcoinConf(context.Context, *connect.Request[v1.SyncNodeRpcFromBitcoinConfRequest]) (*connect.Response[v1.SyncNodeRpcFromBitcoinConfResponse], error)
+	GetEnforcerConfig(context.Context, *v1.GetEnforcerConfigRequest) (*v1.GetEnforcerConfigResponse, error)
+	WriteEnforcerConfig(context.Context, *v1.WriteEnforcerConfigRequest) (*v1.WriteEnforcerConfigResponse, error)
+	SyncNodeRpcFromBitcoinConf(context.Context, *v1.SyncNodeRpcFromBitcoinConfRequest) (*v1.SyncNodeRpcFromBitcoinConfResponse, error)
 }
 
 // NewEnforcerConfServiceClient constructs a client for the orchestrator.v1.EnforcerConfService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewEnforcerConfServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) EnforcerConfServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	enforcerConfServiceMethods := v1.File_orchestrator_v1_enforcer_conf_proto.Services().ByName("EnforcerConfService").Methods()
-	return &enforcerConfServiceClient{
-		getEnforcerConfig: connect.NewClient[v1.GetEnforcerConfigRequest, v1.GetEnforcerConfigResponse](
-			httpClient,
-			baseURL+EnforcerConfServiceGetEnforcerConfigProcedure,
-			connect.WithSchema(enforcerConfServiceMethods.ByName("GetEnforcerConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		writeEnforcerConfig: connect.NewClient[v1.WriteEnforcerConfigRequest, v1.WriteEnforcerConfigResponse](
-			httpClient,
-			baseURL+EnforcerConfServiceWriteEnforcerConfigProcedure,
-			connect.WithSchema(enforcerConfServiceMethods.ByName("WriteEnforcerConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		syncNodeRpcFromBitcoinConf: connect.NewClient[v1.SyncNodeRpcFromBitcoinConfRequest, v1.SyncNodeRpcFromBitcoinConfResponse](
-			httpClient,
-			baseURL+EnforcerConfServiceSyncNodeRpcFromBitcoinConfProcedure,
-			connect.WithSchema(enforcerConfServiceMethods.ByName("SyncNodeRpcFromBitcoinConf")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// service. Multiple service clients may share a single connect.Client.
+func NewEnforcerConfServiceClient(client *connect.Client) EnforcerConfServiceClient {
+	return &enforcerConfServiceClient{client: client}
 }
 
-// enforcerConfServiceClient implements EnforcerConfServiceClient.
-type enforcerConfServiceClient struct {
-	getEnforcerConfig          *connect.Client[v1.GetEnforcerConfigRequest, v1.GetEnforcerConfigResponse]
-	writeEnforcerConfig        *connect.Client[v1.WriteEnforcerConfigRequest, v1.WriteEnforcerConfigResponse]
-	syncNodeRpcFromBitcoinConf *connect.Client[v1.SyncNodeRpcFromBitcoinConfRequest, v1.SyncNodeRpcFromBitcoinConfResponse]
+// EnforcerConfServiceHandler is an implementation of the orchestrator.v1.EnforcerConfService
+// service.
+type EnforcerConfServiceHandler interface {
+	GetEnforcerConfig(context.Context, *v1.GetEnforcerConfigRequest) (*v1.GetEnforcerConfigResponse, error)
+	WriteEnforcerConfig(context.Context, *v1.WriteEnforcerConfigRequest) (*v1.WriteEnforcerConfigResponse, error)
+	SyncNodeRpcFromBitcoinConf(context.Context, *v1.SyncNodeRpcFromBitcoinConfRequest) (*v1.SyncNodeRpcFromBitcoinConfResponse, error)
 }
 
-// GetEnforcerConfig calls orchestrator.v1.EnforcerConfService.GetEnforcerConfig.
-func (c *enforcerConfServiceClient) GetEnforcerConfig(ctx context.Context, req *connect.Request[v1.GetEnforcerConfigRequest]) (*connect.Response[v1.GetEnforcerConfigResponse], error) {
-	return c.getEnforcerConfig.CallUnary(ctx, req)
+// RegisterEnforcerConfServiceHandler registers svc as the orchestrator.v1.EnforcerConfService
+// implementation on server.
+func RegisterEnforcerConfServiceHandler(server *connect.Server, svc EnforcerConfServiceHandler) {
+	adapter := enforcerConfServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: enforcerConfServiceGetEnforcerConfigSpec(), Handler: adapter.getEnforcerConfig},
+		connect.Method{Spec: enforcerConfServiceWriteEnforcerConfigSpec(), Handler: adapter.writeEnforcerConfig},
+		connect.Method{Spec: enforcerConfServiceSyncNodeRpcFromBitcoinConfSpec(), Handler: adapter.syncNodeRpcFromBitcoinConf},
+	)
 }
 
-// WriteEnforcerConfig calls orchestrator.v1.EnforcerConfService.WriteEnforcerConfig.
-func (c *enforcerConfServiceClient) WriteEnforcerConfig(ctx context.Context, req *connect.Request[v1.WriteEnforcerConfigRequest]) (*connect.Response[v1.WriteEnforcerConfigResponse], error) {
-	return c.writeEnforcerConfig.CallUnary(ctx, req)
+// UnimplementedEnforcerConfServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedEnforcerConfServiceHandler struct{}
+
+func (UnimplementedEnforcerConfServiceHandler) GetEnforcerConfig(context.Context, *v1.GetEnforcerConfigRequest) (*v1.GetEnforcerConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.EnforcerConfService.GetEnforcerConfig is not implemented")
 }
 
-// SyncNodeRpcFromBitcoinConf calls orchestrator.v1.EnforcerConfService.SyncNodeRpcFromBitcoinConf.
-func (c *enforcerConfServiceClient) SyncNodeRpcFromBitcoinConf(ctx context.Context, req *connect.Request[v1.SyncNodeRpcFromBitcoinConfRequest]) (*connect.Response[v1.SyncNodeRpcFromBitcoinConfResponse], error) {
-	return c.syncNodeRpcFromBitcoinConf.CallUnary(ctx, req)
+func (UnimplementedEnforcerConfServiceHandler) WriteEnforcerConfig(context.Context, *v1.WriteEnforcerConfigRequest) (*v1.WriteEnforcerConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.EnforcerConfService.WriteEnforcerConfig is not implemented")
 }
 
-// EnforcerConfServiceHandler is an implementation of the orchestrator.v1.EnforcerConfService
-// service.
-type EnforcerConfServiceHandler interface {
-	// Get current Enforcer configuration state.
-	GetEnforcerConfig(context.Context, *connect.Request[v1.GetEnforcerConfigRequest]) (*connect.Response[v1.GetEnforcerConfigResponse], error)
-	// Write Enforcer configuration content.
-	WriteEnforcerConfig(context.Context, *connect.Request[v1.WriteEnforcerConfigRequest]) (*connect.Response[v1.WriteEnforcerConfigResponse], error)
-	// Sync node-rpc settings from Bitcoin Core config.
-	SyncNodeRpcFromBitcoinConf(context.Context, *connect.Request[v1.SyncNodeRpcFromBitcoinConfRequest]) (*connect.Response[v1.SyncNodeRpcFromBitcoinConfResponse], error)
+func (UnimplementedEnforcerConfServiceHandler) SyncNodeRpcFromBitcoinConf(context.Context, *v1.SyncNodeRpcFromBitcoinConfRequest) (*v1.SyncNodeRpcFromBitcoinConfResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.EnforcerConfService.SyncNodeRpcFromBitcoinConf is not implemented")
 }
 
-// NewEnforcerConfServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewEnforcerConfServiceHandler(svc EnforcerConfServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	enforcerConfServiceMethods := v1.File_orchestrator_v1_enforcer_conf_proto.Services().ByName("EnforcerConfService").Methods()
-	enforcerConfServiceGetEnforcerConfigHandler := connect.NewUnaryHandler(
-		EnforcerConfServiceGetEnforcerConfigProcedure,
-		svc.GetEnforcerConfig,
-		connect.WithSchema(enforcerConfServiceMethods.ByName("GetEnforcerConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	enforcerConfServiceWriteEnforcerConfigHandler := connect.NewUnaryHandler(
-		EnforcerConfServiceWriteEnforcerConfigProcedure,
-		svc.WriteEnforcerConfig,
-		connect.WithSchema(enforcerConfServiceMethods.ByName("WriteEnforcerConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	enforcerConfServiceSyncNodeRpcFromBitcoinConfHandler := connect.NewUnaryHandler(
-		EnforcerConfServiceSyncNodeRpcFromBitcoinConfProcedure,
-		svc.SyncNodeRpcFromBitcoinConf,
-		connect.WithSchema(enforcerConfServiceMethods.ByName("SyncNodeRpcFromBitcoinConf")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/orchestrator.v1.EnforcerConfService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case EnforcerConfServiceGetEnforcerConfigProcedure:
-			enforcerConfServiceGetEnforcerConfigHandler.ServeHTTP(w, r)
-		case EnforcerConfServiceWriteEnforcerConfigProcedure:
-			enforcerConfServiceWriteEnforcerConfigHandler.ServeHTTP(w, r)
-		case EnforcerConfServiceSyncNodeRpcFromBitcoinConfProcedure:
-			enforcerConfServiceSyncNodeRpcFromBitcoinConfHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type enforcerConfServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedEnforcerConfServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedEnforcerConfServiceHandler struct{}
+func (c *enforcerConfServiceClient) GetEnforcerConfig(ctx context.Context, req *v1.GetEnforcerConfigRequest) (*v1.GetEnforcerConfigResponse, error) {
+	var res v1.GetEnforcerConfigResponse
+	if err := c.client.CallUnary(ctx, enforcerConfServiceGetEnforcerConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedEnforcerConfServiceHandler) GetEnforcerConfig(context.Context, *connect.Request[v1.GetEnforcerConfigRequest]) (*connect.Response[v1.GetEnforcerConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.EnforcerConfService.GetEnforcerConfig is not implemented"))
+func (c *enforcerConfServiceClient) WriteEnforcerConfig(ctx context.Context, req *v1.WriteEnforcerConfigRequest) (*v1.WriteEnforcerConfigResponse, error) {
+	var res v1.WriteEnforcerConfigResponse
+	if err := c.client.CallUnary(ctx, enforcerConfServiceWriteEnforcerConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedEnforcerConfServiceHandler) WriteEnforcerConfig(context.Context, *connect.Request[v1.WriteEnforcerConfigRequest]) (*connect.Response[v1.WriteEnforcerConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.EnforcerConfService.WriteEnforcerConfig is not implemented"))
+func (c *enforcerConfServiceClient) SyncNodeRpcFromBitcoinConf(ctx context.Context, req *v1.SyncNodeRpcFromBitcoinConfRequest) (*v1.SyncNodeRpcFromBitcoinConfResponse, error) {
+	var res v1.SyncNodeRpcFromBitcoinConfResponse
+	if err := c.client.CallUnary(ctx, enforcerConfServiceSyncNodeRpcFromBitcoinConfSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedEnforcerConfServiceHandler) SyncNodeRpcFromBitcoinConf(context.Context, *connect.Request[v1.SyncNodeRpcFromBitcoinConfRequest]) (*connect.Response[v1.SyncNodeRpcFromBitcoinConfResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.EnforcerConfService.SyncNodeRpcFromBitcoinConf is not implemented"))
+type enforcerConfServiceHandler struct{ svc EnforcerConfServiceHandler }
+
+func (h enforcerConfServiceHandler) getEnforcerConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetEnforcerConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetEnforcerConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h enforcerConfServiceHandler) writeEnforcerConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WriteEnforcerConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.WriteEnforcerConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h enforcerConfServiceHandler) syncNodeRpcFromBitcoinConf(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SyncNodeRpcFromBitcoinConfRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SyncNodeRpcFromBitcoinConf(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/orchestrator.connect.go b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/orchestrator.connect.go
index c077807212..32706a1010 100644
--- a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/orchestrator.connect.go
+++ b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/orchestrator.connect.go
@@ -5,1346 +5,1592 @@
 package orchestratorv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// OrchestratorServiceName is the fully-qualified name of the OrchestratorService service.
 	OrchestratorServiceName = "orchestrator.v1.OrchestratorService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// OrchestratorServiceListBinariesProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceListBinariesProcedure is the procedure name of the OrchestratorService's
 	// ListBinaries RPC.
 	OrchestratorServiceListBinariesProcedure = "/orchestrator.v1.OrchestratorService/ListBinaries"
-	// OrchestratorServiceGetBinaryStatusProcedure is the fully-qualified name of the
-	// OrchestratorService's GetBinaryStatus RPC.
+	// OrchestratorServiceGetBinaryStatusProcedure is the procedure name of the OrchestratorService's
+	// GetBinaryStatus RPC.
 	OrchestratorServiceGetBinaryStatusProcedure = "/orchestrator.v1.OrchestratorService/GetBinaryStatus"
-	// OrchestratorServiceGetBinaryVersionProcedure is the fully-qualified name of the
-	// OrchestratorService's GetBinaryVersion RPC.
+	// OrchestratorServiceGetBinaryVersionProcedure is the procedure name of the OrchestratorService's
+	// GetBinaryVersion RPC.
 	OrchestratorServiceGetBinaryVersionProcedure = "/orchestrator.v1.OrchestratorService/GetBinaryVersion"
-	// OrchestratorServiceDownloadBinaryProcedure is the fully-qualified name of the
-	// OrchestratorService's DownloadBinary RPC.
+	// OrchestratorServiceDownloadBinaryProcedure is the procedure name of the OrchestratorService's
+	// DownloadBinary RPC.
 	OrchestratorServiceDownloadBinaryProcedure = "/orchestrator.v1.OrchestratorService/DownloadBinary"
-	// OrchestratorServiceStartBinaryProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceStartBinaryProcedure is the procedure name of the OrchestratorService's
 	// StartBinary RPC.
 	OrchestratorServiceStartBinaryProcedure = "/orchestrator.v1.OrchestratorService/StartBinary"
-	// OrchestratorServiceStopBinaryProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceStopBinaryProcedure is the procedure name of the OrchestratorService's
 	// StopBinary RPC.
 	OrchestratorServiceStopBinaryProcedure = "/orchestrator.v1.OrchestratorService/StopBinary"
-	// OrchestratorServiceStreamLogsProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceStreamLogsProcedure is the procedure name of the OrchestratorService's
 	// StreamLogs RPC.
 	OrchestratorServiceStreamLogsProcedure = "/orchestrator.v1.OrchestratorService/StreamLogs"
-	// OrchestratorServiceStartWithL1Procedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceStartWithL1Procedure is the procedure name of the OrchestratorService's
 	// StartWithL1 RPC.
 	OrchestratorServiceStartWithL1Procedure = "/orchestrator.v1.OrchestratorService/StartWithL1"
-	// OrchestratorServiceRestartDaemonProcedure is the fully-qualified name of the
-	// OrchestratorService's RestartDaemon RPC.
+	// OrchestratorServiceRestartDaemonProcedure is the procedure name of the OrchestratorService's
+	// RestartDaemon RPC.
 	OrchestratorServiceRestartDaemonProcedure = "/orchestrator.v1.OrchestratorService/RestartDaemon"
-	// OrchestratorServiceRestartL1Procedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceRestartL1Procedure is the procedure name of the OrchestratorService's
 	// RestartL1 RPC.
 	OrchestratorServiceRestartL1Procedure = "/orchestrator.v1.OrchestratorService/RestartL1"
-	// OrchestratorServiceApplyUTXOSnapshotProcedure is the fully-qualified name of the
-	// OrchestratorService's ApplyUTXOSnapshot RPC.
+	// OrchestratorServiceApplyUTXOSnapshotProcedure is the procedure name of the OrchestratorService's
+	// ApplyUTXOSnapshot RPC.
 	OrchestratorServiceApplyUTXOSnapshotProcedure = "/orchestrator.v1.OrchestratorService/ApplyUTXOSnapshot"
-	// OrchestratorServiceGetSnapshotStatusProcedure is the fully-qualified name of the
-	// OrchestratorService's GetSnapshotStatus RPC.
+	// OrchestratorServiceGetSnapshotStatusProcedure is the procedure name of the OrchestratorService's
+	// GetSnapshotStatus RPC.
 	OrchestratorServiceGetSnapshotStatusProcedure = "/orchestrator.v1.OrchestratorService/GetSnapshotStatus"
-	// OrchestratorServiceGetPendingNetworkGenerationProcedure is the fully-qualified name of the
+	// OrchestratorServiceGetPendingNetworkGenerationProcedure is the procedure name of the
 	// OrchestratorService's GetPendingNetworkGeneration RPC.
 	OrchestratorServiceGetPendingNetworkGenerationProcedure = "/orchestrator.v1.OrchestratorService/GetPendingNetworkGeneration"
-	// OrchestratorServiceConfirmPendingNetworkGenerationProcedure is the fully-qualified name of the
+	// OrchestratorServiceConfirmPendingNetworkGenerationProcedure is the procedure name of the
 	// OrchestratorService's ConfirmPendingNetworkGeneration RPC.
 	OrchestratorServiceConfirmPendingNetworkGenerationProcedure = "/orchestrator.v1.OrchestratorService/ConfirmPendingNetworkGeneration"
-	// OrchestratorServiceShutdownAllProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceShutdownAllProcedure is the procedure name of the OrchestratorService's
 	// ShutdownAll RPC.
 	OrchestratorServiceShutdownAllProcedure = "/orchestrator.v1.OrchestratorService/ShutdownAll"
-	// OrchestratorServiceShutdownProcedure is the fully-qualified name of the OrchestratorService's
-	// Shutdown RPC.
+	// OrchestratorServiceShutdownProcedure is the procedure name of the OrchestratorService's Shutdown
+	// RPC.
 	OrchestratorServiceShutdownProcedure = "/orchestrator.v1.OrchestratorService/Shutdown"
-	// OrchestratorServiceAdoptOwnerProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceAdoptOwnerProcedure is the procedure name of the OrchestratorService's
 	// AdoptOwner RPC.
 	OrchestratorServiceAdoptOwnerProcedure = "/orchestrator.v1.OrchestratorService/AdoptOwner"
-	// OrchestratorServiceGetBTCPriceProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceGetBTCPriceProcedure is the procedure name of the OrchestratorService's
 	// GetBTCPrice RPC.
 	OrchestratorServiceGetBTCPriceProcedure = "/orchestrator.v1.OrchestratorService/GetBTCPrice"
-	// OrchestratorServiceGetMainchainBlockchainInfoProcedure is the fully-qualified name of the
+	// OrchestratorServiceGetMainchainBlockchainInfoProcedure is the procedure name of the
 	// OrchestratorService's GetMainchainBlockchainInfo RPC.
 	OrchestratorServiceGetMainchainBlockchainInfoProcedure = "/orchestrator.v1.OrchestratorService/GetMainchainBlockchainInfo"
-	// OrchestratorServiceGetEnforcerBlockchainInfoProcedure is the fully-qualified name of the
+	// OrchestratorServiceGetEnforcerBlockchainInfoProcedure is the procedure name of the
 	// OrchestratorService's GetEnforcerBlockchainInfo RPC.
 	OrchestratorServiceGetEnforcerBlockchainInfoProcedure = "/orchestrator.v1.OrchestratorService/GetEnforcerBlockchainInfo"
-	// OrchestratorServiceGetSyncStatusProcedure is the fully-qualified name of the
-	// OrchestratorService's GetSyncStatus RPC.
+	// OrchestratorServiceGetSyncStatusProcedure is the procedure name of the OrchestratorService's
+	// GetSyncStatus RPC.
 	OrchestratorServiceGetSyncStatusProcedure = "/orchestrator.v1.OrchestratorService/GetSyncStatus"
-	// OrchestratorServiceGetDownloadStatusProcedure is the fully-qualified name of the
-	// OrchestratorService's GetDownloadStatus RPC.
+	// OrchestratorServiceGetDownloadStatusProcedure is the procedure name of the OrchestratorService's
+	// GetDownloadStatus RPC.
 	OrchestratorServiceGetDownloadStatusProcedure = "/orchestrator.v1.OrchestratorService/GetDownloadStatus"
-	// OrchestratorServiceGetMainchainBalanceProcedure is the fully-qualified name of the
+	// OrchestratorServiceGetMainchainBalanceProcedure is the procedure name of the
 	// OrchestratorService's GetMainchainBalance RPC.
 	OrchestratorServiceGetMainchainBalanceProcedure = "/orchestrator.v1.OrchestratorService/GetMainchainBalance"
-	// OrchestratorServiceGetSidechainBalanceProcedure is the fully-qualified name of the
+	// OrchestratorServiceGetSidechainBalanceProcedure is the procedure name of the
 	// OrchestratorService's GetSidechainBalance RPC.
 	OrchestratorServiceGetSidechainBalanceProcedure = "/orchestrator.v1.OrchestratorService/GetSidechainBalance"
-	// OrchestratorServiceGatherFilesToDeleteProcedure is the fully-qualified name of the
+	// OrchestratorServiceGatherFilesToDeleteProcedure is the procedure name of the
 	// OrchestratorService's GatherFilesToDelete RPC.
 	OrchestratorServiceGatherFilesToDeleteProcedure = "/orchestrator.v1.OrchestratorService/GatherFilesToDelete"
-	// OrchestratorServiceDeleteFilesProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceDeleteFilesProcedure is the procedure name of the OrchestratorService's
 	// DeleteFiles RPC.
 	OrchestratorServiceDeleteFilesProcedure = "/orchestrator.v1.OrchestratorService/DeleteFiles"
-	// OrchestratorServiceRejectBlockProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceRejectBlockProcedure is the procedure name of the OrchestratorService's
 	// RejectBlock RPC.
 	OrchestratorServiceRejectBlockProcedure = "/orchestrator.v1.OrchestratorService/RejectBlock"
-	// OrchestratorServiceAcceptBlockProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceAcceptBlockProcedure is the procedure name of the OrchestratorService's
 	// AcceptBlock RPC.
 	OrchestratorServiceAcceptBlockProcedure = "/orchestrator.v1.OrchestratorService/AcceptBlock"
-	// OrchestratorServiceResetToBlockProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceResetToBlockProcedure is the procedure name of the OrchestratorService's
 	// ResetToBlock RPC.
 	OrchestratorServiceResetToBlockProcedure = "/orchestrator.v1.OrchestratorService/ResetToBlock"
-	// OrchestratorServiceGetCoreMempoolInfoProcedure is the fully-qualified name of the
-	// OrchestratorService's GetCoreMempoolInfo RPC.
+	// OrchestratorServiceGetCoreMempoolInfoProcedure is the procedure name of the OrchestratorService's
+	// GetCoreMempoolInfo RPC.
 	OrchestratorServiceGetCoreMempoolInfoProcedure = "/orchestrator.v1.OrchestratorService/GetCoreMempoolInfo"
-	// OrchestratorServiceGetBmmContextProcedure is the fully-qualified name of the
-	// OrchestratorService's GetBmmContext RPC.
+	// OrchestratorServiceGetBmmContextProcedure is the procedure name of the OrchestratorService's
+	// GetBmmContext RPC.
 	OrchestratorServiceGetBmmContextProcedure = "/orchestrator.v1.OrchestratorService/GetBmmContext"
-	// OrchestratorServiceCoreRawCallProcedure is the fully-qualified name of the OrchestratorService's
+	// OrchestratorServiceCoreRawCallProcedure is the procedure name of the OrchestratorService's
 	// CoreRawCall RPC.
 	OrchestratorServiceCoreRawCallProcedure = "/orchestrator.v1.OrchestratorService/CoreRawCall"
-	// OrchestratorServiceGetForkStatusProcedure is the fully-qualified name of the
-	// OrchestratorService's GetForkStatus RPC.
+	// OrchestratorServiceGetForkStatusProcedure is the procedure name of the OrchestratorService's
+	// GetForkStatus RPC.
 	OrchestratorServiceGetForkStatusProcedure = "/orchestrator.v1.OrchestratorService/GetForkStatus"
-	// OrchestratorServicePreviewECashMigrationProcedure is the fully-qualified name of the
+	// OrchestratorServicePreviewECashMigrationProcedure is the procedure name of the
 	// OrchestratorService's PreviewECashMigration RPC.
 	OrchestratorServicePreviewECashMigrationProcedure = "/orchestrator.v1.OrchestratorService/PreviewECashMigration"
-	// OrchestratorServiceStartECashMigrationProcedure is the fully-qualified name of the
+	// OrchestratorServiceStartECashMigrationProcedure is the procedure name of the
 	// OrchestratorService's StartECashMigration RPC.
 	OrchestratorServiceStartECashMigrationProcedure = "/orchestrator.v1.OrchestratorService/StartECashMigration"
-	// OrchestratorServiceGetECashMigrationStatusProcedure is the fully-qualified name of the
+	// OrchestratorServiceGetECashMigrationStatusProcedure is the procedure name of the
 	// OrchestratorService's GetECashMigrationStatus RPC.
 	OrchestratorServiceGetECashMigrationStatusProcedure = "/orchestrator.v1.OrchestratorService/GetECashMigrationStatus"
-	// OrchestratorServiceGetDatadirNetworkProcedure is the fully-qualified name of the
-	// OrchestratorService's GetDatadirNetwork RPC.
+	// OrchestratorServiceGetDatadirNetworkProcedure is the procedure name of the OrchestratorService's
+	// GetDatadirNetwork RPC.
 	OrchestratorServiceGetDatadirNetworkProcedure = "/orchestrator.v1.OrchestratorService/GetDatadirNetwork"
 )
 
+var (
+	orchestratorServiceListBinariesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("ListBinaries"),
+			Procedure:  OrchestratorServiceListBinariesProcedure,
+		}
+	})
+	orchestratorServiceGetBinaryStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetBinaryStatus"),
+			Procedure:  OrchestratorServiceGetBinaryStatusProcedure,
+		}
+	})
+	orchestratorServiceGetBinaryVersionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetBinaryVersion"),
+			Procedure:  OrchestratorServiceGetBinaryVersionProcedure,
+		}
+	})
+	orchestratorServiceDownloadBinarySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("DownloadBinary"),
+			Procedure:  OrchestratorServiceDownloadBinaryProcedure,
+		}
+	})
+	orchestratorServiceStartBinarySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("StartBinary"),
+			Procedure:  OrchestratorServiceStartBinaryProcedure,
+		}
+	})
+	orchestratorServiceStopBinarySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("StopBinary"),
+			Procedure:  OrchestratorServiceStopBinaryProcedure,
+		}
+	})
+	orchestratorServiceStreamLogsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("StreamLogs"),
+			Procedure:  OrchestratorServiceStreamLogsProcedure,
+		}
+	})
+	orchestratorServiceStartWithL1Spec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("StartWithL1"),
+			Procedure:  OrchestratorServiceStartWithL1Procedure,
+		}
+	})
+	orchestratorServiceRestartDaemonSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("RestartDaemon"),
+			Procedure:  OrchestratorServiceRestartDaemonProcedure,
+		}
+	})
+	orchestratorServiceRestartL1Spec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("RestartL1"),
+			Procedure:  OrchestratorServiceRestartL1Procedure,
+		}
+	})
+	orchestratorServiceApplyUTXOSnapshotSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("ApplyUTXOSnapshot"),
+			Procedure:  OrchestratorServiceApplyUTXOSnapshotProcedure,
+		}
+	})
+	orchestratorServiceGetSnapshotStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetSnapshotStatus"),
+			Procedure:  OrchestratorServiceGetSnapshotStatusProcedure,
+		}
+	})
+	orchestratorServiceGetPendingNetworkGenerationSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetPendingNetworkGeneration"),
+			Procedure:  OrchestratorServiceGetPendingNetworkGenerationProcedure,
+		}
+	})
+	orchestratorServiceConfirmPendingNetworkGenerationSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("ConfirmPendingNetworkGeneration"),
+			Procedure:  OrchestratorServiceConfirmPendingNetworkGenerationProcedure,
+		}
+	})
+	orchestratorServiceShutdownAllSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("ShutdownAll"),
+			Procedure:  OrchestratorServiceShutdownAllProcedure,
+		}
+	})
+	orchestratorServiceShutdownSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("Shutdown"),
+			Procedure:  OrchestratorServiceShutdownProcedure,
+		}
+	})
+	orchestratorServiceAdoptOwnerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("AdoptOwner"),
+			Procedure:  OrchestratorServiceAdoptOwnerProcedure,
+		}
+	})
+	orchestratorServiceGetBTCPriceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetBTCPrice"),
+			Procedure:  OrchestratorServiceGetBTCPriceProcedure,
+		}
+	})
+	orchestratorServiceGetMainchainBlockchainInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetMainchainBlockchainInfo"),
+			Procedure:  OrchestratorServiceGetMainchainBlockchainInfoProcedure,
+		}
+	})
+	orchestratorServiceGetEnforcerBlockchainInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetEnforcerBlockchainInfo"),
+			Procedure:  OrchestratorServiceGetEnforcerBlockchainInfoProcedure,
+		}
+	})
+	orchestratorServiceGetSyncStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetSyncStatus"),
+			Procedure:  OrchestratorServiceGetSyncStatusProcedure,
+		}
+	})
+	orchestratorServiceGetDownloadStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetDownloadStatus"),
+			Procedure:  OrchestratorServiceGetDownloadStatusProcedure,
+		}
+	})
+	orchestratorServiceGetMainchainBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetMainchainBalance"),
+			Procedure:  OrchestratorServiceGetMainchainBalanceProcedure,
+		}
+	})
+	orchestratorServiceGetSidechainBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetSidechainBalance"),
+			Procedure:  OrchestratorServiceGetSidechainBalanceProcedure,
+		}
+	})
+	orchestratorServiceGatherFilesToDeleteSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GatherFilesToDelete"),
+			Procedure:  OrchestratorServiceGatherFilesToDeleteProcedure,
+		}
+	})
+	orchestratorServiceDeleteFilesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("DeleteFiles"),
+			Procedure:  OrchestratorServiceDeleteFilesProcedure,
+		}
+	})
+	orchestratorServiceRejectBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("RejectBlock"),
+			Procedure:  OrchestratorServiceRejectBlockProcedure,
+		}
+	})
+	orchestratorServiceAcceptBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("AcceptBlock"),
+			Procedure:  OrchestratorServiceAcceptBlockProcedure,
+		}
+	})
+	orchestratorServiceResetToBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("ResetToBlock"),
+			Procedure:  OrchestratorServiceResetToBlockProcedure,
+		}
+	})
+	orchestratorServiceGetCoreMempoolInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetCoreMempoolInfo"),
+			Procedure:  OrchestratorServiceGetCoreMempoolInfoProcedure,
+		}
+	})
+	orchestratorServiceGetBmmContextSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetBmmContext"),
+			Procedure:  OrchestratorServiceGetBmmContextProcedure,
+		}
+	})
+	orchestratorServiceCoreRawCallSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("CoreRawCall"),
+			Procedure:  OrchestratorServiceCoreRawCallProcedure,
+		}
+	})
+	orchestratorServiceGetForkStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetForkStatus"),
+			Procedure:  OrchestratorServiceGetForkStatusProcedure,
+		}
+	})
+	orchestratorServicePreviewECashMigrationSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("PreviewECashMigration"),
+			Procedure:  OrchestratorServicePreviewECashMigrationProcedure,
+		}
+	})
+	orchestratorServiceStartECashMigrationSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("StartECashMigration"),
+			Procedure:  OrchestratorServiceStartECashMigrationProcedure,
+		}
+	})
+	orchestratorServiceGetECashMigrationStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetECashMigrationStatus"),
+			Procedure:  OrchestratorServiceGetECashMigrationStatusProcedure,
+		}
+	})
+	orchestratorServiceGetDatadirNetworkSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods().ByName("GetDatadirNetwork"),
+			Procedure:  OrchestratorServiceGetDatadirNetworkProcedure,
+		}
+	})
+)
+
 // OrchestratorServiceClient is a client for the orchestrator.v1.OrchestratorService service.
 type OrchestratorServiceClient interface {
-	// List all configured binaries and their status.
-	ListBinaries(context.Context, *connect.Request[v1.ListBinariesRequest]) (*connect.Response[v1.ListBinariesResponse], error)
-	// Get the status of a single binary.
-	GetBinaryStatus(context.Context, *connect.Request[v1.GetBinaryStatusRequest]) (*connect.Response[v1.GetBinaryStatusResponse], error)
-	// Resolve a binary's on-disk path the same way the launcher does (variant-
-	// and test-build aware, honoring force_backend) and return its --version
-	// output. The frontend must never re-derive the path or shell out itself;
-	// this RPC is the single source of truth for "which binary, what version".
-	GetBinaryVersion(context.Context, *connect.Request[v1.GetBinaryVersionRequest]) (*connect.Response[v1.GetBinaryVersionResponse], error)
-	// Download a binary with streaming progress.
-	// Kicks off a download in a background goroutine and returns
-	// immediately. Progress (MB downloaded / total, is_downloading) is
-	// polled out of GetSyncStatus, never tied to this RPC's lifetime — so
-	// a transport blip can't cancel an in-flight download.
-	DownloadBinary(context.Context, *connect.Request[v1.DownloadBinaryRequest]) (*connect.Response[v1.DownloadBinaryResponse], error)
-	// Start a binary.
-	StartBinary(context.Context, *connect.Request[v1.StartBinaryRequest]) (*connect.Response[v1.StartBinaryResponse], error)
-	// Stop a binary.
-	StopBinary(context.Context, *connect.Request[v1.StopBinaryRequest]) (*connect.Response[v1.StopBinaryResponse], error)
-	// Stream stdout/stderr from a binary.
-	StreamLogs(context.Context, *connect.Request[v1.StreamLogsRequest]) (*connect.ServerStreamForClient[v1.StreamLogsResponse], error)
-	// Kick off a binary and its full L1 dependency chain (Core -> Enforcer ->
-	// target). Fire-and-forget on the server: returns as soon as the boot
-	// goroutine is dispatched. Callers poll GetSyncStatus / ListBinaries for
-	// download progress and connection state — never tied to this RPC's
-	// lifetime, so a transport blip can't kill an in-flight download.
-	StartWithL1(context.Context, *connect.Request[v1.StartWithL1Request]) (*connect.Response[v1.StartWithL1Response], error)
-	// Stop the named binary and start it again, single-daemon scope. Never
-	// touches sibling daemons: restarting "enforcer" never spawns or adopts
-	// bitcoind. Use this for per-daemon "Restart" buttons on UI cards;
-	// StartWithL1 stays the entry point for full-chain bootstrap. Same
-	// fire-and-forget shape as StartWithL1.
-	RestartDaemon(context.Context, *connect.Request[v1.RestartDaemonRequest]) (*connect.Response[v1.RestartDaemonResponse], error)
-	// Restart the whole L1 stack (bitcoind + enforcer) on the current config.
-	// Stops both (a not-running daemon is skipped, never an error) then boots
-	// the L1 chain via the same path as StartWithL1. Running sidechains are left
-	// alone — they reconnect once the enforcer is back. Fire-and-forget: returns
-	// as soon as the boot goroutine is dispatched. Use this for the "Restart
-	// Bitcoin Core and Enforcer" UI flow instead of hand-sequencing stop/start.
-	RestartL1(context.Context, *connect.Request[v1.RestartL1Request]) (*connect.Response[v1.RestartL1Response], error)
-	// Load a UTXO snapshot into the running Bitcoin Core. Streams download and
-	// load progress; a snapshot Core refuses (its base block already passed, or
-	// a snapshot already loaded in this datadir) comes back as an error carrying
-	// Core's own message. Nothing is stopped, restarted or deleted.
-	ApplyUTXOSnapshot(context.Context, *connect.Request[v1.ApplyUTXOSnapshotRequest]) (*connect.ServerStreamForClient[v1.ApplyUTXOSnapshotResponse], error)
-	// The UTXO snapshot published for the active network (from the network
-	// catalog) plus the one currently loaded in Bitcoin Core, if any. Feeds the
-	// settings UI: pre-fills the snapshot field and shows what is loaded.
-	GetSnapshotStatus(context.Context, *connect.Request[v1.GetSnapshotStatusRequest]) (*connect.Response[v1.GetSnapshotStatusResponse], error)
-	// The eCash network published but not switched to yet. Feeds the upgrade
-	// prompt; pending_network_id is empty when already on the newest one.
-	GetPendingNetworkGeneration(context.Context, *connect.Request[v1.GetPendingNetworkGenerationRequest]) (*connect.Response[v1.GetPendingNetworkGenerationResponse], error)
-	// Record the user's go-ahead to switch to the published eCash network.
-	// Nothing is stopped or deleted here: the caller must restart the backends,
-	// and the switch runs on the next start. Wallets survive, chain history and
-	// its transactions do not — only call with the user's confirmation.
-	ConfirmPendingNetworkGeneration(context.Context, *connect.Request[v1.ConfirmPendingNetworkGenerationRequest]) (*connect.Response[v1.ConfirmPendingNetworkGenerationResponse], error)
-	// Shutdown all running binaries.
-	ShutdownAll(context.Context, *connect.Request[v1.ShutdownAllRequest]) (*connect.ServerStreamForClient[v1.ShutdownAllResponse], error)
-	// Detached-daemon shutdown. bitwindowd calls this on window close;
-	// drivechaind acks immediately, drains its children (bitcoind, enforcer,
-	// sidechains) in a background goroutine, and os.Exit(0)s when done.
-	// Idempotent. If bitwindow is relaunched while the drain is still in
-	// flight, the next StartWithL1 transparently adopts it (flips the
-	// will-exit bit + awaits the in-flight stops) before booting a fresh
-	// stack — no separate cancel/await RPCs needed by callers.
-	Shutdown(context.Context, *connect.Request[v1.ShutdownRequest]) (*connect.Response[v1.ShutdownResponse], error)
-	// Point the daemon at the frontend process that owns it now. An app update
-	// replaces the frontend with a new process, and the daemon drains itself a
-	// few seconds after the old one dies. bitwindowd calls this the moment it
-	// finds a live daemon, so the warm stack survives the swap.
-	AdoptOwner(context.Context, *connect.Request[v1.AdoptOwnerRequest]) (*connect.Response[v1.AdoptOwnerResponse], error)
-	// Get the current BTC/USD exchange rate.
-	GetBTCPrice(context.Context, *connect.Request[v1.GetBTCPriceRequest]) (*connect.Response[v1.GetBTCPriceResponse], error)
-	// Get blockchain info from Bitcoin Core (proxied via orchestrator).
-	GetMainchainBlockchainInfo(context.Context, *connect.Request[v1.GetMainchainBlockchainInfoRequest]) (*connect.Response[v1.GetMainchainBlockchainInfoResponse], error)
-	// Get blockchain info from the enforcer (proxied via orchestrator).
-	GetEnforcerBlockchainInfo(context.Context, *connect.Request[v1.GetEnforcerBlockchainInfoRequest]) (*connect.Response[v1.GetEnforcerBlockchainInfoResponse], error)
-	// One-shot snapshot of mainchain + enforcer + bitwindow daemon sync state.
-	// Backend fans out to all three in parallel so the three numbers are taken
-	// at the same wall-clock instant — no two cards in the UI can ever disagree.
-	GetSyncStatus(context.Context, *connect.Request[v1.GetSyncStatusRequest]) (*connect.Response[v1.GetSyncStatusResponse], error)
-	// Snapshot of every binary the orchestrator is currently downloading.
-	// Reads from the in-memory DownloadManager state — light, polled by the
-	// frontend's DownloadProvider on a fast (100ms) cadence while a download
-	// is in flight, and dropping back to 2s when the response is empty.
-	GetDownloadStatus(context.Context, *connect.Request[v1.GetDownloadStatusRequest]) (*connect.Response[v1.GetDownloadStatusResponse], error)
-	// Get wallet balance from Bitcoin Core (proxied via orchestrator).
-	GetMainchainBalance(context.Context, *connect.Request[v1.GetMainchainBalanceRequest]) (*connect.Response[v1.GetMainchainBalanceResponse], error)
-	// Get wallet balance from a sidechain daemon (proxied via orchestrator).
-	GetSidechainBalance(context.Context, *connect.Request[v1.GetSidechainBalanceRequest]) (*connect.Response[v1.GetSidechainBalanceResponse], error)
-	// Gather the files/dirs that would be deleted for a per-binary deletion spec
-	// (no side effects). Shared by the single-binary wipe and the full reset page.
-	GatherFilesToDelete(context.Context, *connect.Request[v1.GatherFilesToDeleteRequest]) (*connect.Response[v1.GatherFilesToDeleteResponse], error)
-	// Delete the selected files. Stops binaries first; wallet paths are moved to
-	// wallet_backups/ instead of removed. Returns a gRPC error if it can't run.
-	// Streams one message per path; an unset error means that path succeeded.
-	DeleteFiles(context.Context, *connect.Request[v1.DeleteFilesRequest]) (*connect.ServerStreamForClient[v1.DeleteFilesResponse], error)
-	// Drop a block Core must not follow. Core rejects it and every block above
-	// it, then follows the best remaining valid branch.
-	RejectBlock(context.Context, *connect.Request[v1.RejectBlockRequest]) (*connect.Response[v1.RejectBlockResponse], error)
-	// Undo RejectBlock. Core re-checks the block and its branch, and follows it
-	// again when it has the most work.
-	AcceptBlock(context.Context, *connect.Request[v1.AcceptBlockRequest]) (*connect.Response[v1.AcceptBlockResponse], error)
-	// Move the chain back to a block, then sync forward to the tip again. Core
-	// drops the block and every block above it, then re-validates them from
-	// disk. Streams one message per phase.
-	ResetToBlock(context.Context, *connect.Request[v1.ResetToBlockRequest]) (*connect.ServerStreamForClient[v1.ResetToBlockResponse], error)
-	// Full bitcoind getmempoolinfo response. Distinct from getrawmempool.
-	GetCoreMempoolInfo(context.Context, *connect.Request[v1.GetCoreMempoolInfoRequest]) (*connect.Response[v1.GetCoreMempoolInfoResponse], error)
-	// Parent-chain state the sidechain BMM tab bids against: the tip a request
-	// targets, the fee rate it competes with, mempool depth.
-	GetBmmContext(context.Context, *connect.Request[v1.GetBmmContextRequest]) (*connect.Response[v1.GetBmmContextResponse], error)
-	// Generic raw bitcoind RPC. Optional `wallet` field routes the call to
-	// /wallet/{name} on bitcoind for wallet-scoped RPCs.
-	CoreRawCall(context.Context, *connect.Request[v1.CoreRawCallRequest]) (*connect.Response[v1.CoreRawCallResponse], error)
-	// ─── eCash fork ───────────────────────────────────────────────────────────
-	// Report where the mainchain tip sits relative to the eCash fork height.
-	// The orchestrator is the single source of truth for the fork height; the
-	// frontend renders "fork mode" (the claim card) off fork_active. Per-wallet
-	// pre-fork coin detection and the sweep itself stay in the frontend via the
-	// existing WalletManagerService (listUnspent / sendTransaction), one call
-	// per wallet — this RPC only supplies the height.
-	GetForkStatus(context.Context, *connect.Request[v1.GetForkStatusRequest]) (*connect.Response[v1.GetForkStatusResponse], error)
-	// Read the migration plan from the daemon without changes to node files.
-	PreviewECashMigration(context.Context, *connect.Request[v1.PreviewECashMigrationRequest]) (*connect.Response[v1.PreviewECashMigrationResponse], error)
-	// Start or resume a migration that continues after the client disconnects.
-	StartECashMigration(context.Context, *connect.Request[v1.StartECashMigrationRequest]) (*connect.Response[v1.StartECashMigrationResponse], error)
-	// Read the saved migration state from the daemon.
-	GetECashMigrationStatus(context.Context, *connect.Request[v1.GetECashMigrationStatusRequest]) (*connect.Response[v1.GetECashMigrationStatusResponse], error)
-	// Read the network the blocks on disk belong to, next to the one the app
-	// runs. The blocks name the chain, so a datadir from another network says so
-	// before a rollback throws the balance away.
-	GetDatadirNetwork(context.Context, *connect.Request[v1.GetDatadirNetworkRequest]) (*connect.Response[v1.GetDatadirNetworkResponse], error)
+	ListBinaries(context.Context, *v1.ListBinariesRequest) (*v1.ListBinariesResponse, error)
+	GetBinaryStatus(context.Context, *v1.GetBinaryStatusRequest) (*v1.GetBinaryStatusResponse, error)
+	GetBinaryVersion(context.Context, *v1.GetBinaryVersionRequest) (*v1.GetBinaryVersionResponse, error)
+	DownloadBinary(context.Context, *v1.DownloadBinaryRequest) (*v1.DownloadBinaryResponse, error)
+	StartBinary(context.Context, *v1.StartBinaryRequest) (*v1.StartBinaryResponse, error)
+	StopBinary(context.Context, *v1.StopBinaryRequest) (*v1.StopBinaryResponse, error)
+	StreamLogs(context.Context, *v1.StreamLogsRequest) (OrchestratorServiceStreamLogsClientStream, error)
+	StartWithL1(context.Context, *v1.StartWithL1Request) (*v1.StartWithL1Response, error)
+	RestartDaemon(context.Context, *v1.RestartDaemonRequest) (*v1.RestartDaemonResponse, error)
+	RestartL1(context.Context, *v1.RestartL1Request) (*v1.RestartL1Response, error)
+	ApplyUTXOSnapshot(context.Context, *v1.ApplyUTXOSnapshotRequest) (OrchestratorServiceApplyUTXOSnapshotClientStream, error)
+	GetSnapshotStatus(context.Context, *v1.GetSnapshotStatusRequest) (*v1.GetSnapshotStatusResponse, error)
+	GetPendingNetworkGeneration(context.Context, *v1.GetPendingNetworkGenerationRequest) (*v1.GetPendingNetworkGenerationResponse, error)
+	ConfirmPendingNetworkGeneration(context.Context, *v1.ConfirmPendingNetworkGenerationRequest) (*v1.ConfirmPendingNetworkGenerationResponse, error)
+	ShutdownAll(context.Context, *v1.ShutdownAllRequest) (OrchestratorServiceShutdownAllClientStream, error)
+	Shutdown(context.Context, *v1.ShutdownRequest) (*v1.ShutdownResponse, error)
+	AdoptOwner(context.Context, *v1.AdoptOwnerRequest) (*v1.AdoptOwnerResponse, error)
+	GetBTCPrice(context.Context, *v1.GetBTCPriceRequest) (*v1.GetBTCPriceResponse, error)
+	GetMainchainBlockchainInfo(context.Context, *v1.GetMainchainBlockchainInfoRequest) (*v1.GetMainchainBlockchainInfoResponse, error)
+	GetEnforcerBlockchainInfo(context.Context, *v1.GetEnforcerBlockchainInfoRequest) (*v1.GetEnforcerBlockchainInfoResponse, error)
+	GetSyncStatus(context.Context, *v1.GetSyncStatusRequest) (*v1.GetSyncStatusResponse, error)
+	GetDownloadStatus(context.Context, *v1.GetDownloadStatusRequest) (*v1.GetDownloadStatusResponse, error)
+	GetMainchainBalance(context.Context, *v1.GetMainchainBalanceRequest) (*v1.GetMainchainBalanceResponse, error)
+	GetSidechainBalance(context.Context, *v1.GetSidechainBalanceRequest) (*v1.GetSidechainBalanceResponse, error)
+	GatherFilesToDelete(context.Context, *v1.GatherFilesToDeleteRequest) (*v1.GatherFilesToDeleteResponse, error)
+	DeleteFiles(context.Context, *v1.DeleteFilesRequest) (OrchestratorServiceDeleteFilesClientStream, error)
+	RejectBlock(context.Context, *v1.RejectBlockRequest) (*v1.RejectBlockResponse, error)
+	AcceptBlock(context.Context, *v1.AcceptBlockRequest) (*v1.AcceptBlockResponse, error)
+	ResetToBlock(context.Context, *v1.ResetToBlockRequest) (OrchestratorServiceResetToBlockClientStream, error)
+	GetCoreMempoolInfo(context.Context, *v1.GetCoreMempoolInfoRequest) (*v1.GetCoreMempoolInfoResponse, error)
+	GetBmmContext(context.Context, *v1.GetBmmContextRequest) (*v1.GetBmmContextResponse, error)
+	CoreRawCall(context.Context, *v1.CoreRawCallRequest) (*v1.CoreRawCallResponse, error)
+	GetForkStatus(context.Context, *v1.GetForkStatusRequest) (*v1.GetForkStatusResponse, error)
+	PreviewECashMigration(context.Context, *v1.PreviewECashMigrationRequest) (*v1.PreviewECashMigrationResponse, error)
+	StartECashMigration(context.Context, *v1.StartECashMigrationRequest) (*v1.StartECashMigrationResponse, error)
+	GetECashMigrationStatus(context.Context, *v1.GetECashMigrationStatusRequest) (*v1.GetECashMigrationStatusResponse, error)
+	GetDatadirNetwork(context.Context, *v1.GetDatadirNetworkRequest) (*v1.GetDatadirNetworkResponse, error)
 }
 
 // NewOrchestratorServiceClient constructs a client for the orchestrator.v1.OrchestratorService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewOrchestratorServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) OrchestratorServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	orchestratorServiceMethods := v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods()
-	return &orchestratorServiceClient{
-		listBinaries: connect.NewClient[v1.ListBinariesRequest, v1.ListBinariesResponse](
-			httpClient,
-			baseURL+OrchestratorServiceListBinariesProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("ListBinaries")),
-			connect.WithClientOptions(opts...),
-		),
-		getBinaryStatus: connect.NewClient[v1.GetBinaryStatusRequest, v1.GetBinaryStatusResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetBinaryStatusProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetBinaryStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		getBinaryVersion: connect.NewClient[v1.GetBinaryVersionRequest, v1.GetBinaryVersionResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetBinaryVersionProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetBinaryVersion")),
-			connect.WithClientOptions(opts...),
-		),
-		downloadBinary: connect.NewClient[v1.DownloadBinaryRequest, v1.DownloadBinaryResponse](
-			httpClient,
-			baseURL+OrchestratorServiceDownloadBinaryProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("DownloadBinary")),
-			connect.WithClientOptions(opts...),
-		),
-		startBinary: connect.NewClient[v1.StartBinaryRequest, v1.StartBinaryResponse](
-			httpClient,
-			baseURL+OrchestratorServiceStartBinaryProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("StartBinary")),
-			connect.WithClientOptions(opts...),
-		),
-		stopBinary: connect.NewClient[v1.StopBinaryRequest, v1.StopBinaryResponse](
-			httpClient,
-			baseURL+OrchestratorServiceStopBinaryProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("StopBinary")),
-			connect.WithClientOptions(opts...),
-		),
-		streamLogs: connect.NewClient[v1.StreamLogsRequest, v1.StreamLogsResponse](
-			httpClient,
-			baseURL+OrchestratorServiceStreamLogsProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("StreamLogs")),
-			connect.WithClientOptions(opts...),
-		),
-		startWithL1: connect.NewClient[v1.StartWithL1Request, v1.StartWithL1Response](
-			httpClient,
-			baseURL+OrchestratorServiceStartWithL1Procedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("StartWithL1")),
-			connect.WithClientOptions(opts...),
-		),
-		restartDaemon: connect.NewClient[v1.RestartDaemonRequest, v1.RestartDaemonResponse](
-			httpClient,
-			baseURL+OrchestratorServiceRestartDaemonProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("RestartDaemon")),
-			connect.WithClientOptions(opts...),
-		),
-		restartL1: connect.NewClient[v1.RestartL1Request, v1.RestartL1Response](
-			httpClient,
-			baseURL+OrchestratorServiceRestartL1Procedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("RestartL1")),
-			connect.WithClientOptions(opts...),
-		),
-		applyUTXOSnapshot: connect.NewClient[v1.ApplyUTXOSnapshotRequest, v1.ApplyUTXOSnapshotResponse](
-			httpClient,
-			baseURL+OrchestratorServiceApplyUTXOSnapshotProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("ApplyUTXOSnapshot")),
-			connect.WithClientOptions(opts...),
-		),
-		getSnapshotStatus: connect.NewClient[v1.GetSnapshotStatusRequest, v1.GetSnapshotStatusResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetSnapshotStatusProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetSnapshotStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingNetworkGeneration: connect.NewClient[v1.GetPendingNetworkGenerationRequest, v1.GetPendingNetworkGenerationResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetPendingNetworkGenerationProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetPendingNetworkGeneration")),
-			connect.WithClientOptions(opts...),
-		),
-		confirmPendingNetworkGeneration: connect.NewClient[v1.ConfirmPendingNetworkGenerationRequest, v1.ConfirmPendingNetworkGenerationResponse](
-			httpClient,
-			baseURL+OrchestratorServiceConfirmPendingNetworkGenerationProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("ConfirmPendingNetworkGeneration")),
-			connect.WithClientOptions(opts...),
-		),
-		shutdownAll: connect.NewClient[v1.ShutdownAllRequest, v1.ShutdownAllResponse](
-			httpClient,
-			baseURL+OrchestratorServiceShutdownAllProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("ShutdownAll")),
-			connect.WithClientOptions(opts...),
-		),
-		shutdown: connect.NewClient[v1.ShutdownRequest, v1.ShutdownResponse](
-			httpClient,
-			baseURL+OrchestratorServiceShutdownProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("Shutdown")),
-			connect.WithClientOptions(opts...),
-		),
-		adoptOwner: connect.NewClient[v1.AdoptOwnerRequest, v1.AdoptOwnerResponse](
-			httpClient,
-			baseURL+OrchestratorServiceAdoptOwnerProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("AdoptOwner")),
-			connect.WithClientOptions(opts...),
-		),
-		getBTCPrice: connect.NewClient[v1.GetBTCPriceRequest, v1.GetBTCPriceResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetBTCPriceProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetBTCPrice")),
-			connect.WithClientOptions(opts...),
-		),
-		getMainchainBlockchainInfo: connect.NewClient[v1.GetMainchainBlockchainInfoRequest, v1.GetMainchainBlockchainInfoResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetMainchainBlockchainInfoProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetMainchainBlockchainInfo")),
-			connect.WithClientOptions(opts...),
-		),
-		getEnforcerBlockchainInfo: connect.NewClient[v1.GetEnforcerBlockchainInfoRequest, v1.GetEnforcerBlockchainInfoResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetEnforcerBlockchainInfoProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetEnforcerBlockchainInfo")),
-			connect.WithClientOptions(opts...),
-		),
-		getSyncStatus: connect.NewClient[v1.GetSyncStatusRequest, v1.GetSyncStatusResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetSyncStatusProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetSyncStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		getDownloadStatus: connect.NewClient[v1.GetDownloadStatusRequest, v1.GetDownloadStatusResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetDownloadStatusProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetDownloadStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		getMainchainBalance: connect.NewClient[v1.GetMainchainBalanceRequest, v1.GetMainchainBalanceResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetMainchainBalanceProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetMainchainBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainBalance: connect.NewClient[v1.GetSidechainBalanceRequest, v1.GetSidechainBalanceResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetSidechainBalanceProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetSidechainBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		gatherFilesToDelete: connect.NewClient[v1.GatherFilesToDeleteRequest, v1.GatherFilesToDeleteResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGatherFilesToDeleteProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GatherFilesToDelete")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteFiles: connect.NewClient[v1.DeleteFilesRequest, v1.DeleteFilesResponse](
-			httpClient,
-			baseURL+OrchestratorServiceDeleteFilesProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("DeleteFiles")),
-			connect.WithClientOptions(opts...),
-		),
-		rejectBlock: connect.NewClient[v1.RejectBlockRequest, v1.RejectBlockResponse](
-			httpClient,
-			baseURL+OrchestratorServiceRejectBlockProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("RejectBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		acceptBlock: connect.NewClient[v1.AcceptBlockRequest, v1.AcceptBlockResponse](
-			httpClient,
-			baseURL+OrchestratorServiceAcceptBlockProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("AcceptBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		resetToBlock: connect.NewClient[v1.ResetToBlockRequest, v1.ResetToBlockResponse](
-			httpClient,
-			baseURL+OrchestratorServiceResetToBlockProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("ResetToBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getCoreMempoolInfo: connect.NewClient[v1.GetCoreMempoolInfoRequest, v1.GetCoreMempoolInfoResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetCoreMempoolInfoProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetCoreMempoolInfo")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmContext: connect.NewClient[v1.GetBmmContextRequest, v1.GetBmmContextResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetBmmContextProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetBmmContext")),
-			connect.WithClientOptions(opts...),
-		),
-		coreRawCall: connect.NewClient[v1.CoreRawCallRequest, v1.CoreRawCallResponse](
-			httpClient,
-			baseURL+OrchestratorServiceCoreRawCallProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("CoreRawCall")),
-			connect.WithClientOptions(opts...),
-		),
-		getForkStatus: connect.NewClient[v1.GetForkStatusRequest, v1.GetForkStatusResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetForkStatusProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetForkStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		previewECashMigration: connect.NewClient[v1.PreviewECashMigrationRequest, v1.PreviewECashMigrationResponse](
-			httpClient,
-			baseURL+OrchestratorServicePreviewECashMigrationProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("PreviewECashMigration")),
-			connect.WithClientOptions(opts...),
-		),
-		startECashMigration: connect.NewClient[v1.StartECashMigrationRequest, v1.StartECashMigrationResponse](
-			httpClient,
-			baseURL+OrchestratorServiceStartECashMigrationProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("StartECashMigration")),
-			connect.WithClientOptions(opts...),
-		),
-		getECashMigrationStatus: connect.NewClient[v1.GetECashMigrationStatusRequest, v1.GetECashMigrationStatusResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetECashMigrationStatusProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetECashMigrationStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		getDatadirNetwork: connect.NewClient[v1.GetDatadirNetworkRequest, v1.GetDatadirNetworkResponse](
-			httpClient,
-			baseURL+OrchestratorServiceGetDatadirNetworkProcedure,
-			connect.WithSchema(orchestratorServiceMethods.ByName("GetDatadirNetwork")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// orchestratorServiceClient implements OrchestratorServiceClient.
-type orchestratorServiceClient struct {
-	listBinaries                    *connect.Client[v1.ListBinariesRequest, v1.ListBinariesResponse]
-	getBinaryStatus                 *connect.Client[v1.GetBinaryStatusRequest, v1.GetBinaryStatusResponse]
-	getBinaryVersion                *connect.Client[v1.GetBinaryVersionRequest, v1.GetBinaryVersionResponse]
-	downloadBinary                  *connect.Client[v1.DownloadBinaryRequest, v1.DownloadBinaryResponse]
-	startBinary                     *connect.Client[v1.StartBinaryRequest, v1.StartBinaryResponse]
-	stopBinary                      *connect.Client[v1.StopBinaryRequest, v1.StopBinaryResponse]
-	streamLogs                      *connect.Client[v1.StreamLogsRequest, v1.StreamLogsResponse]
-	startWithL1                     *connect.Client[v1.StartWithL1Request, v1.StartWithL1Response]
-	restartDaemon                   *connect.Client[v1.RestartDaemonRequest, v1.RestartDaemonResponse]
-	restartL1                       *connect.Client[v1.RestartL1Request, v1.RestartL1Response]
-	applyUTXOSnapshot               *connect.Client[v1.ApplyUTXOSnapshotRequest, v1.ApplyUTXOSnapshotResponse]
-	getSnapshotStatus               *connect.Client[v1.GetSnapshotStatusRequest, v1.GetSnapshotStatusResponse]
-	getPendingNetworkGeneration     *connect.Client[v1.GetPendingNetworkGenerationRequest, v1.GetPendingNetworkGenerationResponse]
-	confirmPendingNetworkGeneration *connect.Client[v1.ConfirmPendingNetworkGenerationRequest, v1.ConfirmPendingNetworkGenerationResponse]
-	shutdownAll                     *connect.Client[v1.ShutdownAllRequest, v1.ShutdownAllResponse]
-	shutdown                        *connect.Client[v1.ShutdownRequest, v1.ShutdownResponse]
-	adoptOwner                      *connect.Client[v1.AdoptOwnerRequest, v1.AdoptOwnerResponse]
-	getBTCPrice                     *connect.Client[v1.GetBTCPriceRequest, v1.GetBTCPriceResponse]
-	getMainchainBlockchainInfo      *connect.Client[v1.GetMainchainBlockchainInfoRequest, v1.GetMainchainBlockchainInfoResponse]
-	getEnforcerBlockchainInfo       *connect.Client[v1.GetEnforcerBlockchainInfoRequest, v1.GetEnforcerBlockchainInfoResponse]
-	getSyncStatus                   *connect.Client[v1.GetSyncStatusRequest, v1.GetSyncStatusResponse]
-	getDownloadStatus               *connect.Client[v1.GetDownloadStatusRequest, v1.GetDownloadStatusResponse]
-	getMainchainBalance             *connect.Client[v1.GetMainchainBalanceRequest, v1.GetMainchainBalanceResponse]
-	getSidechainBalance             *connect.Client[v1.GetSidechainBalanceRequest, v1.GetSidechainBalanceResponse]
-	gatherFilesToDelete             *connect.Client[v1.GatherFilesToDeleteRequest, v1.GatherFilesToDeleteResponse]
-	deleteFiles                     *connect.Client[v1.DeleteFilesRequest, v1.DeleteFilesResponse]
-	rejectBlock                     *connect.Client[v1.RejectBlockRequest, v1.RejectBlockResponse]
-	acceptBlock                     *connect.Client[v1.AcceptBlockRequest, v1.AcceptBlockResponse]
-	resetToBlock                    *connect.Client[v1.ResetToBlockRequest, v1.ResetToBlockResponse]
-	getCoreMempoolInfo              *connect.Client[v1.GetCoreMempoolInfoRequest, v1.GetCoreMempoolInfoResponse]
-	getBmmContext                   *connect.Client[v1.GetBmmContextRequest, v1.GetBmmContextResponse]
-	coreRawCall                     *connect.Client[v1.CoreRawCallRequest, v1.CoreRawCallResponse]
-	getForkStatus                   *connect.Client[v1.GetForkStatusRequest, v1.GetForkStatusResponse]
-	previewECashMigration           *connect.Client[v1.PreviewECashMigrationRequest, v1.PreviewECashMigrationResponse]
-	startECashMigration             *connect.Client[v1.StartECashMigrationRequest, v1.StartECashMigrationResponse]
-	getECashMigrationStatus         *connect.Client[v1.GetECashMigrationStatusRequest, v1.GetECashMigrationStatusResponse]
-	getDatadirNetwork               *connect.Client[v1.GetDatadirNetworkRequest, v1.GetDatadirNetworkResponse]
+// service. Multiple service clients may share a single connect.Client.
+func NewOrchestratorServiceClient(client *connect.Client) OrchestratorServiceClient {
+	return &orchestratorServiceClient{client: client}
 }
 
-// ListBinaries calls orchestrator.v1.OrchestratorService.ListBinaries.
-func (c *orchestratorServiceClient) ListBinaries(ctx context.Context, req *connect.Request[v1.ListBinariesRequest]) (*connect.Response[v1.ListBinariesResponse], error) {
-	return c.listBinaries.CallUnary(ctx, req)
+// OrchestratorServiceStreamLogsClientStream is the client stream for the OrchestratorService's
+// StreamLogs RPC.
+type OrchestratorServiceStreamLogsClientStream struct {
+	stream connect.ClientStream
 }
 
-// GetBinaryStatus calls orchestrator.v1.OrchestratorService.GetBinaryStatus.
-func (c *orchestratorServiceClient) GetBinaryStatus(ctx context.Context, req *connect.Request[v1.GetBinaryStatusRequest]) (*connect.Response[v1.GetBinaryStatusResponse], error) {
-	return c.getBinaryStatus.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s OrchestratorServiceStreamLogsClientStream) Receive() (*v1.StreamLogsResponse, error) {
+	var res v1.StreamLogsResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// GetBinaryVersion calls orchestrator.v1.OrchestratorService.GetBinaryVersion.
-func (c *orchestratorServiceClient) GetBinaryVersion(ctx context.Context, req *connect.Request[v1.GetBinaryVersionRequest]) (*connect.Response[v1.GetBinaryVersionResponse], error) {
-	return c.getBinaryVersion.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s OrchestratorServiceStreamLogsClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// DownloadBinary calls orchestrator.v1.OrchestratorService.DownloadBinary.
-func (c *orchestratorServiceClient) DownloadBinary(ctx context.Context, req *connect.Request[v1.DownloadBinaryRequest]) (*connect.Response[v1.DownloadBinaryResponse], error) {
-	return c.downloadBinary.CallUnary(ctx, req)
+// OrchestratorServiceApplyUTXOSnapshotClientStream is the client stream for the
+// OrchestratorService's ApplyUTXOSnapshot RPC.
+type OrchestratorServiceApplyUTXOSnapshotClientStream struct {
+	stream connect.ClientStream
 }
 
-// StartBinary calls orchestrator.v1.OrchestratorService.StartBinary.
-func (c *orchestratorServiceClient) StartBinary(ctx context.Context, req *connect.Request[v1.StartBinaryRequest]) (*connect.Response[v1.StartBinaryResponse], error) {
-	return c.startBinary.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s OrchestratorServiceApplyUTXOSnapshotClientStream) Receive() (*v1.ApplyUTXOSnapshotResponse, error) {
+	var res v1.ApplyUTXOSnapshotResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// StopBinary calls orchestrator.v1.OrchestratorService.StopBinary.
-func (c *orchestratorServiceClient) StopBinary(ctx context.Context, req *connect.Request[v1.StopBinaryRequest]) (*connect.Response[v1.StopBinaryResponse], error) {
-	return c.stopBinary.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s OrchestratorServiceApplyUTXOSnapshotClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// StreamLogs calls orchestrator.v1.OrchestratorService.StreamLogs.
-func (c *orchestratorServiceClient) StreamLogs(ctx context.Context, req *connect.Request[v1.StreamLogsRequest]) (*connect.ServerStreamForClient[v1.StreamLogsResponse], error) {
-	return c.streamLogs.CallServerStream(ctx, req)
+// OrchestratorServiceShutdownAllClientStream is the client stream for the OrchestratorService's
+// ShutdownAll RPC.
+type OrchestratorServiceShutdownAllClientStream struct {
+	stream connect.ClientStream
 }
 
-// StartWithL1 calls orchestrator.v1.OrchestratorService.StartWithL1.
-func (c *orchestratorServiceClient) StartWithL1(ctx context.Context, req *connect.Request[v1.StartWithL1Request]) (*connect.Response[v1.StartWithL1Response], error) {
-	return c.startWithL1.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s OrchestratorServiceShutdownAllClientStream) Receive() (*v1.ShutdownAllResponse, error) {
+	var res v1.ShutdownAllResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// RestartDaemon calls orchestrator.v1.OrchestratorService.RestartDaemon.
-func (c *orchestratorServiceClient) RestartDaemon(ctx context.Context, req *connect.Request[v1.RestartDaemonRequest]) (*connect.Response[v1.RestartDaemonResponse], error) {
-	return c.restartDaemon.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s OrchestratorServiceShutdownAllClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// RestartL1 calls orchestrator.v1.OrchestratorService.RestartL1.
-func (c *orchestratorServiceClient) RestartL1(ctx context.Context, req *connect.Request[v1.RestartL1Request]) (*connect.Response[v1.RestartL1Response], error) {
-	return c.restartL1.CallUnary(ctx, req)
+// OrchestratorServiceDeleteFilesClientStream is the client stream for the OrchestratorService's
+// DeleteFiles RPC.
+type OrchestratorServiceDeleteFilesClientStream struct {
+	stream connect.ClientStream
 }
 
-// ApplyUTXOSnapshot calls orchestrator.v1.OrchestratorService.ApplyUTXOSnapshot.
-func (c *orchestratorServiceClient) ApplyUTXOSnapshot(ctx context.Context, req *connect.Request[v1.ApplyUTXOSnapshotRequest]) (*connect.ServerStreamForClient[v1.ApplyUTXOSnapshotResponse], error) {
-	return c.applyUTXOSnapshot.CallServerStream(ctx, req)
+// Receive returns the next response message from the server.
+func (s OrchestratorServiceDeleteFilesClientStream) Receive() (*v1.DeleteFilesResponse, error) {
+	var res v1.DeleteFilesResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// GetSnapshotStatus calls orchestrator.v1.OrchestratorService.GetSnapshotStatus.
-func (c *orchestratorServiceClient) GetSnapshotStatus(ctx context.Context, req *connect.Request[v1.GetSnapshotStatusRequest]) (*connect.Response[v1.GetSnapshotStatusResponse], error) {
-	return c.getSnapshotStatus.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s OrchestratorServiceDeleteFilesClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// GetPendingNetworkGeneration calls
-// orchestrator.v1.OrchestratorService.GetPendingNetworkGeneration.
-func (c *orchestratorServiceClient) GetPendingNetworkGeneration(ctx context.Context, req *connect.Request[v1.GetPendingNetworkGenerationRequest]) (*connect.Response[v1.GetPendingNetworkGenerationResponse], error) {
-	return c.getPendingNetworkGeneration.CallUnary(ctx, req)
+// OrchestratorServiceResetToBlockClientStream is the client stream for the OrchestratorService's
+// ResetToBlock RPC.
+type OrchestratorServiceResetToBlockClientStream struct {
+	stream connect.ClientStream
 }
 
-// ConfirmPendingNetworkGeneration calls
-// orchestrator.v1.OrchestratorService.ConfirmPendingNetworkGeneration.
-func (c *orchestratorServiceClient) ConfirmPendingNetworkGeneration(ctx context.Context, req *connect.Request[v1.ConfirmPendingNetworkGenerationRequest]) (*connect.Response[v1.ConfirmPendingNetworkGenerationResponse], error) {
-	return c.confirmPendingNetworkGeneration.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s OrchestratorServiceResetToBlockClientStream) Receive() (*v1.ResetToBlockResponse, error) {
+	var res v1.ResetToBlockResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// ShutdownAll calls orchestrator.v1.OrchestratorService.ShutdownAll.
-func (c *orchestratorServiceClient) ShutdownAll(ctx context.Context, req *connect.Request[v1.ShutdownAllRequest]) (*connect.ServerStreamForClient[v1.ShutdownAllResponse], error) {
-	return c.shutdownAll.CallServerStream(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s OrchestratorServiceResetToBlockClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// Shutdown calls orchestrator.v1.OrchestratorService.Shutdown.
-func (c *orchestratorServiceClient) Shutdown(ctx context.Context, req *connect.Request[v1.ShutdownRequest]) (*connect.Response[v1.ShutdownResponse], error) {
-	return c.shutdown.CallUnary(ctx, req)
+// OrchestratorServiceHandler is an implementation of the orchestrator.v1.OrchestratorService
+// service.
+type OrchestratorServiceHandler interface {
+	ListBinaries(context.Context, *v1.ListBinariesRequest) (*v1.ListBinariesResponse, error)
+	GetBinaryStatus(context.Context, *v1.GetBinaryStatusRequest) (*v1.GetBinaryStatusResponse, error)
+	GetBinaryVersion(context.Context, *v1.GetBinaryVersionRequest) (*v1.GetBinaryVersionResponse, error)
+	DownloadBinary(context.Context, *v1.DownloadBinaryRequest) (*v1.DownloadBinaryResponse, error)
+	StartBinary(context.Context, *v1.StartBinaryRequest) (*v1.StartBinaryResponse, error)
+	StopBinary(context.Context, *v1.StopBinaryRequest) (*v1.StopBinaryResponse, error)
+	StreamLogs(context.Context, *v1.StreamLogsRequest, OrchestratorServiceStreamLogsServerStream) error
+	StartWithL1(context.Context, *v1.StartWithL1Request) (*v1.StartWithL1Response, error)
+	RestartDaemon(context.Context, *v1.RestartDaemonRequest) (*v1.RestartDaemonResponse, error)
+	RestartL1(context.Context, *v1.RestartL1Request) (*v1.RestartL1Response, error)
+	ApplyUTXOSnapshot(context.Context, *v1.ApplyUTXOSnapshotRequest, OrchestratorServiceApplyUTXOSnapshotServerStream) error
+	GetSnapshotStatus(context.Context, *v1.GetSnapshotStatusRequest) (*v1.GetSnapshotStatusResponse, error)
+	GetPendingNetworkGeneration(context.Context, *v1.GetPendingNetworkGenerationRequest) (*v1.GetPendingNetworkGenerationResponse, error)
+	ConfirmPendingNetworkGeneration(context.Context, *v1.ConfirmPendingNetworkGenerationRequest) (*v1.ConfirmPendingNetworkGenerationResponse, error)
+	ShutdownAll(context.Context, *v1.ShutdownAllRequest, OrchestratorServiceShutdownAllServerStream) error
+	Shutdown(context.Context, *v1.ShutdownRequest) (*v1.ShutdownResponse, error)
+	AdoptOwner(context.Context, *v1.AdoptOwnerRequest) (*v1.AdoptOwnerResponse, error)
+	GetBTCPrice(context.Context, *v1.GetBTCPriceRequest) (*v1.GetBTCPriceResponse, error)
+	GetMainchainBlockchainInfo(context.Context, *v1.GetMainchainBlockchainInfoRequest) (*v1.GetMainchainBlockchainInfoResponse, error)
+	GetEnforcerBlockchainInfo(context.Context, *v1.GetEnforcerBlockchainInfoRequest) (*v1.GetEnforcerBlockchainInfoResponse, error)
+	GetSyncStatus(context.Context, *v1.GetSyncStatusRequest) (*v1.GetSyncStatusResponse, error)
+	GetDownloadStatus(context.Context, *v1.GetDownloadStatusRequest) (*v1.GetDownloadStatusResponse, error)
+	GetMainchainBalance(context.Context, *v1.GetMainchainBalanceRequest) (*v1.GetMainchainBalanceResponse, error)
+	GetSidechainBalance(context.Context, *v1.GetSidechainBalanceRequest) (*v1.GetSidechainBalanceResponse, error)
+	GatherFilesToDelete(context.Context, *v1.GatherFilesToDeleteRequest) (*v1.GatherFilesToDeleteResponse, error)
+	DeleteFiles(context.Context, *v1.DeleteFilesRequest, OrchestratorServiceDeleteFilesServerStream) error
+	RejectBlock(context.Context, *v1.RejectBlockRequest) (*v1.RejectBlockResponse, error)
+	AcceptBlock(context.Context, *v1.AcceptBlockRequest) (*v1.AcceptBlockResponse, error)
+	ResetToBlock(context.Context, *v1.ResetToBlockRequest, OrchestratorServiceResetToBlockServerStream) error
+	GetCoreMempoolInfo(context.Context, *v1.GetCoreMempoolInfoRequest) (*v1.GetCoreMempoolInfoResponse, error)
+	GetBmmContext(context.Context, *v1.GetBmmContextRequest) (*v1.GetBmmContextResponse, error)
+	CoreRawCall(context.Context, *v1.CoreRawCallRequest) (*v1.CoreRawCallResponse, error)
+	GetForkStatus(context.Context, *v1.GetForkStatusRequest) (*v1.GetForkStatusResponse, error)
+	PreviewECashMigration(context.Context, *v1.PreviewECashMigrationRequest) (*v1.PreviewECashMigrationResponse, error)
+	StartECashMigration(context.Context, *v1.StartECashMigrationRequest) (*v1.StartECashMigrationResponse, error)
+	GetECashMigrationStatus(context.Context, *v1.GetECashMigrationStatusRequest) (*v1.GetECashMigrationStatusResponse, error)
+	GetDatadirNetwork(context.Context, *v1.GetDatadirNetworkRequest) (*v1.GetDatadirNetworkResponse, error)
+}
+
+// RegisterOrchestratorServiceHandler registers svc as the orchestrator.v1.OrchestratorService
+// implementation on server.
+func RegisterOrchestratorServiceHandler(server *connect.Server, svc OrchestratorServiceHandler) {
+	adapter := orchestratorServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: orchestratorServiceListBinariesSpec(), Handler: adapter.listBinaries},
+		connect.Method{Spec: orchestratorServiceGetBinaryStatusSpec(), Handler: adapter.getBinaryStatus},
+		connect.Method{Spec: orchestratorServiceGetBinaryVersionSpec(), Handler: adapter.getBinaryVersion},
+		connect.Method{Spec: orchestratorServiceDownloadBinarySpec(), Handler: adapter.downloadBinary},
+		connect.Method{Spec: orchestratorServiceStartBinarySpec(), Handler: adapter.startBinary},
+		connect.Method{Spec: orchestratorServiceStopBinarySpec(), Handler: adapter.stopBinary},
+		connect.Method{Spec: orchestratorServiceStreamLogsSpec(), Handler: adapter.streamLogs},
+		connect.Method{Spec: orchestratorServiceStartWithL1Spec(), Handler: adapter.startWithL1},
+		connect.Method{Spec: orchestratorServiceRestartDaemonSpec(), Handler: adapter.restartDaemon},
+		connect.Method{Spec: orchestratorServiceRestartL1Spec(), Handler: adapter.restartL1},
+		connect.Method{Spec: orchestratorServiceApplyUTXOSnapshotSpec(), Handler: adapter.applyUTXOSnapshot},
+		connect.Method{Spec: orchestratorServiceGetSnapshotStatusSpec(), Handler: adapter.getSnapshotStatus},
+		connect.Method{Spec: orchestratorServiceGetPendingNetworkGenerationSpec(), Handler: adapter.getPendingNetworkGeneration},
+		connect.Method{Spec: orchestratorServiceConfirmPendingNetworkGenerationSpec(), Handler: adapter.confirmPendingNetworkGeneration},
+		connect.Method{Spec: orchestratorServiceShutdownAllSpec(), Handler: adapter.shutdownAll},
+		connect.Method{Spec: orchestratorServiceShutdownSpec(), Handler: adapter.shutdown},
+		connect.Method{Spec: orchestratorServiceAdoptOwnerSpec(), Handler: adapter.adoptOwner},
+		connect.Method{Spec: orchestratorServiceGetBTCPriceSpec(), Handler: adapter.getBTCPrice},
+		connect.Method{Spec: orchestratorServiceGetMainchainBlockchainInfoSpec(), Handler: adapter.getMainchainBlockchainInfo},
+		connect.Method{Spec: orchestratorServiceGetEnforcerBlockchainInfoSpec(), Handler: adapter.getEnforcerBlockchainInfo},
+		connect.Method{Spec: orchestratorServiceGetSyncStatusSpec(), Handler: adapter.getSyncStatus},
+		connect.Method{Spec: orchestratorServiceGetDownloadStatusSpec(), Handler: adapter.getDownloadStatus},
+		connect.Method{Spec: orchestratorServiceGetMainchainBalanceSpec(), Handler: adapter.getMainchainBalance},
+		connect.Method{Spec: orchestratorServiceGetSidechainBalanceSpec(), Handler: adapter.getSidechainBalance},
+		connect.Method{Spec: orchestratorServiceGatherFilesToDeleteSpec(), Handler: adapter.gatherFilesToDelete},
+		connect.Method{Spec: orchestratorServiceDeleteFilesSpec(), Handler: adapter.deleteFiles},
+		connect.Method{Spec: orchestratorServiceRejectBlockSpec(), Handler: adapter.rejectBlock},
+		connect.Method{Spec: orchestratorServiceAcceptBlockSpec(), Handler: adapter.acceptBlock},
+		connect.Method{Spec: orchestratorServiceResetToBlockSpec(), Handler: adapter.resetToBlock},
+		connect.Method{Spec: orchestratorServiceGetCoreMempoolInfoSpec(), Handler: adapter.getCoreMempoolInfo},
+		connect.Method{Spec: orchestratorServiceGetBmmContextSpec(), Handler: adapter.getBmmContext},
+		connect.Method{Spec: orchestratorServiceCoreRawCallSpec(), Handler: adapter.coreRawCall},
+		connect.Method{Spec: orchestratorServiceGetForkStatusSpec(), Handler: adapter.getForkStatus},
+		connect.Method{Spec: orchestratorServicePreviewECashMigrationSpec(), Handler: adapter.previewECashMigration},
+		connect.Method{Spec: orchestratorServiceStartECashMigrationSpec(), Handler: adapter.startECashMigration},
+		connect.Method{Spec: orchestratorServiceGetECashMigrationStatusSpec(), Handler: adapter.getECashMigrationStatus},
+		connect.Method{Spec: orchestratorServiceGetDatadirNetworkSpec(), Handler: adapter.getDatadirNetwork},
+	)
 }
 
-// AdoptOwner calls orchestrator.v1.OrchestratorService.AdoptOwner.
-func (c *orchestratorServiceClient) AdoptOwner(ctx context.Context, req *connect.Request[v1.AdoptOwnerRequest]) (*connect.Response[v1.AdoptOwnerResponse], error) {
-	return c.adoptOwner.CallUnary(ctx, req)
+// OrchestratorServiceStreamLogsServerStream is the server stream for the OrchestratorService's
+// StreamLogs RPC.
+type OrchestratorServiceStreamLogsServerStream struct {
+	stream connect.ServerStream
 }
 
-// GetBTCPrice calls orchestrator.v1.OrchestratorService.GetBTCPrice.
-func (c *orchestratorServiceClient) GetBTCPrice(ctx context.Context, req *connect.Request[v1.GetBTCPriceRequest]) (*connect.Response[v1.GetBTCPriceResponse], error) {
-	return c.getBTCPrice.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s OrchestratorServiceStreamLogsServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// GetMainchainBlockchainInfo calls orchestrator.v1.OrchestratorService.GetMainchainBlockchainInfo.
-func (c *orchestratorServiceClient) GetMainchainBlockchainInfo(ctx context.Context, req *connect.Request[v1.GetMainchainBlockchainInfoRequest]) (*connect.Response[v1.GetMainchainBlockchainInfoResponse], error) {
-	return c.getMainchainBlockchainInfo.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s OrchestratorServiceStreamLogsServerStream) Send(res *v1.StreamLogsResponse) error {
+	return s.stream.Send(res)
 }
 
-// GetEnforcerBlockchainInfo calls orchestrator.v1.OrchestratorService.GetEnforcerBlockchainInfo.
-func (c *orchestratorServiceClient) GetEnforcerBlockchainInfo(ctx context.Context, req *connect.Request[v1.GetEnforcerBlockchainInfoRequest]) (*connect.Response[v1.GetEnforcerBlockchainInfoResponse], error) {
-	return c.getEnforcerBlockchainInfo.CallUnary(ctx, req)
+// OrchestratorServiceApplyUTXOSnapshotServerStream is the server stream for the
+// OrchestratorService's ApplyUTXOSnapshot RPC.
+type OrchestratorServiceApplyUTXOSnapshotServerStream struct {
+	stream connect.ServerStream
 }
 
-// GetSyncStatus calls orchestrator.v1.OrchestratorService.GetSyncStatus.
-func (c *orchestratorServiceClient) GetSyncStatus(ctx context.Context, req *connect.Request[v1.GetSyncStatusRequest]) (*connect.Response[v1.GetSyncStatusResponse], error) {
-	return c.getSyncStatus.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s OrchestratorServiceApplyUTXOSnapshotServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// GetDownloadStatus calls orchestrator.v1.OrchestratorService.GetDownloadStatus.
-func (c *orchestratorServiceClient) GetDownloadStatus(ctx context.Context, req *connect.Request[v1.GetDownloadStatusRequest]) (*connect.Response[v1.GetDownloadStatusResponse], error) {
-	return c.getDownloadStatus.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s OrchestratorServiceApplyUTXOSnapshotServerStream) Send(res *v1.ApplyUTXOSnapshotResponse) error {
+	return s.stream.Send(res)
 }
 
-// GetMainchainBalance calls orchestrator.v1.OrchestratorService.GetMainchainBalance.
-func (c *orchestratorServiceClient) GetMainchainBalance(ctx context.Context, req *connect.Request[v1.GetMainchainBalanceRequest]) (*connect.Response[v1.GetMainchainBalanceResponse], error) {
-	return c.getMainchainBalance.CallUnary(ctx, req)
+// OrchestratorServiceShutdownAllServerStream is the server stream for the OrchestratorService's
+// ShutdownAll RPC.
+type OrchestratorServiceShutdownAllServerStream struct {
+	stream connect.ServerStream
 }
 
-// GetSidechainBalance calls orchestrator.v1.OrchestratorService.GetSidechainBalance.
-func (c *orchestratorServiceClient) GetSidechainBalance(ctx context.Context, req *connect.Request[v1.GetSidechainBalanceRequest]) (*connect.Response[v1.GetSidechainBalanceResponse], error) {
-	return c.getSidechainBalance.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s OrchestratorServiceShutdownAllServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// GatherFilesToDelete calls orchestrator.v1.OrchestratorService.GatherFilesToDelete.
-func (c *orchestratorServiceClient) GatherFilesToDelete(ctx context.Context, req *connect.Request[v1.GatherFilesToDeleteRequest]) (*connect.Response[v1.GatherFilesToDeleteResponse], error) {
-	return c.gatherFilesToDelete.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s OrchestratorServiceShutdownAllServerStream) Send(res *v1.ShutdownAllResponse) error {
+	return s.stream.Send(res)
 }
 
-// DeleteFiles calls orchestrator.v1.OrchestratorService.DeleteFiles.
-func (c *orchestratorServiceClient) DeleteFiles(ctx context.Context, req *connect.Request[v1.DeleteFilesRequest]) (*connect.ServerStreamForClient[v1.DeleteFilesResponse], error) {
-	return c.deleteFiles.CallServerStream(ctx, req)
+// OrchestratorServiceDeleteFilesServerStream is the server stream for the OrchestratorService's
+// DeleteFiles RPC.
+type OrchestratorServiceDeleteFilesServerStream struct {
+	stream connect.ServerStream
 }
 
-// RejectBlock calls orchestrator.v1.OrchestratorService.RejectBlock.
-func (c *orchestratorServiceClient) RejectBlock(ctx context.Context, req *connect.Request[v1.RejectBlockRequest]) (*connect.Response[v1.RejectBlockResponse], error) {
-	return c.rejectBlock.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s OrchestratorServiceDeleteFilesServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// AcceptBlock calls orchestrator.v1.OrchestratorService.AcceptBlock.
-func (c *orchestratorServiceClient) AcceptBlock(ctx context.Context, req *connect.Request[v1.AcceptBlockRequest]) (*connect.Response[v1.AcceptBlockResponse], error) {
-	return c.acceptBlock.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s OrchestratorServiceDeleteFilesServerStream) Send(res *v1.DeleteFilesResponse) error {
+	return s.stream.Send(res)
 }
 
-// ResetToBlock calls orchestrator.v1.OrchestratorService.ResetToBlock.
-func (c *orchestratorServiceClient) ResetToBlock(ctx context.Context, req *connect.Request[v1.ResetToBlockRequest]) (*connect.ServerStreamForClient[v1.ResetToBlockResponse], error) {
-	return c.resetToBlock.CallServerStream(ctx, req)
+// OrchestratorServiceResetToBlockServerStream is the server stream for the OrchestratorService's
+// ResetToBlock RPC.
+type OrchestratorServiceResetToBlockServerStream struct {
+	stream connect.ServerStream
 }
 
-// GetCoreMempoolInfo calls orchestrator.v1.OrchestratorService.GetCoreMempoolInfo.
-func (c *orchestratorServiceClient) GetCoreMempoolInfo(ctx context.Context, req *connect.Request[v1.GetCoreMempoolInfoRequest]) (*connect.Response[v1.GetCoreMempoolInfoResponse], error) {
-	return c.getCoreMempoolInfo.CallUnary(ctx, req)
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s OrchestratorServiceResetToBlockServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
 }
 
-// GetBmmContext calls orchestrator.v1.OrchestratorService.GetBmmContext.
-func (c *orchestratorServiceClient) GetBmmContext(ctx context.Context, req *connect.Request[v1.GetBmmContextRequest]) (*connect.Response[v1.GetBmmContextResponse], error) {
-	return c.getBmmContext.CallUnary(ctx, req)
+// Send sends a response message to the client.
+func (s OrchestratorServiceResetToBlockServerStream) Send(res *v1.ResetToBlockResponse) error {
+	return s.stream.Send(res)
 }
 
-// CoreRawCall calls orchestrator.v1.OrchestratorService.CoreRawCall.
-func (c *orchestratorServiceClient) CoreRawCall(ctx context.Context, req *connect.Request[v1.CoreRawCallRequest]) (*connect.Response[v1.CoreRawCallResponse], error) {
-	return c.coreRawCall.CallUnary(ctx, req)
+// UnimplementedOrchestratorServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedOrchestratorServiceHandler struct{}
+
+func (UnimplementedOrchestratorServiceHandler) ListBinaries(context.Context, *v1.ListBinariesRequest) (*v1.ListBinariesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.ListBinaries is not implemented")
 }
 
-// GetForkStatus calls orchestrator.v1.OrchestratorService.GetForkStatus.
-func (c *orchestratorServiceClient) GetForkStatus(ctx context.Context, req *connect.Request[v1.GetForkStatusRequest]) (*connect.Response[v1.GetForkStatusResponse], error) {
-	return c.getForkStatus.CallUnary(ctx, req)
+func (UnimplementedOrchestratorServiceHandler) GetBinaryStatus(context.Context, *v1.GetBinaryStatusRequest) (*v1.GetBinaryStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetBinaryStatus is not implemented")
 }
 
-// PreviewECashMigration calls orchestrator.v1.OrchestratorService.PreviewECashMigration.
-func (c *orchestratorServiceClient) PreviewECashMigration(ctx context.Context, req *connect.Request[v1.PreviewECashMigrationRequest]) (*connect.Response[v1.PreviewECashMigrationResponse], error) {
-	return c.previewECashMigration.CallUnary(ctx, req)
+func (UnimplementedOrchestratorServiceHandler) GetBinaryVersion(context.Context, *v1.GetBinaryVersionRequest) (*v1.GetBinaryVersionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetBinaryVersion is not implemented")
 }
 
-// StartECashMigration calls orchestrator.v1.OrchestratorService.StartECashMigration.
-func (c *orchestratorServiceClient) StartECashMigration(ctx context.Context, req *connect.Request[v1.StartECashMigrationRequest]) (*connect.Response[v1.StartECashMigrationResponse], error) {
-	return c.startECashMigration.CallUnary(ctx, req)
+func (UnimplementedOrchestratorServiceHandler) DownloadBinary(context.Context, *v1.DownloadBinaryRequest) (*v1.DownloadBinaryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.DownloadBinary is not implemented")
 }
 
-// GetECashMigrationStatus calls orchestrator.v1.OrchestratorService.GetECashMigrationStatus.
-func (c *orchestratorServiceClient) GetECashMigrationStatus(ctx context.Context, req *connect.Request[v1.GetECashMigrationStatusRequest]) (*connect.Response[v1.GetECashMigrationStatusResponse], error) {
-	return c.getECashMigrationStatus.CallUnary(ctx, req)
+func (UnimplementedOrchestratorServiceHandler) StartBinary(context.Context, *v1.StartBinaryRequest) (*v1.StartBinaryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.StartBinary is not implemented")
 }
 
-// GetDatadirNetwork calls orchestrator.v1.OrchestratorService.GetDatadirNetwork.
-func (c *orchestratorServiceClient) GetDatadirNetwork(ctx context.Context, req *connect.Request[v1.GetDatadirNetworkRequest]) (*connect.Response[v1.GetDatadirNetworkResponse], error) {
-	return c.getDatadirNetwork.CallUnary(ctx, req)
+func (UnimplementedOrchestratorServiceHandler) StopBinary(context.Context, *v1.StopBinaryRequest) (*v1.StopBinaryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.StopBinary is not implemented")
 }
 
-// OrchestratorServiceHandler is an implementation of the orchestrator.v1.OrchestratorService
-// service.
-type OrchestratorServiceHandler interface {
-	// List all configured binaries and their status.
-	ListBinaries(context.Context, *connect.Request[v1.ListBinariesRequest]) (*connect.Response[v1.ListBinariesResponse], error)
-	// Get the status of a single binary.
-	GetBinaryStatus(context.Context, *connect.Request[v1.GetBinaryStatusRequest]) (*connect.Response[v1.GetBinaryStatusResponse], error)
-	// Resolve a binary's on-disk path the same way the launcher does (variant-
-	// and test-build aware, honoring force_backend) and return its --version
-	// output. The frontend must never re-derive the path or shell out itself;
-	// this RPC is the single source of truth for "which binary, what version".
-	GetBinaryVersion(context.Context, *connect.Request[v1.GetBinaryVersionRequest]) (*connect.Response[v1.GetBinaryVersionResponse], error)
-	// Download a binary with streaming progress.
-	// Kicks off a download in a background goroutine and returns
-	// immediately. Progress (MB downloaded / total, is_downloading) is
-	// polled out of GetSyncStatus, never tied to this RPC's lifetime — so
-	// a transport blip can't cancel an in-flight download.
-	DownloadBinary(context.Context, *connect.Request[v1.DownloadBinaryRequest]) (*connect.Response[v1.DownloadBinaryResponse], error)
-	// Start a binary.
-	StartBinary(context.Context, *connect.Request[v1.StartBinaryRequest]) (*connect.Response[v1.StartBinaryResponse], error)
-	// Stop a binary.
-	StopBinary(context.Context, *connect.Request[v1.StopBinaryRequest]) (*connect.Response[v1.StopBinaryResponse], error)
-	// Stream stdout/stderr from a binary.
-	StreamLogs(context.Context, *connect.Request[v1.StreamLogsRequest], *connect.ServerStream[v1.StreamLogsResponse]) error
-	// Kick off a binary and its full L1 dependency chain (Core -> Enforcer ->
-	// target). Fire-and-forget on the server: returns as soon as the boot
-	// goroutine is dispatched. Callers poll GetSyncStatus / ListBinaries for
-	// download progress and connection state — never tied to this RPC's
-	// lifetime, so a transport blip can't kill an in-flight download.
-	StartWithL1(context.Context, *connect.Request[v1.StartWithL1Request]) (*connect.Response[v1.StartWithL1Response], error)
-	// Stop the named binary and start it again, single-daemon scope. Never
-	// touches sibling daemons: restarting "enforcer" never spawns or adopts
-	// bitcoind. Use this for per-daemon "Restart" buttons on UI cards;
-	// StartWithL1 stays the entry point for full-chain bootstrap. Same
-	// fire-and-forget shape as StartWithL1.
-	RestartDaemon(context.Context, *connect.Request[v1.RestartDaemonRequest]) (*connect.Response[v1.RestartDaemonResponse], error)
-	// Restart the whole L1 stack (bitcoind + enforcer) on the current config.
-	// Stops both (a not-running daemon is skipped, never an error) then boots
-	// the L1 chain via the same path as StartWithL1. Running sidechains are left
-	// alone — they reconnect once the enforcer is back. Fire-and-forget: returns
-	// as soon as the boot goroutine is dispatched. Use this for the "Restart
-	// Bitcoin Core and Enforcer" UI flow instead of hand-sequencing stop/start.
-	RestartL1(context.Context, *connect.Request[v1.RestartL1Request]) (*connect.Response[v1.RestartL1Response], error)
-	// Load a UTXO snapshot into the running Bitcoin Core. Streams download and
-	// load progress; a snapshot Core refuses (its base block already passed, or
-	// a snapshot already loaded in this datadir) comes back as an error carrying
-	// Core's own message. Nothing is stopped, restarted or deleted.
-	ApplyUTXOSnapshot(context.Context, *connect.Request[v1.ApplyUTXOSnapshotRequest], *connect.ServerStream[v1.ApplyUTXOSnapshotResponse]) error
-	// The UTXO snapshot published for the active network (from the network
-	// catalog) plus the one currently loaded in Bitcoin Core, if any. Feeds the
-	// settings UI: pre-fills the snapshot field and shows what is loaded.
-	GetSnapshotStatus(context.Context, *connect.Request[v1.GetSnapshotStatusRequest]) (*connect.Response[v1.GetSnapshotStatusResponse], error)
-	// The eCash network published but not switched to yet. Feeds the upgrade
-	// prompt; pending_network_id is empty when already on the newest one.
-	GetPendingNetworkGeneration(context.Context, *connect.Request[v1.GetPendingNetworkGenerationRequest]) (*connect.Response[v1.GetPendingNetworkGenerationResponse], error)
-	// Record the user's go-ahead to switch to the published eCash network.
-	// Nothing is stopped or deleted here: the caller must restart the backends,
-	// and the switch runs on the next start. Wallets survive, chain history and
-	// its transactions do not — only call with the user's confirmation.
-	ConfirmPendingNetworkGeneration(context.Context, *connect.Request[v1.ConfirmPendingNetworkGenerationRequest]) (*connect.Response[v1.ConfirmPendingNetworkGenerationResponse], error)
-	// Shutdown all running binaries.
-	ShutdownAll(context.Context, *connect.Request[v1.ShutdownAllRequest], *connect.ServerStream[v1.ShutdownAllResponse]) error
-	// Detached-daemon shutdown. bitwindowd calls this on window close;
-	// drivechaind acks immediately, drains its children (bitcoind, enforcer,
-	// sidechains) in a background goroutine, and os.Exit(0)s when done.
-	// Idempotent. If bitwindow is relaunched while the drain is still in
-	// flight, the next StartWithL1 transparently adopts it (flips the
-	// will-exit bit + awaits the in-flight stops) before booting a fresh
-	// stack — no separate cancel/await RPCs needed by callers.
-	Shutdown(context.Context, *connect.Request[v1.ShutdownRequest]) (*connect.Response[v1.ShutdownResponse], error)
-	// Point the daemon at the frontend process that owns it now. An app update
-	// replaces the frontend with a new process, and the daemon drains itself a
-	// few seconds after the old one dies. bitwindowd calls this the moment it
-	// finds a live daemon, so the warm stack survives the swap.
-	AdoptOwner(context.Context, *connect.Request[v1.AdoptOwnerRequest]) (*connect.Response[v1.AdoptOwnerResponse], error)
-	// Get the current BTC/USD exchange rate.
-	GetBTCPrice(context.Context, *connect.Request[v1.GetBTCPriceRequest]) (*connect.Response[v1.GetBTCPriceResponse], error)
-	// Get blockchain info from Bitcoin Core (proxied via orchestrator).
-	GetMainchainBlockchainInfo(context.Context, *connect.Request[v1.GetMainchainBlockchainInfoRequest]) (*connect.Response[v1.GetMainchainBlockchainInfoResponse], error)
-	// Get blockchain info from the enforcer (proxied via orchestrator).
-	GetEnforcerBlockchainInfo(context.Context, *connect.Request[v1.GetEnforcerBlockchainInfoRequest]) (*connect.Response[v1.GetEnforcerBlockchainInfoResponse], error)
-	// One-shot snapshot of mainchain + enforcer + bitwindow daemon sync state.
-	// Backend fans out to all three in parallel so the three numbers are taken
-	// at the same wall-clock instant — no two cards in the UI can ever disagree.
-	GetSyncStatus(context.Context, *connect.Request[v1.GetSyncStatusRequest]) (*connect.Response[v1.GetSyncStatusResponse], error)
-	// Snapshot of every binary the orchestrator is currently downloading.
-	// Reads from the in-memory DownloadManager state — light, polled by the
-	// frontend's DownloadProvider on a fast (100ms) cadence while a download
-	// is in flight, and dropping back to 2s when the response is empty.
-	GetDownloadStatus(context.Context, *connect.Request[v1.GetDownloadStatusRequest]) (*connect.Response[v1.GetDownloadStatusResponse], error)
-	// Get wallet balance from Bitcoin Core (proxied via orchestrator).
-	GetMainchainBalance(context.Context, *connect.Request[v1.GetMainchainBalanceRequest]) (*connect.Response[v1.GetMainchainBalanceResponse], error)
-	// Get wallet balance from a sidechain daemon (proxied via orchestrator).
-	GetSidechainBalance(context.Context, *connect.Request[v1.GetSidechainBalanceRequest]) (*connect.Response[v1.GetSidechainBalanceResponse], error)
-	// Gather the files/dirs that would be deleted for a per-binary deletion spec
-	// (no side effects). Shared by the single-binary wipe and the full reset page.
-	GatherFilesToDelete(context.Context, *connect.Request[v1.GatherFilesToDeleteRequest]) (*connect.Response[v1.GatherFilesToDeleteResponse], error)
-	// Delete the selected files. Stops binaries first; wallet paths are moved to
-	// wallet_backups/ instead of removed. Returns a gRPC error if it can't run.
-	// Streams one message per path; an unset error means that path succeeded.
-	DeleteFiles(context.Context, *connect.Request[v1.DeleteFilesRequest], *connect.ServerStream[v1.DeleteFilesResponse]) error
-	// Drop a block Core must not follow. Core rejects it and every block above
-	// it, then follows the best remaining valid branch.
-	RejectBlock(context.Context, *connect.Request[v1.RejectBlockRequest]) (*connect.Response[v1.RejectBlockResponse], error)
-	// Undo RejectBlock. Core re-checks the block and its branch, and follows it
-	// again when it has the most work.
-	AcceptBlock(context.Context, *connect.Request[v1.AcceptBlockRequest]) (*connect.Response[v1.AcceptBlockResponse], error)
-	// Move the chain back to a block, then sync forward to the tip again. Core
-	// drops the block and every block above it, then re-validates them from
-	// disk. Streams one message per phase.
-	ResetToBlock(context.Context, *connect.Request[v1.ResetToBlockRequest], *connect.ServerStream[v1.ResetToBlockResponse]) error
-	// Full bitcoind getmempoolinfo response. Distinct from getrawmempool.
-	GetCoreMempoolInfo(context.Context, *connect.Request[v1.GetCoreMempoolInfoRequest]) (*connect.Response[v1.GetCoreMempoolInfoResponse], error)
-	// Parent-chain state the sidechain BMM tab bids against: the tip a request
-	// targets, the fee rate it competes with, mempool depth.
-	GetBmmContext(context.Context, *connect.Request[v1.GetBmmContextRequest]) (*connect.Response[v1.GetBmmContextResponse], error)
-	// Generic raw bitcoind RPC. Optional `wallet` field routes the call to
-	// /wallet/{name} on bitcoind for wallet-scoped RPCs.
-	CoreRawCall(context.Context, *connect.Request[v1.CoreRawCallRequest]) (*connect.Response[v1.CoreRawCallResponse], error)
-	// ─── eCash fork ───────────────────────────────────────────────────────────
-	// Report where the mainchain tip sits relative to the eCash fork height.
-	// The orchestrator is the single source of truth for the fork height; the
-	// frontend renders "fork mode" (the claim card) off fork_active. Per-wallet
-	// pre-fork coin detection and the sweep itself stay in the frontend via the
-	// existing WalletManagerService (listUnspent / sendTransaction), one call
-	// per wallet — this RPC only supplies the height.
-	GetForkStatus(context.Context, *connect.Request[v1.GetForkStatusRequest]) (*connect.Response[v1.GetForkStatusResponse], error)
-	// Read the migration plan from the daemon without changes to node files.
-	PreviewECashMigration(context.Context, *connect.Request[v1.PreviewECashMigrationRequest]) (*connect.Response[v1.PreviewECashMigrationResponse], error)
-	// Start or resume a migration that continues after the client disconnects.
-	StartECashMigration(context.Context, *connect.Request[v1.StartECashMigrationRequest]) (*connect.Response[v1.StartECashMigrationResponse], error)
-	// Read the saved migration state from the daemon.
-	GetECashMigrationStatus(context.Context, *connect.Request[v1.GetECashMigrationStatusRequest]) (*connect.Response[v1.GetECashMigrationStatusResponse], error)
-	// Read the network the blocks on disk belong to, next to the one the app
-	// runs. The blocks name the chain, so a datadir from another network says so
-	// before a rollback throws the balance away.
-	GetDatadirNetwork(context.Context, *connect.Request[v1.GetDatadirNetworkRequest]) (*connect.Response[v1.GetDatadirNetworkResponse], error)
-}
-
-// NewOrchestratorServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewOrchestratorServiceHandler(svc OrchestratorServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	orchestratorServiceMethods := v1.File_orchestrator_v1_orchestrator_proto.Services().ByName("OrchestratorService").Methods()
-	orchestratorServiceListBinariesHandler := connect.NewUnaryHandler(
-		OrchestratorServiceListBinariesProcedure,
-		svc.ListBinaries,
-		connect.WithSchema(orchestratorServiceMethods.ByName("ListBinaries")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetBinaryStatusHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetBinaryStatusProcedure,
-		svc.GetBinaryStatus,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetBinaryStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetBinaryVersionHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetBinaryVersionProcedure,
-		svc.GetBinaryVersion,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetBinaryVersion")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceDownloadBinaryHandler := connect.NewUnaryHandler(
-		OrchestratorServiceDownloadBinaryProcedure,
-		svc.DownloadBinary,
-		connect.WithSchema(orchestratorServiceMethods.ByName("DownloadBinary")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceStartBinaryHandler := connect.NewUnaryHandler(
-		OrchestratorServiceStartBinaryProcedure,
-		svc.StartBinary,
-		connect.WithSchema(orchestratorServiceMethods.ByName("StartBinary")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceStopBinaryHandler := connect.NewUnaryHandler(
-		OrchestratorServiceStopBinaryProcedure,
-		svc.StopBinary,
-		connect.WithSchema(orchestratorServiceMethods.ByName("StopBinary")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceStreamLogsHandler := connect.NewServerStreamHandler(
-		OrchestratorServiceStreamLogsProcedure,
-		svc.StreamLogs,
-		connect.WithSchema(orchestratorServiceMethods.ByName("StreamLogs")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceStartWithL1Handler := connect.NewUnaryHandler(
-		OrchestratorServiceStartWithL1Procedure,
-		svc.StartWithL1,
-		connect.WithSchema(orchestratorServiceMethods.ByName("StartWithL1")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceRestartDaemonHandler := connect.NewUnaryHandler(
-		OrchestratorServiceRestartDaemonProcedure,
-		svc.RestartDaemon,
-		connect.WithSchema(orchestratorServiceMethods.ByName("RestartDaemon")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceRestartL1Handler := connect.NewUnaryHandler(
-		OrchestratorServiceRestartL1Procedure,
-		svc.RestartL1,
-		connect.WithSchema(orchestratorServiceMethods.ByName("RestartL1")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceApplyUTXOSnapshotHandler := connect.NewServerStreamHandler(
-		OrchestratorServiceApplyUTXOSnapshotProcedure,
-		svc.ApplyUTXOSnapshot,
-		connect.WithSchema(orchestratorServiceMethods.ByName("ApplyUTXOSnapshot")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetSnapshotStatusHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetSnapshotStatusProcedure,
-		svc.GetSnapshotStatus,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetSnapshotStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetPendingNetworkGenerationHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetPendingNetworkGenerationProcedure,
-		svc.GetPendingNetworkGeneration,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetPendingNetworkGeneration")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceConfirmPendingNetworkGenerationHandler := connect.NewUnaryHandler(
-		OrchestratorServiceConfirmPendingNetworkGenerationProcedure,
-		svc.ConfirmPendingNetworkGeneration,
-		connect.WithSchema(orchestratorServiceMethods.ByName("ConfirmPendingNetworkGeneration")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceShutdownAllHandler := connect.NewServerStreamHandler(
-		OrchestratorServiceShutdownAllProcedure,
-		svc.ShutdownAll,
-		connect.WithSchema(orchestratorServiceMethods.ByName("ShutdownAll")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceShutdownHandler := connect.NewUnaryHandler(
-		OrchestratorServiceShutdownProcedure,
-		svc.Shutdown,
-		connect.WithSchema(orchestratorServiceMethods.ByName("Shutdown")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceAdoptOwnerHandler := connect.NewUnaryHandler(
-		OrchestratorServiceAdoptOwnerProcedure,
-		svc.AdoptOwner,
-		connect.WithSchema(orchestratorServiceMethods.ByName("AdoptOwner")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetBTCPriceHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetBTCPriceProcedure,
-		svc.GetBTCPrice,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetBTCPrice")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetMainchainBlockchainInfoHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetMainchainBlockchainInfoProcedure,
-		svc.GetMainchainBlockchainInfo,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetMainchainBlockchainInfo")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetEnforcerBlockchainInfoHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetEnforcerBlockchainInfoProcedure,
-		svc.GetEnforcerBlockchainInfo,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetEnforcerBlockchainInfo")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetSyncStatusHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetSyncStatusProcedure,
-		svc.GetSyncStatus,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetSyncStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetDownloadStatusHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetDownloadStatusProcedure,
-		svc.GetDownloadStatus,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetDownloadStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetMainchainBalanceHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetMainchainBalanceProcedure,
-		svc.GetMainchainBalance,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetMainchainBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetSidechainBalanceHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetSidechainBalanceProcedure,
-		svc.GetSidechainBalance,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetSidechainBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGatherFilesToDeleteHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGatherFilesToDeleteProcedure,
-		svc.GatherFilesToDelete,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GatherFilesToDelete")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceDeleteFilesHandler := connect.NewServerStreamHandler(
-		OrchestratorServiceDeleteFilesProcedure,
-		svc.DeleteFiles,
-		connect.WithSchema(orchestratorServiceMethods.ByName("DeleteFiles")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceRejectBlockHandler := connect.NewUnaryHandler(
-		OrchestratorServiceRejectBlockProcedure,
-		svc.RejectBlock,
-		connect.WithSchema(orchestratorServiceMethods.ByName("RejectBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceAcceptBlockHandler := connect.NewUnaryHandler(
-		OrchestratorServiceAcceptBlockProcedure,
-		svc.AcceptBlock,
-		connect.WithSchema(orchestratorServiceMethods.ByName("AcceptBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceResetToBlockHandler := connect.NewServerStreamHandler(
-		OrchestratorServiceResetToBlockProcedure,
-		svc.ResetToBlock,
-		connect.WithSchema(orchestratorServiceMethods.ByName("ResetToBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetCoreMempoolInfoHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetCoreMempoolInfoProcedure,
-		svc.GetCoreMempoolInfo,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetCoreMempoolInfo")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetBmmContextHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetBmmContextProcedure,
-		svc.GetBmmContext,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetBmmContext")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceCoreRawCallHandler := connect.NewUnaryHandler(
-		OrchestratorServiceCoreRawCallProcedure,
-		svc.CoreRawCall,
-		connect.WithSchema(orchestratorServiceMethods.ByName("CoreRawCall")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetForkStatusHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetForkStatusProcedure,
-		svc.GetForkStatus,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetForkStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServicePreviewECashMigrationHandler := connect.NewUnaryHandler(
-		OrchestratorServicePreviewECashMigrationProcedure,
-		svc.PreviewECashMigration,
-		connect.WithSchema(orchestratorServiceMethods.ByName("PreviewECashMigration")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceStartECashMigrationHandler := connect.NewUnaryHandler(
-		OrchestratorServiceStartECashMigrationProcedure,
-		svc.StartECashMigration,
-		connect.WithSchema(orchestratorServiceMethods.ByName("StartECashMigration")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetECashMigrationStatusHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetECashMigrationStatusProcedure,
-		svc.GetECashMigrationStatus,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetECashMigrationStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	orchestratorServiceGetDatadirNetworkHandler := connect.NewUnaryHandler(
-		OrchestratorServiceGetDatadirNetworkProcedure,
-		svc.GetDatadirNetwork,
-		connect.WithSchema(orchestratorServiceMethods.ByName("GetDatadirNetwork")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/orchestrator.v1.OrchestratorService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case OrchestratorServiceListBinariesProcedure:
-			orchestratorServiceListBinariesHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetBinaryStatusProcedure:
-			orchestratorServiceGetBinaryStatusHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetBinaryVersionProcedure:
-			orchestratorServiceGetBinaryVersionHandler.ServeHTTP(w, r)
-		case OrchestratorServiceDownloadBinaryProcedure:
-			orchestratorServiceDownloadBinaryHandler.ServeHTTP(w, r)
-		case OrchestratorServiceStartBinaryProcedure:
-			orchestratorServiceStartBinaryHandler.ServeHTTP(w, r)
-		case OrchestratorServiceStopBinaryProcedure:
-			orchestratorServiceStopBinaryHandler.ServeHTTP(w, r)
-		case OrchestratorServiceStreamLogsProcedure:
-			orchestratorServiceStreamLogsHandler.ServeHTTP(w, r)
-		case OrchestratorServiceStartWithL1Procedure:
-			orchestratorServiceStartWithL1Handler.ServeHTTP(w, r)
-		case OrchestratorServiceRestartDaemonProcedure:
-			orchestratorServiceRestartDaemonHandler.ServeHTTP(w, r)
-		case OrchestratorServiceRestartL1Procedure:
-			orchestratorServiceRestartL1Handler.ServeHTTP(w, r)
-		case OrchestratorServiceApplyUTXOSnapshotProcedure:
-			orchestratorServiceApplyUTXOSnapshotHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetSnapshotStatusProcedure:
-			orchestratorServiceGetSnapshotStatusHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetPendingNetworkGenerationProcedure:
-			orchestratorServiceGetPendingNetworkGenerationHandler.ServeHTTP(w, r)
-		case OrchestratorServiceConfirmPendingNetworkGenerationProcedure:
-			orchestratorServiceConfirmPendingNetworkGenerationHandler.ServeHTTP(w, r)
-		case OrchestratorServiceShutdownAllProcedure:
-			orchestratorServiceShutdownAllHandler.ServeHTTP(w, r)
-		case OrchestratorServiceShutdownProcedure:
-			orchestratorServiceShutdownHandler.ServeHTTP(w, r)
-		case OrchestratorServiceAdoptOwnerProcedure:
-			orchestratorServiceAdoptOwnerHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetBTCPriceProcedure:
-			orchestratorServiceGetBTCPriceHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetMainchainBlockchainInfoProcedure:
-			orchestratorServiceGetMainchainBlockchainInfoHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetEnforcerBlockchainInfoProcedure:
-			orchestratorServiceGetEnforcerBlockchainInfoHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetSyncStatusProcedure:
-			orchestratorServiceGetSyncStatusHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetDownloadStatusProcedure:
-			orchestratorServiceGetDownloadStatusHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetMainchainBalanceProcedure:
-			orchestratorServiceGetMainchainBalanceHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetSidechainBalanceProcedure:
-			orchestratorServiceGetSidechainBalanceHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGatherFilesToDeleteProcedure:
-			orchestratorServiceGatherFilesToDeleteHandler.ServeHTTP(w, r)
-		case OrchestratorServiceDeleteFilesProcedure:
-			orchestratorServiceDeleteFilesHandler.ServeHTTP(w, r)
-		case OrchestratorServiceRejectBlockProcedure:
-			orchestratorServiceRejectBlockHandler.ServeHTTP(w, r)
-		case OrchestratorServiceAcceptBlockProcedure:
-			orchestratorServiceAcceptBlockHandler.ServeHTTP(w, r)
-		case OrchestratorServiceResetToBlockProcedure:
-			orchestratorServiceResetToBlockHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetCoreMempoolInfoProcedure:
-			orchestratorServiceGetCoreMempoolInfoHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetBmmContextProcedure:
-			orchestratorServiceGetBmmContextHandler.ServeHTTP(w, r)
-		case OrchestratorServiceCoreRawCallProcedure:
-			orchestratorServiceCoreRawCallHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetForkStatusProcedure:
-			orchestratorServiceGetForkStatusHandler.ServeHTTP(w, r)
-		case OrchestratorServicePreviewECashMigrationProcedure:
-			orchestratorServicePreviewECashMigrationHandler.ServeHTTP(w, r)
-		case OrchestratorServiceStartECashMigrationProcedure:
-			orchestratorServiceStartECashMigrationHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetECashMigrationStatusProcedure:
-			orchestratorServiceGetECashMigrationStatusHandler.ServeHTTP(w, r)
-		case OrchestratorServiceGetDatadirNetworkProcedure:
-			orchestratorServiceGetDatadirNetworkHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedOrchestratorServiceHandler) StreamLogs(context.Context, *v1.StreamLogsRequest, OrchestratorServiceStreamLogsServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.StreamLogs is not implemented")
 }
 
-// UnimplementedOrchestratorServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedOrchestratorServiceHandler struct{}
+func (UnimplementedOrchestratorServiceHandler) StartWithL1(context.Context, *v1.StartWithL1Request) (*v1.StartWithL1Response, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.StartWithL1 is not implemented")
+}
 
-func (UnimplementedOrchestratorServiceHandler) ListBinaries(context.Context, *connect.Request[v1.ListBinariesRequest]) (*connect.Response[v1.ListBinariesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.ListBinaries is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) RestartDaemon(context.Context, *v1.RestartDaemonRequest) (*v1.RestartDaemonResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.RestartDaemon is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetBinaryStatus(context.Context, *connect.Request[v1.GetBinaryStatusRequest]) (*connect.Response[v1.GetBinaryStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetBinaryStatus is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) RestartL1(context.Context, *v1.RestartL1Request) (*v1.RestartL1Response, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.RestartL1 is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetBinaryVersion(context.Context, *connect.Request[v1.GetBinaryVersionRequest]) (*connect.Response[v1.GetBinaryVersionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetBinaryVersion is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) ApplyUTXOSnapshot(context.Context, *v1.ApplyUTXOSnapshotRequest, OrchestratorServiceApplyUTXOSnapshotServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.ApplyUTXOSnapshot is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) DownloadBinary(context.Context, *connect.Request[v1.DownloadBinaryRequest]) (*connect.Response[v1.DownloadBinaryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.DownloadBinary is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetSnapshotStatus(context.Context, *v1.GetSnapshotStatusRequest) (*v1.GetSnapshotStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetSnapshotStatus is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) StartBinary(context.Context, *connect.Request[v1.StartBinaryRequest]) (*connect.Response[v1.StartBinaryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.StartBinary is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetPendingNetworkGeneration(context.Context, *v1.GetPendingNetworkGenerationRequest) (*v1.GetPendingNetworkGenerationResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetPendingNetworkGeneration is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) StopBinary(context.Context, *connect.Request[v1.StopBinaryRequest]) (*connect.Response[v1.StopBinaryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.StopBinary is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) ConfirmPendingNetworkGeneration(context.Context, *v1.ConfirmPendingNetworkGenerationRequest) (*v1.ConfirmPendingNetworkGenerationResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.ConfirmPendingNetworkGeneration is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) StreamLogs(context.Context, *connect.Request[v1.StreamLogsRequest], *connect.ServerStream[v1.StreamLogsResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.StreamLogs is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) ShutdownAll(context.Context, *v1.ShutdownAllRequest, OrchestratorServiceShutdownAllServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.ShutdownAll is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) StartWithL1(context.Context, *connect.Request[v1.StartWithL1Request]) (*connect.Response[v1.StartWithL1Response], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.StartWithL1 is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) Shutdown(context.Context, *v1.ShutdownRequest) (*v1.ShutdownResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.Shutdown is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) RestartDaemon(context.Context, *connect.Request[v1.RestartDaemonRequest]) (*connect.Response[v1.RestartDaemonResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.RestartDaemon is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) AdoptOwner(context.Context, *v1.AdoptOwnerRequest) (*v1.AdoptOwnerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.AdoptOwner is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) RestartL1(context.Context, *connect.Request[v1.RestartL1Request]) (*connect.Response[v1.RestartL1Response], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.RestartL1 is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetBTCPrice(context.Context, *v1.GetBTCPriceRequest) (*v1.GetBTCPriceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetBTCPrice is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) ApplyUTXOSnapshot(context.Context, *connect.Request[v1.ApplyUTXOSnapshotRequest], *connect.ServerStream[v1.ApplyUTXOSnapshotResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.ApplyUTXOSnapshot is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetMainchainBlockchainInfo(context.Context, *v1.GetMainchainBlockchainInfoRequest) (*v1.GetMainchainBlockchainInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetMainchainBlockchainInfo is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetSnapshotStatus(context.Context, *connect.Request[v1.GetSnapshotStatusRequest]) (*connect.Response[v1.GetSnapshotStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetSnapshotStatus is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetEnforcerBlockchainInfo(context.Context, *v1.GetEnforcerBlockchainInfoRequest) (*v1.GetEnforcerBlockchainInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetEnforcerBlockchainInfo is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetPendingNetworkGeneration(context.Context, *connect.Request[v1.GetPendingNetworkGenerationRequest]) (*connect.Response[v1.GetPendingNetworkGenerationResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetPendingNetworkGeneration is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetSyncStatus(context.Context, *v1.GetSyncStatusRequest) (*v1.GetSyncStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetSyncStatus is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) ConfirmPendingNetworkGeneration(context.Context, *connect.Request[v1.ConfirmPendingNetworkGenerationRequest]) (*connect.Response[v1.ConfirmPendingNetworkGenerationResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.ConfirmPendingNetworkGeneration is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetDownloadStatus(context.Context, *v1.GetDownloadStatusRequest) (*v1.GetDownloadStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetDownloadStatus is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) ShutdownAll(context.Context, *connect.Request[v1.ShutdownAllRequest], *connect.ServerStream[v1.ShutdownAllResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.ShutdownAll is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetMainchainBalance(context.Context, *v1.GetMainchainBalanceRequest) (*v1.GetMainchainBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetMainchainBalance is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) Shutdown(context.Context, *connect.Request[v1.ShutdownRequest]) (*connect.Response[v1.ShutdownResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.Shutdown is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetSidechainBalance(context.Context, *v1.GetSidechainBalanceRequest) (*v1.GetSidechainBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetSidechainBalance is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) AdoptOwner(context.Context, *connect.Request[v1.AdoptOwnerRequest]) (*connect.Response[v1.AdoptOwnerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.AdoptOwner is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GatherFilesToDelete(context.Context, *v1.GatherFilesToDeleteRequest) (*v1.GatherFilesToDeleteResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GatherFilesToDelete is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetBTCPrice(context.Context, *connect.Request[v1.GetBTCPriceRequest]) (*connect.Response[v1.GetBTCPriceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetBTCPrice is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) DeleteFiles(context.Context, *v1.DeleteFilesRequest, OrchestratorServiceDeleteFilesServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.DeleteFiles is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetMainchainBlockchainInfo(context.Context, *connect.Request[v1.GetMainchainBlockchainInfoRequest]) (*connect.Response[v1.GetMainchainBlockchainInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetMainchainBlockchainInfo is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) RejectBlock(context.Context, *v1.RejectBlockRequest) (*v1.RejectBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.RejectBlock is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetEnforcerBlockchainInfo(context.Context, *connect.Request[v1.GetEnforcerBlockchainInfoRequest]) (*connect.Response[v1.GetEnforcerBlockchainInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetEnforcerBlockchainInfo is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) AcceptBlock(context.Context, *v1.AcceptBlockRequest) (*v1.AcceptBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.AcceptBlock is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetSyncStatus(context.Context, *connect.Request[v1.GetSyncStatusRequest]) (*connect.Response[v1.GetSyncStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetSyncStatus is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) ResetToBlock(context.Context, *v1.ResetToBlockRequest, OrchestratorServiceResetToBlockServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.ResetToBlock is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetDownloadStatus(context.Context, *connect.Request[v1.GetDownloadStatusRequest]) (*connect.Response[v1.GetDownloadStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetDownloadStatus is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetCoreMempoolInfo(context.Context, *v1.GetCoreMempoolInfoRequest) (*v1.GetCoreMempoolInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetCoreMempoolInfo is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetMainchainBalance(context.Context, *connect.Request[v1.GetMainchainBalanceRequest]) (*connect.Response[v1.GetMainchainBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetMainchainBalance is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetBmmContext(context.Context, *v1.GetBmmContextRequest) (*v1.GetBmmContextResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetBmmContext is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetSidechainBalance(context.Context, *connect.Request[v1.GetSidechainBalanceRequest]) (*connect.Response[v1.GetSidechainBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetSidechainBalance is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) CoreRawCall(context.Context, *v1.CoreRawCallRequest) (*v1.CoreRawCallResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.CoreRawCall is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GatherFilesToDelete(context.Context, *connect.Request[v1.GatherFilesToDeleteRequest]) (*connect.Response[v1.GatherFilesToDeleteResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GatherFilesToDelete is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetForkStatus(context.Context, *v1.GetForkStatusRequest) (*v1.GetForkStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetForkStatus is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) DeleteFiles(context.Context, *connect.Request[v1.DeleteFilesRequest], *connect.ServerStream[v1.DeleteFilesResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.DeleteFiles is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) PreviewECashMigration(context.Context, *v1.PreviewECashMigrationRequest) (*v1.PreviewECashMigrationResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.PreviewECashMigration is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) RejectBlock(context.Context, *connect.Request[v1.RejectBlockRequest]) (*connect.Response[v1.RejectBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.RejectBlock is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) StartECashMigration(context.Context, *v1.StartECashMigrationRequest) (*v1.StartECashMigrationResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.StartECashMigration is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) AcceptBlock(context.Context, *connect.Request[v1.AcceptBlockRequest]) (*connect.Response[v1.AcceptBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.AcceptBlock is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetECashMigrationStatus(context.Context, *v1.GetECashMigrationStatusRequest) (*v1.GetECashMigrationStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetECashMigrationStatus is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) ResetToBlock(context.Context, *connect.Request[v1.ResetToBlockRequest], *connect.ServerStream[v1.ResetToBlockResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.ResetToBlock is not implemented"))
+func (UnimplementedOrchestratorServiceHandler) GetDatadirNetwork(context.Context, *v1.GetDatadirNetworkRequest) (*v1.GetDatadirNetworkResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.OrchestratorService.GetDatadirNetwork is not implemented")
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetCoreMempoolInfo(context.Context, *connect.Request[v1.GetCoreMempoolInfoRequest]) (*connect.Response[v1.GetCoreMempoolInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetCoreMempoolInfo is not implemented"))
+type orchestratorServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetBmmContext(context.Context, *connect.Request[v1.GetBmmContextRequest]) (*connect.Response[v1.GetBmmContextResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetBmmContext is not implemented"))
+func (c *orchestratorServiceClient) ListBinaries(ctx context.Context, req *v1.ListBinariesRequest) (*v1.ListBinariesResponse, error) {
+	var res v1.ListBinariesResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceListBinariesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedOrchestratorServiceHandler) CoreRawCall(context.Context, *connect.Request[v1.CoreRawCallRequest]) (*connect.Response[v1.CoreRawCallResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.CoreRawCall is not implemented"))
+func (c *orchestratorServiceClient) GetBinaryStatus(ctx context.Context, req *v1.GetBinaryStatusRequest) (*v1.GetBinaryStatusResponse, error) {
+	var res v1.GetBinaryStatusResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetBinaryStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetForkStatus(context.Context, *connect.Request[v1.GetForkStatusRequest]) (*connect.Response[v1.GetForkStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetForkStatus is not implemented"))
+func (c *orchestratorServiceClient) GetBinaryVersion(ctx context.Context, req *v1.GetBinaryVersionRequest) (*v1.GetBinaryVersionResponse, error) {
+	var res v1.GetBinaryVersionResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetBinaryVersionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedOrchestratorServiceHandler) PreviewECashMigration(context.Context, *connect.Request[v1.PreviewECashMigrationRequest]) (*connect.Response[v1.PreviewECashMigrationResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.PreviewECashMigration is not implemented"))
+func (c *orchestratorServiceClient) DownloadBinary(ctx context.Context, req *v1.DownloadBinaryRequest) (*v1.DownloadBinaryResponse, error) {
+	var res v1.DownloadBinaryResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceDownloadBinarySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedOrchestratorServiceHandler) StartECashMigration(context.Context, *connect.Request[v1.StartECashMigrationRequest]) (*connect.Response[v1.StartECashMigrationResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.StartECashMigration is not implemented"))
+func (c *orchestratorServiceClient) StartBinary(ctx context.Context, req *v1.StartBinaryRequest) (*v1.StartBinaryResponse, error) {
+	var res v1.StartBinaryResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceStartBinarySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetECashMigrationStatus(context.Context, *connect.Request[v1.GetECashMigrationStatusRequest]) (*connect.Response[v1.GetECashMigrationStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetECashMigrationStatus is not implemented"))
+func (c *orchestratorServiceClient) StopBinary(ctx context.Context, req *v1.StopBinaryRequest) (*v1.StopBinaryResponse, error) {
+	var res v1.StopBinaryResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceStopBinarySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) StreamLogs(ctx context.Context, req *v1.StreamLogsRequest) (OrchestratorServiceStreamLogsClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, orchestratorServiceStreamLogsSpec(), req)
+	if err != nil {
+		return OrchestratorServiceStreamLogsClientStream{}, err
+	}
+	return OrchestratorServiceStreamLogsClientStream{stream: stream}, nil
+}
+
+func (c *orchestratorServiceClient) StartWithL1(ctx context.Context, req *v1.StartWithL1Request) (*v1.StartWithL1Response, error) {
+	var res v1.StartWithL1Response
+	if err := c.client.CallUnary(ctx, orchestratorServiceStartWithL1Spec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) RestartDaemon(ctx context.Context, req *v1.RestartDaemonRequest) (*v1.RestartDaemonResponse, error) {
+	var res v1.RestartDaemonResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceRestartDaemonSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) RestartL1(ctx context.Context, req *v1.RestartL1Request) (*v1.RestartL1Response, error) {
+	var res v1.RestartL1Response
+	if err := c.client.CallUnary(ctx, orchestratorServiceRestartL1Spec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) ApplyUTXOSnapshot(ctx context.Context, req *v1.ApplyUTXOSnapshotRequest) (OrchestratorServiceApplyUTXOSnapshotClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, orchestratorServiceApplyUTXOSnapshotSpec(), req)
+	if err != nil {
+		return OrchestratorServiceApplyUTXOSnapshotClientStream{}, err
+	}
+	return OrchestratorServiceApplyUTXOSnapshotClientStream{stream: stream}, nil
+}
+
+func (c *orchestratorServiceClient) GetSnapshotStatus(ctx context.Context, req *v1.GetSnapshotStatusRequest) (*v1.GetSnapshotStatusResponse, error) {
+	var res v1.GetSnapshotStatusResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetSnapshotStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetPendingNetworkGeneration(ctx context.Context, req *v1.GetPendingNetworkGenerationRequest) (*v1.GetPendingNetworkGenerationResponse, error) {
+	var res v1.GetPendingNetworkGenerationResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetPendingNetworkGenerationSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedOrchestratorServiceHandler) GetDatadirNetwork(context.Context, *connect.Request[v1.GetDatadirNetworkRequest]) (*connect.Response[v1.GetDatadirNetworkResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.OrchestratorService.GetDatadirNetwork is not implemented"))
+func (c *orchestratorServiceClient) ConfirmPendingNetworkGeneration(ctx context.Context, req *v1.ConfirmPendingNetworkGenerationRequest) (*v1.ConfirmPendingNetworkGenerationResponse, error) {
+	var res v1.ConfirmPendingNetworkGenerationResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceConfirmPendingNetworkGenerationSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) ShutdownAll(ctx context.Context, req *v1.ShutdownAllRequest) (OrchestratorServiceShutdownAllClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, orchestratorServiceShutdownAllSpec(), req)
+	if err != nil {
+		return OrchestratorServiceShutdownAllClientStream{}, err
+	}
+	return OrchestratorServiceShutdownAllClientStream{stream: stream}, nil
+}
+
+func (c *orchestratorServiceClient) Shutdown(ctx context.Context, req *v1.ShutdownRequest) (*v1.ShutdownResponse, error) {
+	var res v1.ShutdownResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceShutdownSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) AdoptOwner(ctx context.Context, req *v1.AdoptOwnerRequest) (*v1.AdoptOwnerResponse, error) {
+	var res v1.AdoptOwnerResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceAdoptOwnerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetBTCPrice(ctx context.Context, req *v1.GetBTCPriceRequest) (*v1.GetBTCPriceResponse, error) {
+	var res v1.GetBTCPriceResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetBTCPriceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetMainchainBlockchainInfo(ctx context.Context, req *v1.GetMainchainBlockchainInfoRequest) (*v1.GetMainchainBlockchainInfoResponse, error) {
+	var res v1.GetMainchainBlockchainInfoResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetMainchainBlockchainInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetEnforcerBlockchainInfo(ctx context.Context, req *v1.GetEnforcerBlockchainInfoRequest) (*v1.GetEnforcerBlockchainInfoResponse, error) {
+	var res v1.GetEnforcerBlockchainInfoResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetEnforcerBlockchainInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetSyncStatus(ctx context.Context, req *v1.GetSyncStatusRequest) (*v1.GetSyncStatusResponse, error) {
+	var res v1.GetSyncStatusResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetSyncStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetDownloadStatus(ctx context.Context, req *v1.GetDownloadStatusRequest) (*v1.GetDownloadStatusResponse, error) {
+	var res v1.GetDownloadStatusResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetDownloadStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetMainchainBalance(ctx context.Context, req *v1.GetMainchainBalanceRequest) (*v1.GetMainchainBalanceResponse, error) {
+	var res v1.GetMainchainBalanceResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetMainchainBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetSidechainBalance(ctx context.Context, req *v1.GetSidechainBalanceRequest) (*v1.GetSidechainBalanceResponse, error) {
+	var res v1.GetSidechainBalanceResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetSidechainBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GatherFilesToDelete(ctx context.Context, req *v1.GatherFilesToDeleteRequest) (*v1.GatherFilesToDeleteResponse, error) {
+	var res v1.GatherFilesToDeleteResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGatherFilesToDeleteSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) DeleteFiles(ctx context.Context, req *v1.DeleteFilesRequest) (OrchestratorServiceDeleteFilesClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, orchestratorServiceDeleteFilesSpec(), req)
+	if err != nil {
+		return OrchestratorServiceDeleteFilesClientStream{}, err
+	}
+	return OrchestratorServiceDeleteFilesClientStream{stream: stream}, nil
+}
+
+func (c *orchestratorServiceClient) RejectBlock(ctx context.Context, req *v1.RejectBlockRequest) (*v1.RejectBlockResponse, error) {
+	var res v1.RejectBlockResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceRejectBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) AcceptBlock(ctx context.Context, req *v1.AcceptBlockRequest) (*v1.AcceptBlockResponse, error) {
+	var res v1.AcceptBlockResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceAcceptBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) ResetToBlock(ctx context.Context, req *v1.ResetToBlockRequest) (OrchestratorServiceResetToBlockClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, orchestratorServiceResetToBlockSpec(), req)
+	if err != nil {
+		return OrchestratorServiceResetToBlockClientStream{}, err
+	}
+	return OrchestratorServiceResetToBlockClientStream{stream: stream}, nil
+}
+
+func (c *orchestratorServiceClient) GetCoreMempoolInfo(ctx context.Context, req *v1.GetCoreMempoolInfoRequest) (*v1.GetCoreMempoolInfoResponse, error) {
+	var res v1.GetCoreMempoolInfoResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetCoreMempoolInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetBmmContext(ctx context.Context, req *v1.GetBmmContextRequest) (*v1.GetBmmContextResponse, error) {
+	var res v1.GetBmmContextResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetBmmContextSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) CoreRawCall(ctx context.Context, req *v1.CoreRawCallRequest) (*v1.CoreRawCallResponse, error) {
+	var res v1.CoreRawCallResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceCoreRawCallSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetForkStatus(ctx context.Context, req *v1.GetForkStatusRequest) (*v1.GetForkStatusResponse, error) {
+	var res v1.GetForkStatusResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetForkStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) PreviewECashMigration(ctx context.Context, req *v1.PreviewECashMigrationRequest) (*v1.PreviewECashMigrationResponse, error) {
+	var res v1.PreviewECashMigrationResponse
+	if err := c.client.CallUnary(ctx, orchestratorServicePreviewECashMigrationSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) StartECashMigration(ctx context.Context, req *v1.StartECashMigrationRequest) (*v1.StartECashMigrationResponse, error) {
+	var res v1.StartECashMigrationResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceStartECashMigrationSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetECashMigrationStatus(ctx context.Context, req *v1.GetECashMigrationStatusRequest) (*v1.GetECashMigrationStatusResponse, error) {
+	var res v1.GetECashMigrationStatusResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetECashMigrationStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *orchestratorServiceClient) GetDatadirNetwork(ctx context.Context, req *v1.GetDatadirNetworkRequest) (*v1.GetDatadirNetworkResponse, error) {
+	var res v1.GetDatadirNetworkResponse
+	if err := c.client.CallUnary(ctx, orchestratorServiceGetDatadirNetworkSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type orchestratorServiceHandler struct{ svc OrchestratorServiceHandler }
+
+func (h orchestratorServiceHandler) listBinaries(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListBinariesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListBinaries(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getBinaryStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBinaryStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBinaryStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getBinaryVersion(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBinaryVersionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBinaryVersion(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) downloadBinary(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DownloadBinaryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DownloadBinary(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) startBinary(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StartBinaryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StartBinary(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) stopBinary(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopBinaryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StopBinary(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) streamLogs(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StreamLogsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.StreamLogs(ctx, &req, OrchestratorServiceStreamLogsServerStream{stream: stream})
+}
+
+func (h orchestratorServiceHandler) startWithL1(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StartWithL1Request
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StartWithL1(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) restartDaemon(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RestartDaemonRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RestartDaemon(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) restartL1(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RestartL1Request
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RestartL1(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) applyUTXOSnapshot(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ApplyUTXOSnapshotRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.ApplyUTXOSnapshot(ctx, &req, OrchestratorServiceApplyUTXOSnapshotServerStream{stream: stream})
+}
+
+func (h orchestratorServiceHandler) getSnapshotStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSnapshotStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSnapshotStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getPendingNetworkGeneration(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingNetworkGenerationRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingNetworkGeneration(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) confirmPendingNetworkGeneration(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConfirmPendingNetworkGenerationRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConfirmPendingNetworkGeneration(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) shutdownAll(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ShutdownAllRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.ShutdownAll(ctx, &req, OrchestratorServiceShutdownAllServerStream{stream: stream})
+}
+
+func (h orchestratorServiceHandler) shutdown(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ShutdownRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Shutdown(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) adoptOwner(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.AdoptOwnerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.AdoptOwner(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getBTCPrice(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBTCPriceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBTCPrice(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getMainchainBlockchainInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetMainchainBlockchainInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetMainchainBlockchainInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getEnforcerBlockchainInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetEnforcerBlockchainInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetEnforcerBlockchainInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getSyncStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSyncStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSyncStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getDownloadStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetDownloadStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetDownloadStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getMainchainBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetMainchainBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetMainchainBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getSidechainBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) gatherFilesToDelete(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GatherFilesToDeleteRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GatherFilesToDelete(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) deleteFiles(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteFilesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.DeleteFiles(ctx, &req, OrchestratorServiceDeleteFilesServerStream{stream: stream})
+}
+
+func (h orchestratorServiceHandler) rejectBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RejectBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RejectBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) acceptBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.AcceptBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.AcceptBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) resetToBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ResetToBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.ResetToBlock(ctx, &req, OrchestratorServiceResetToBlockServerStream{stream: stream})
+}
+
+func (h orchestratorServiceHandler) getCoreMempoolInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetCoreMempoolInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCoreMempoolInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getBmmContext(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmContextRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmContext(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) coreRawCall(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CoreRawCallRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CoreRawCall(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getForkStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetForkStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetForkStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) previewECashMigration(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PreviewECashMigrationRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PreviewECashMigration(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) startECashMigration(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StartECashMigrationRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StartECashMigration(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getECashMigrationStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetECashMigrationStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetECashMigrationStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h orchestratorServiceHandler) getDatadirNetwork(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetDatadirNetworkRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetDatadirNetwork(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/sidechain_conf.connect.go b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/sidechain_conf.connect.go
index ea365f0c8d..5c1dda4dd2 100644
--- a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/sidechain_conf.connect.go
+++ b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/sidechain_conf.connect.go
@@ -5,171 +5,169 @@
 package orchestratorv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// SidechainConfServiceName is the fully-qualified name of the SidechainConfService service.
 	SidechainConfServiceName = "orchestrator.v1.SidechainConfService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// SidechainConfServiceGetSidechainConfigProcedure is the fully-qualified name of the
+	// SidechainConfServiceGetSidechainConfigProcedure is the procedure name of the
 	// SidechainConfService's GetSidechainConfig RPC.
 	SidechainConfServiceGetSidechainConfigProcedure = "/orchestrator.v1.SidechainConfService/GetSidechainConfig"
-	// SidechainConfServiceWriteSidechainConfigProcedure is the fully-qualified name of the
+	// SidechainConfServiceWriteSidechainConfigProcedure is the procedure name of the
 	// SidechainConfService's WriteSidechainConfig RPC.
 	SidechainConfServiceWriteSidechainConfigProcedure = "/orchestrator.v1.SidechainConfService/WriteSidechainConfig"
-	// SidechainConfServiceSyncSidechainNetworkFromBitcoinConfProcedure is the fully-qualified name of
-	// the SidechainConfService's SyncSidechainNetworkFromBitcoinConf RPC.
+	// SidechainConfServiceSyncSidechainNetworkFromBitcoinConfProcedure is the procedure name of the
+	// SidechainConfService's SyncSidechainNetworkFromBitcoinConf RPC.
 	SidechainConfServiceSyncSidechainNetworkFromBitcoinConfProcedure = "/orchestrator.v1.SidechainConfService/SyncSidechainNetworkFromBitcoinConf"
 )
 
+var (
+	sidechainConfServiceGetSidechainConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_sidechain_conf_proto.Services().ByName("SidechainConfService").Methods().ByName("GetSidechainConfig"),
+			Procedure:  SidechainConfServiceGetSidechainConfigProcedure,
+		}
+	})
+	sidechainConfServiceWriteSidechainConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_sidechain_conf_proto.Services().ByName("SidechainConfService").Methods().ByName("WriteSidechainConfig"),
+			Procedure:  SidechainConfServiceWriteSidechainConfigProcedure,
+		}
+	})
+	sidechainConfServiceSyncSidechainNetworkFromBitcoinConfSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_sidechain_conf_proto.Services().ByName("SidechainConfService").Methods().ByName("SyncSidechainNetworkFromBitcoinConf"),
+			Procedure:  SidechainConfServiceSyncSidechainNetworkFromBitcoinConfProcedure,
+		}
+	})
+)
+
 // SidechainConfServiceClient is a client for the orchestrator.v1.SidechainConfService service.
 type SidechainConfServiceClient interface {
-	// Get current sidechain configuration state.
-	GetSidechainConfig(context.Context, *connect.Request[v1.GetSidechainConfigRequest]) (*connect.Response[v1.GetSidechainConfigResponse], error)
-	// Write sidechain configuration content.
-	WriteSidechainConfig(context.Context, *connect.Request[v1.WriteSidechainConfigRequest]) (*connect.Response[v1.WriteSidechainConfigResponse], error)
-	// Sync network from Bitcoin Core config.
-	SyncSidechainNetworkFromBitcoinConf(context.Context, *connect.Request[v1.SyncSidechainNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncSidechainNetworkFromBitcoinConfResponse], error)
+	GetSidechainConfig(context.Context, *v1.GetSidechainConfigRequest) (*v1.GetSidechainConfigResponse, error)
+	WriteSidechainConfig(context.Context, *v1.WriteSidechainConfigRequest) (*v1.WriteSidechainConfigResponse, error)
+	SyncSidechainNetworkFromBitcoinConf(context.Context, *v1.SyncSidechainNetworkFromBitcoinConfRequest) (*v1.SyncSidechainNetworkFromBitcoinConfResponse, error)
 }
 
 // NewSidechainConfServiceClient constructs a client for the orchestrator.v1.SidechainConfService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewSidechainConfServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) SidechainConfServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	sidechainConfServiceMethods := v1.File_orchestrator_v1_sidechain_conf_proto.Services().ByName("SidechainConfService").Methods()
-	return &sidechainConfServiceClient{
-		getSidechainConfig: connect.NewClient[v1.GetSidechainConfigRequest, v1.GetSidechainConfigResponse](
-			httpClient,
-			baseURL+SidechainConfServiceGetSidechainConfigProcedure,
-			connect.WithSchema(sidechainConfServiceMethods.ByName("GetSidechainConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		writeSidechainConfig: connect.NewClient[v1.WriteSidechainConfigRequest, v1.WriteSidechainConfigResponse](
-			httpClient,
-			baseURL+SidechainConfServiceWriteSidechainConfigProcedure,
-			connect.WithSchema(sidechainConfServiceMethods.ByName("WriteSidechainConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		syncSidechainNetworkFromBitcoinConf: connect.NewClient[v1.SyncSidechainNetworkFromBitcoinConfRequest, v1.SyncSidechainNetworkFromBitcoinConfResponse](
-			httpClient,
-			baseURL+SidechainConfServiceSyncSidechainNetworkFromBitcoinConfProcedure,
-			connect.WithSchema(sidechainConfServiceMethods.ByName("SyncSidechainNetworkFromBitcoinConf")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// service. Multiple service clients may share a single connect.Client.
+func NewSidechainConfServiceClient(client *connect.Client) SidechainConfServiceClient {
+	return &sidechainConfServiceClient{client: client}
 }
 
-// sidechainConfServiceClient implements SidechainConfServiceClient.
-type sidechainConfServiceClient struct {
-	getSidechainConfig                  *connect.Client[v1.GetSidechainConfigRequest, v1.GetSidechainConfigResponse]
-	writeSidechainConfig                *connect.Client[v1.WriteSidechainConfigRequest, v1.WriteSidechainConfigResponse]
-	syncSidechainNetworkFromBitcoinConf *connect.Client[v1.SyncSidechainNetworkFromBitcoinConfRequest, v1.SyncSidechainNetworkFromBitcoinConfResponse]
+// SidechainConfServiceHandler is an implementation of the orchestrator.v1.SidechainConfService
+// service.
+type SidechainConfServiceHandler interface {
+	GetSidechainConfig(context.Context, *v1.GetSidechainConfigRequest) (*v1.GetSidechainConfigResponse, error)
+	WriteSidechainConfig(context.Context, *v1.WriteSidechainConfigRequest) (*v1.WriteSidechainConfigResponse, error)
+	SyncSidechainNetworkFromBitcoinConf(context.Context, *v1.SyncSidechainNetworkFromBitcoinConfRequest) (*v1.SyncSidechainNetworkFromBitcoinConfResponse, error)
 }
 
-// GetSidechainConfig calls orchestrator.v1.SidechainConfService.GetSidechainConfig.
-func (c *sidechainConfServiceClient) GetSidechainConfig(ctx context.Context, req *connect.Request[v1.GetSidechainConfigRequest]) (*connect.Response[v1.GetSidechainConfigResponse], error) {
-	return c.getSidechainConfig.CallUnary(ctx, req)
+// RegisterSidechainConfServiceHandler registers svc as the orchestrator.v1.SidechainConfService
+// implementation on server.
+func RegisterSidechainConfServiceHandler(server *connect.Server, svc SidechainConfServiceHandler) {
+	adapter := sidechainConfServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: sidechainConfServiceGetSidechainConfigSpec(), Handler: adapter.getSidechainConfig},
+		connect.Method{Spec: sidechainConfServiceWriteSidechainConfigSpec(), Handler: adapter.writeSidechainConfig},
+		connect.Method{Spec: sidechainConfServiceSyncSidechainNetworkFromBitcoinConfSpec(), Handler: adapter.syncSidechainNetworkFromBitcoinConf},
+	)
 }
 
-// WriteSidechainConfig calls orchestrator.v1.SidechainConfService.WriteSidechainConfig.
-func (c *sidechainConfServiceClient) WriteSidechainConfig(ctx context.Context, req *connect.Request[v1.WriteSidechainConfigRequest]) (*connect.Response[v1.WriteSidechainConfigResponse], error) {
-	return c.writeSidechainConfig.CallUnary(ctx, req)
+// UnimplementedSidechainConfServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedSidechainConfServiceHandler struct{}
+
+func (UnimplementedSidechainConfServiceHandler) GetSidechainConfig(context.Context, *v1.GetSidechainConfigRequest) (*v1.GetSidechainConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.SidechainConfService.GetSidechainConfig is not implemented")
 }
 
-// SyncSidechainNetworkFromBitcoinConf calls
-// orchestrator.v1.SidechainConfService.SyncSidechainNetworkFromBitcoinConf.
-func (c *sidechainConfServiceClient) SyncSidechainNetworkFromBitcoinConf(ctx context.Context, req *connect.Request[v1.SyncSidechainNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncSidechainNetworkFromBitcoinConfResponse], error) {
-	return c.syncSidechainNetworkFromBitcoinConf.CallUnary(ctx, req)
+func (UnimplementedSidechainConfServiceHandler) WriteSidechainConfig(context.Context, *v1.WriteSidechainConfigRequest) (*v1.WriteSidechainConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.SidechainConfService.WriteSidechainConfig is not implemented")
 }
 
-// SidechainConfServiceHandler is an implementation of the orchestrator.v1.SidechainConfService
-// service.
-type SidechainConfServiceHandler interface {
-	// Get current sidechain configuration state.
-	GetSidechainConfig(context.Context, *connect.Request[v1.GetSidechainConfigRequest]) (*connect.Response[v1.GetSidechainConfigResponse], error)
-	// Write sidechain configuration content.
-	WriteSidechainConfig(context.Context, *connect.Request[v1.WriteSidechainConfigRequest]) (*connect.Response[v1.WriteSidechainConfigResponse], error)
-	// Sync network from Bitcoin Core config.
-	SyncSidechainNetworkFromBitcoinConf(context.Context, *connect.Request[v1.SyncSidechainNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncSidechainNetworkFromBitcoinConfResponse], error)
+func (UnimplementedSidechainConfServiceHandler) SyncSidechainNetworkFromBitcoinConf(context.Context, *v1.SyncSidechainNetworkFromBitcoinConfRequest) (*v1.SyncSidechainNetworkFromBitcoinConfResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.SidechainConfService.SyncSidechainNetworkFromBitcoinConf is not implemented")
 }
 
-// NewSidechainConfServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewSidechainConfServiceHandler(svc SidechainConfServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	sidechainConfServiceMethods := v1.File_orchestrator_v1_sidechain_conf_proto.Services().ByName("SidechainConfService").Methods()
-	sidechainConfServiceGetSidechainConfigHandler := connect.NewUnaryHandler(
-		SidechainConfServiceGetSidechainConfigProcedure,
-		svc.GetSidechainConfig,
-		connect.WithSchema(sidechainConfServiceMethods.ByName("GetSidechainConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	sidechainConfServiceWriteSidechainConfigHandler := connect.NewUnaryHandler(
-		SidechainConfServiceWriteSidechainConfigProcedure,
-		svc.WriteSidechainConfig,
-		connect.WithSchema(sidechainConfServiceMethods.ByName("WriteSidechainConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	sidechainConfServiceSyncSidechainNetworkFromBitcoinConfHandler := connect.NewUnaryHandler(
-		SidechainConfServiceSyncSidechainNetworkFromBitcoinConfProcedure,
-		svc.SyncSidechainNetworkFromBitcoinConf,
-		connect.WithSchema(sidechainConfServiceMethods.ByName("SyncSidechainNetworkFromBitcoinConf")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/orchestrator.v1.SidechainConfService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case SidechainConfServiceGetSidechainConfigProcedure:
-			sidechainConfServiceGetSidechainConfigHandler.ServeHTTP(w, r)
-		case SidechainConfServiceWriteSidechainConfigProcedure:
-			sidechainConfServiceWriteSidechainConfigHandler.ServeHTTP(w, r)
-		case SidechainConfServiceSyncSidechainNetworkFromBitcoinConfProcedure:
-			sidechainConfServiceSyncSidechainNetworkFromBitcoinConfHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type sidechainConfServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedSidechainConfServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedSidechainConfServiceHandler struct{}
+func (c *sidechainConfServiceClient) GetSidechainConfig(ctx context.Context, req *v1.GetSidechainConfigRequest) (*v1.GetSidechainConfigResponse, error) {
+	var res v1.GetSidechainConfigResponse
+	if err := c.client.CallUnary(ctx, sidechainConfServiceGetSidechainConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedSidechainConfServiceHandler) GetSidechainConfig(context.Context, *connect.Request[v1.GetSidechainConfigRequest]) (*connect.Response[v1.GetSidechainConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.SidechainConfService.GetSidechainConfig is not implemented"))
+func (c *sidechainConfServiceClient) WriteSidechainConfig(ctx context.Context, req *v1.WriteSidechainConfigRequest) (*v1.WriteSidechainConfigResponse, error) {
+	var res v1.WriteSidechainConfigResponse
+	if err := c.client.CallUnary(ctx, sidechainConfServiceWriteSidechainConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedSidechainConfServiceHandler) WriteSidechainConfig(context.Context, *connect.Request[v1.WriteSidechainConfigRequest]) (*connect.Response[v1.WriteSidechainConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.SidechainConfService.WriteSidechainConfig is not implemented"))
+func (c *sidechainConfServiceClient) SyncSidechainNetworkFromBitcoinConf(ctx context.Context, req *v1.SyncSidechainNetworkFromBitcoinConfRequest) (*v1.SyncSidechainNetworkFromBitcoinConfResponse, error) {
+	var res v1.SyncSidechainNetworkFromBitcoinConfResponse
+	if err := c.client.CallUnary(ctx, sidechainConfServiceSyncSidechainNetworkFromBitcoinConfSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedSidechainConfServiceHandler) SyncSidechainNetworkFromBitcoinConf(context.Context, *connect.Request[v1.SyncSidechainNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncSidechainNetworkFromBitcoinConfResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.SidechainConfService.SyncSidechainNetworkFromBitcoinConf is not implemented"))
+type sidechainConfServiceHandler struct{ svc SidechainConfServiceHandler }
+
+func (h sidechainConfServiceHandler) getSidechainConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h sidechainConfServiceHandler) writeSidechainConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WriteSidechainConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.WriteSidechainConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h sidechainConfServiceHandler) syncSidechainNetworkFromBitcoinConf(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SyncSidechainNetworkFromBitcoinConfRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SyncSidechainNetworkFromBitcoinConf(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/thunder_conf.connect.go b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/thunder_conf.connect.go
index 872047a78e..9359f964f7 100644
--- a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/thunder_conf.connect.go
+++ b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/thunder_conf.connect.go
@@ -5,169 +5,168 @@
 package orchestratorv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ThunderConfServiceName is the fully-qualified name of the ThunderConfService service.
 	ThunderConfServiceName = "orchestrator.v1.ThunderConfService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ThunderConfServiceGetThunderConfigProcedure is the fully-qualified name of the
-	// ThunderConfService's GetThunderConfig RPC.
+	// ThunderConfServiceGetThunderConfigProcedure is the procedure name of the ThunderConfService's
+	// GetThunderConfig RPC.
 	ThunderConfServiceGetThunderConfigProcedure = "/orchestrator.v1.ThunderConfService/GetThunderConfig"
-	// ThunderConfServiceWriteThunderConfigProcedure is the fully-qualified name of the
-	// ThunderConfService's WriteThunderConfig RPC.
+	// ThunderConfServiceWriteThunderConfigProcedure is the procedure name of the ThunderConfService's
+	// WriteThunderConfig RPC.
 	ThunderConfServiceWriteThunderConfigProcedure = "/orchestrator.v1.ThunderConfService/WriteThunderConfig"
-	// ThunderConfServiceSyncNetworkFromBitcoinConfProcedure is the fully-qualified name of the
+	// ThunderConfServiceSyncNetworkFromBitcoinConfProcedure is the procedure name of the
 	// ThunderConfService's SyncNetworkFromBitcoinConf RPC.
 	ThunderConfServiceSyncNetworkFromBitcoinConfProcedure = "/orchestrator.v1.ThunderConfService/SyncNetworkFromBitcoinConf"
 )
 
+var (
+	thunderConfServiceGetThunderConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_thunder_conf_proto.Services().ByName("ThunderConfService").Methods().ByName("GetThunderConfig"),
+			Procedure:  ThunderConfServiceGetThunderConfigProcedure,
+		}
+	})
+	thunderConfServiceWriteThunderConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_thunder_conf_proto.Services().ByName("ThunderConfService").Methods().ByName("WriteThunderConfig"),
+			Procedure:  ThunderConfServiceWriteThunderConfigProcedure,
+		}
+	})
+	thunderConfServiceSyncNetworkFromBitcoinConfSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_thunder_conf_proto.Services().ByName("ThunderConfService").Methods().ByName("SyncNetworkFromBitcoinConf"),
+			Procedure:  ThunderConfServiceSyncNetworkFromBitcoinConfProcedure,
+		}
+	})
+)
+
 // ThunderConfServiceClient is a client for the orchestrator.v1.ThunderConfService service.
 type ThunderConfServiceClient interface {
-	// Get current Thunder sidechain configuration state.
-	GetThunderConfig(context.Context, *connect.Request[v1.GetThunderConfigRequest]) (*connect.Response[v1.GetThunderConfigResponse], error)
-	// Write Thunder configuration content.
-	WriteThunderConfig(context.Context, *connect.Request[v1.WriteThunderConfigRequest]) (*connect.Response[v1.WriteThunderConfigResponse], error)
-	// Sync network from Bitcoin Core config.
-	SyncNetworkFromBitcoinConf(context.Context, *connect.Request[v1.SyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncNetworkFromBitcoinConfResponse], error)
+	GetThunderConfig(context.Context, *v1.GetThunderConfigRequest) (*v1.GetThunderConfigResponse, error)
+	WriteThunderConfig(context.Context, *v1.WriteThunderConfigRequest) (*v1.WriteThunderConfigResponse, error)
+	SyncNetworkFromBitcoinConf(context.Context, *v1.SyncNetworkFromBitcoinConfRequest) (*v1.SyncNetworkFromBitcoinConfResponse, error)
 }
 
 // NewThunderConfServiceClient constructs a client for the orchestrator.v1.ThunderConfService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewThunderConfServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ThunderConfServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	thunderConfServiceMethods := v1.File_orchestrator_v1_thunder_conf_proto.Services().ByName("ThunderConfService").Methods()
-	return &thunderConfServiceClient{
-		getThunderConfig: connect.NewClient[v1.GetThunderConfigRequest, v1.GetThunderConfigResponse](
-			httpClient,
-			baseURL+ThunderConfServiceGetThunderConfigProcedure,
-			connect.WithSchema(thunderConfServiceMethods.ByName("GetThunderConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		writeThunderConfig: connect.NewClient[v1.WriteThunderConfigRequest, v1.WriteThunderConfigResponse](
-			httpClient,
-			baseURL+ThunderConfServiceWriteThunderConfigProcedure,
-			connect.WithSchema(thunderConfServiceMethods.ByName("WriteThunderConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		syncNetworkFromBitcoinConf: connect.NewClient[v1.SyncNetworkFromBitcoinConfRequest, v1.SyncNetworkFromBitcoinConfResponse](
-			httpClient,
-			baseURL+ThunderConfServiceSyncNetworkFromBitcoinConfProcedure,
-			connect.WithSchema(thunderConfServiceMethods.ByName("SyncNetworkFromBitcoinConf")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// service. Multiple service clients may share a single connect.Client.
+func NewThunderConfServiceClient(client *connect.Client) ThunderConfServiceClient {
+	return &thunderConfServiceClient{client: client}
 }
 
-// thunderConfServiceClient implements ThunderConfServiceClient.
-type thunderConfServiceClient struct {
-	getThunderConfig           *connect.Client[v1.GetThunderConfigRequest, v1.GetThunderConfigResponse]
-	writeThunderConfig         *connect.Client[v1.WriteThunderConfigRequest, v1.WriteThunderConfigResponse]
-	syncNetworkFromBitcoinConf *connect.Client[v1.SyncNetworkFromBitcoinConfRequest, v1.SyncNetworkFromBitcoinConfResponse]
+// ThunderConfServiceHandler is an implementation of the orchestrator.v1.ThunderConfService service.
+type ThunderConfServiceHandler interface {
+	GetThunderConfig(context.Context, *v1.GetThunderConfigRequest) (*v1.GetThunderConfigResponse, error)
+	WriteThunderConfig(context.Context, *v1.WriteThunderConfigRequest) (*v1.WriteThunderConfigResponse, error)
+	SyncNetworkFromBitcoinConf(context.Context, *v1.SyncNetworkFromBitcoinConfRequest) (*v1.SyncNetworkFromBitcoinConfResponse, error)
 }
 
-// GetThunderConfig calls orchestrator.v1.ThunderConfService.GetThunderConfig.
-func (c *thunderConfServiceClient) GetThunderConfig(ctx context.Context, req *connect.Request[v1.GetThunderConfigRequest]) (*connect.Response[v1.GetThunderConfigResponse], error) {
-	return c.getThunderConfig.CallUnary(ctx, req)
+// RegisterThunderConfServiceHandler registers svc as the orchestrator.v1.ThunderConfService
+// implementation on server.
+func RegisterThunderConfServiceHandler(server *connect.Server, svc ThunderConfServiceHandler) {
+	adapter := thunderConfServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: thunderConfServiceGetThunderConfigSpec(), Handler: adapter.getThunderConfig},
+		connect.Method{Spec: thunderConfServiceWriteThunderConfigSpec(), Handler: adapter.writeThunderConfig},
+		connect.Method{Spec: thunderConfServiceSyncNetworkFromBitcoinConfSpec(), Handler: adapter.syncNetworkFromBitcoinConf},
+	)
 }
 
-// WriteThunderConfig calls orchestrator.v1.ThunderConfService.WriteThunderConfig.
-func (c *thunderConfServiceClient) WriteThunderConfig(ctx context.Context, req *connect.Request[v1.WriteThunderConfigRequest]) (*connect.Response[v1.WriteThunderConfigResponse], error) {
-	return c.writeThunderConfig.CallUnary(ctx, req)
+// UnimplementedThunderConfServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedThunderConfServiceHandler struct{}
+
+func (UnimplementedThunderConfServiceHandler) GetThunderConfig(context.Context, *v1.GetThunderConfigRequest) (*v1.GetThunderConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.ThunderConfService.GetThunderConfig is not implemented")
 }
 
-// SyncNetworkFromBitcoinConf calls orchestrator.v1.ThunderConfService.SyncNetworkFromBitcoinConf.
-func (c *thunderConfServiceClient) SyncNetworkFromBitcoinConf(ctx context.Context, req *connect.Request[v1.SyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncNetworkFromBitcoinConfResponse], error) {
-	return c.syncNetworkFromBitcoinConf.CallUnary(ctx, req)
+func (UnimplementedThunderConfServiceHandler) WriteThunderConfig(context.Context, *v1.WriteThunderConfigRequest) (*v1.WriteThunderConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.ThunderConfService.WriteThunderConfig is not implemented")
 }
 
-// ThunderConfServiceHandler is an implementation of the orchestrator.v1.ThunderConfService service.
-type ThunderConfServiceHandler interface {
-	// Get current Thunder sidechain configuration state.
-	GetThunderConfig(context.Context, *connect.Request[v1.GetThunderConfigRequest]) (*connect.Response[v1.GetThunderConfigResponse], error)
-	// Write Thunder configuration content.
-	WriteThunderConfig(context.Context, *connect.Request[v1.WriteThunderConfigRequest]) (*connect.Response[v1.WriteThunderConfigResponse], error)
-	// Sync network from Bitcoin Core config.
-	SyncNetworkFromBitcoinConf(context.Context, *connect.Request[v1.SyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncNetworkFromBitcoinConfResponse], error)
+func (UnimplementedThunderConfServiceHandler) SyncNetworkFromBitcoinConf(context.Context, *v1.SyncNetworkFromBitcoinConfRequest) (*v1.SyncNetworkFromBitcoinConfResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.ThunderConfService.SyncNetworkFromBitcoinConf is not implemented")
 }
 
-// NewThunderConfServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewThunderConfServiceHandler(svc ThunderConfServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	thunderConfServiceMethods := v1.File_orchestrator_v1_thunder_conf_proto.Services().ByName("ThunderConfService").Methods()
-	thunderConfServiceGetThunderConfigHandler := connect.NewUnaryHandler(
-		ThunderConfServiceGetThunderConfigProcedure,
-		svc.GetThunderConfig,
-		connect.WithSchema(thunderConfServiceMethods.ByName("GetThunderConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderConfServiceWriteThunderConfigHandler := connect.NewUnaryHandler(
-		ThunderConfServiceWriteThunderConfigProcedure,
-		svc.WriteThunderConfig,
-		connect.WithSchema(thunderConfServiceMethods.ByName("WriteThunderConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderConfServiceSyncNetworkFromBitcoinConfHandler := connect.NewUnaryHandler(
-		ThunderConfServiceSyncNetworkFromBitcoinConfProcedure,
-		svc.SyncNetworkFromBitcoinConf,
-		connect.WithSchema(thunderConfServiceMethods.ByName("SyncNetworkFromBitcoinConf")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/orchestrator.v1.ThunderConfService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ThunderConfServiceGetThunderConfigProcedure:
-			thunderConfServiceGetThunderConfigHandler.ServeHTTP(w, r)
-		case ThunderConfServiceWriteThunderConfigProcedure:
-			thunderConfServiceWriteThunderConfigHandler.ServeHTTP(w, r)
-		case ThunderConfServiceSyncNetworkFromBitcoinConfProcedure:
-			thunderConfServiceSyncNetworkFromBitcoinConfHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type thunderConfServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedThunderConfServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedThunderConfServiceHandler struct{}
+func (c *thunderConfServiceClient) GetThunderConfig(ctx context.Context, req *v1.GetThunderConfigRequest) (*v1.GetThunderConfigResponse, error) {
+	var res v1.GetThunderConfigResponse
+	if err := c.client.CallUnary(ctx, thunderConfServiceGetThunderConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *thunderConfServiceClient) WriteThunderConfig(ctx context.Context, req *v1.WriteThunderConfigRequest) (*v1.WriteThunderConfigResponse, error) {
+	var res v1.WriteThunderConfigResponse
+	if err := c.client.CallUnary(ctx, thunderConfServiceWriteThunderConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedThunderConfServiceHandler) GetThunderConfig(context.Context, *connect.Request[v1.GetThunderConfigRequest]) (*connect.Response[v1.GetThunderConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.ThunderConfService.GetThunderConfig is not implemented"))
+func (c *thunderConfServiceClient) SyncNetworkFromBitcoinConf(ctx context.Context, req *v1.SyncNetworkFromBitcoinConfRequest) (*v1.SyncNetworkFromBitcoinConfResponse, error) {
+	var res v1.SyncNetworkFromBitcoinConfResponse
+	if err := c.client.CallUnary(ctx, thunderConfServiceSyncNetworkFromBitcoinConfSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderConfServiceHandler) WriteThunderConfig(context.Context, *connect.Request[v1.WriteThunderConfigRequest]) (*connect.Response[v1.WriteThunderConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.ThunderConfService.WriteThunderConfig is not implemented"))
+type thunderConfServiceHandler struct{ svc ThunderConfServiceHandler }
+
+func (h thunderConfServiceHandler) getThunderConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetThunderConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetThunderConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedThunderConfServiceHandler) SyncNetworkFromBitcoinConf(context.Context, *connect.Request[v1.SyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.SyncNetworkFromBitcoinConfResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.ThunderConfService.SyncNetworkFromBitcoinConf is not implemented"))
+func (h thunderConfServiceHandler) writeThunderConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WriteThunderConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.WriteThunderConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderConfServiceHandler) syncNetworkFromBitcoinConf(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SyncNetworkFromBitcoinConfRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SyncNetworkFromBitcoinConf(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/zside_conf.connect.go b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/zside_conf.connect.go
index ea3a2a22fe..01d6601ce4 100644
--- a/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/zside_conf.connect.go
+++ b/sidechain-orchestrator/gen/orchestrator/v1/orchestratorv1connect/zside_conf.connect.go
@@ -5,169 +5,168 @@
 package orchestratorv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/orchestrator/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ZSideConfServiceName is the fully-qualified name of the ZSideConfService service.
 	ZSideConfServiceName = "orchestrator.v1.ZSideConfService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ZSideConfServiceGetZSideConfigProcedure is the fully-qualified name of the ZSideConfService's
+	// ZSideConfServiceGetZSideConfigProcedure is the procedure name of the ZSideConfService's
 	// GetZSideConfig RPC.
 	ZSideConfServiceGetZSideConfigProcedure = "/orchestrator.v1.ZSideConfService/GetZSideConfig"
-	// ZSideConfServiceWriteZSideConfigProcedure is the fully-qualified name of the ZSideConfService's
+	// ZSideConfServiceWriteZSideConfigProcedure is the procedure name of the ZSideConfService's
 	// WriteZSideConfig RPC.
 	ZSideConfServiceWriteZSideConfigProcedure = "/orchestrator.v1.ZSideConfService/WriteZSideConfig"
-	// ZSideConfServiceSyncNetworkFromBitcoinConfProcedure is the fully-qualified name of the
+	// ZSideConfServiceSyncNetworkFromBitcoinConfProcedure is the procedure name of the
 	// ZSideConfService's SyncNetworkFromBitcoinConf RPC.
 	ZSideConfServiceSyncNetworkFromBitcoinConfProcedure = "/orchestrator.v1.ZSideConfService/SyncNetworkFromBitcoinConf"
 )
 
+var (
+	zSideConfServiceGetZSideConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_zside_conf_proto.Services().ByName("ZSideConfService").Methods().ByName("GetZSideConfig"),
+			Procedure:  ZSideConfServiceGetZSideConfigProcedure,
+		}
+	})
+	zSideConfServiceWriteZSideConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_zside_conf_proto.Services().ByName("ZSideConfService").Methods().ByName("WriteZSideConfig"),
+			Procedure:  ZSideConfServiceWriteZSideConfigProcedure,
+		}
+	})
+	zSideConfServiceSyncNetworkFromBitcoinConfSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_orchestrator_v1_zside_conf_proto.Services().ByName("ZSideConfService").Methods().ByName("SyncNetworkFromBitcoinConf"),
+			Procedure:  ZSideConfServiceSyncNetworkFromBitcoinConfProcedure,
+		}
+	})
+)
+
 // ZSideConfServiceClient is a client for the orchestrator.v1.ZSideConfService service.
 type ZSideConfServiceClient interface {
-	// Get current ZSide sidechain configuration state.
-	GetZSideConfig(context.Context, *connect.Request[v1.GetZSideConfigRequest]) (*connect.Response[v1.GetZSideConfigResponse], error)
-	// Write ZSide configuration content.
-	WriteZSideConfig(context.Context, *connect.Request[v1.WriteZSideConfigRequest]) (*connect.Response[v1.WriteZSideConfigResponse], error)
-	// Sync network from Bitcoin Core config.
-	SyncNetworkFromBitcoinConf(context.Context, *connect.Request[v1.ZSideSyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.ZSideSyncNetworkFromBitcoinConfResponse], error)
+	GetZSideConfig(context.Context, *v1.GetZSideConfigRequest) (*v1.GetZSideConfigResponse, error)
+	WriteZSideConfig(context.Context, *v1.WriteZSideConfigRequest) (*v1.WriteZSideConfigResponse, error)
+	SyncNetworkFromBitcoinConf(context.Context, *v1.ZSideSyncNetworkFromBitcoinConfRequest) (*v1.ZSideSyncNetworkFromBitcoinConfResponse, error)
 }
 
 // NewZSideConfServiceClient constructs a client for the orchestrator.v1.ZSideConfService service.
-// By default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped
-// responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewZSideConfServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ZSideConfServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	zSideConfServiceMethods := v1.File_orchestrator_v1_zside_conf_proto.Services().ByName("ZSideConfService").Methods()
-	return &zSideConfServiceClient{
-		getZSideConfig: connect.NewClient[v1.GetZSideConfigRequest, v1.GetZSideConfigResponse](
-			httpClient,
-			baseURL+ZSideConfServiceGetZSideConfigProcedure,
-			connect.WithSchema(zSideConfServiceMethods.ByName("GetZSideConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		writeZSideConfig: connect.NewClient[v1.WriteZSideConfigRequest, v1.WriteZSideConfigResponse](
-			httpClient,
-			baseURL+ZSideConfServiceWriteZSideConfigProcedure,
-			connect.WithSchema(zSideConfServiceMethods.ByName("WriteZSideConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		syncNetworkFromBitcoinConf: connect.NewClient[v1.ZSideSyncNetworkFromBitcoinConfRequest, v1.ZSideSyncNetworkFromBitcoinConfResponse](
-			httpClient,
-			baseURL+ZSideConfServiceSyncNetworkFromBitcoinConfProcedure,
-			connect.WithSchema(zSideConfServiceMethods.ByName("SyncNetworkFromBitcoinConf")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+// Multiple service clients may share a single connect.Client.
+func NewZSideConfServiceClient(client *connect.Client) ZSideConfServiceClient {
+	return &zSideConfServiceClient{client: client}
 }
 
-// zSideConfServiceClient implements ZSideConfServiceClient.
-type zSideConfServiceClient struct {
-	getZSideConfig             *connect.Client[v1.GetZSideConfigRequest, v1.GetZSideConfigResponse]
-	writeZSideConfig           *connect.Client[v1.WriteZSideConfigRequest, v1.WriteZSideConfigResponse]
-	syncNetworkFromBitcoinConf *connect.Client[v1.ZSideSyncNetworkFromBitcoinConfRequest, v1.ZSideSyncNetworkFromBitcoinConfResponse]
+// ZSideConfServiceHandler is an implementation of the orchestrator.v1.ZSideConfService service.
+type ZSideConfServiceHandler interface {
+	GetZSideConfig(context.Context, *v1.GetZSideConfigRequest) (*v1.GetZSideConfigResponse, error)
+	WriteZSideConfig(context.Context, *v1.WriteZSideConfigRequest) (*v1.WriteZSideConfigResponse, error)
+	SyncNetworkFromBitcoinConf(context.Context, *v1.ZSideSyncNetworkFromBitcoinConfRequest) (*v1.ZSideSyncNetworkFromBitcoinConfResponse, error)
 }
 
-// GetZSideConfig calls orchestrator.v1.ZSideConfService.GetZSideConfig.
-func (c *zSideConfServiceClient) GetZSideConfig(ctx context.Context, req *connect.Request[v1.GetZSideConfigRequest]) (*connect.Response[v1.GetZSideConfigResponse], error) {
-	return c.getZSideConfig.CallUnary(ctx, req)
+// RegisterZSideConfServiceHandler registers svc as the orchestrator.v1.ZSideConfService
+// implementation on server.
+func RegisterZSideConfServiceHandler(server *connect.Server, svc ZSideConfServiceHandler) {
+	adapter := zSideConfServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: zSideConfServiceGetZSideConfigSpec(), Handler: adapter.getZSideConfig},
+		connect.Method{Spec: zSideConfServiceWriteZSideConfigSpec(), Handler: adapter.writeZSideConfig},
+		connect.Method{Spec: zSideConfServiceSyncNetworkFromBitcoinConfSpec(), Handler: adapter.syncNetworkFromBitcoinConf},
+	)
 }
 
-// WriteZSideConfig calls orchestrator.v1.ZSideConfService.WriteZSideConfig.
-func (c *zSideConfServiceClient) WriteZSideConfig(ctx context.Context, req *connect.Request[v1.WriteZSideConfigRequest]) (*connect.Response[v1.WriteZSideConfigResponse], error) {
-	return c.writeZSideConfig.CallUnary(ctx, req)
+// UnimplementedZSideConfServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedZSideConfServiceHandler struct{}
+
+func (UnimplementedZSideConfServiceHandler) GetZSideConfig(context.Context, *v1.GetZSideConfigRequest) (*v1.GetZSideConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.ZSideConfService.GetZSideConfig is not implemented")
 }
 
-// SyncNetworkFromBitcoinConf calls orchestrator.v1.ZSideConfService.SyncNetworkFromBitcoinConf.
-func (c *zSideConfServiceClient) SyncNetworkFromBitcoinConf(ctx context.Context, req *connect.Request[v1.ZSideSyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.ZSideSyncNetworkFromBitcoinConfResponse], error) {
-	return c.syncNetworkFromBitcoinConf.CallUnary(ctx, req)
+func (UnimplementedZSideConfServiceHandler) WriteZSideConfig(context.Context, *v1.WriteZSideConfigRequest) (*v1.WriteZSideConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.ZSideConfService.WriteZSideConfig is not implemented")
 }
 
-// ZSideConfServiceHandler is an implementation of the orchestrator.v1.ZSideConfService service.
-type ZSideConfServiceHandler interface {
-	// Get current ZSide sidechain configuration state.
-	GetZSideConfig(context.Context, *connect.Request[v1.GetZSideConfigRequest]) (*connect.Response[v1.GetZSideConfigResponse], error)
-	// Write ZSide configuration content.
-	WriteZSideConfig(context.Context, *connect.Request[v1.WriteZSideConfigRequest]) (*connect.Response[v1.WriteZSideConfigResponse], error)
-	// Sync network from Bitcoin Core config.
-	SyncNetworkFromBitcoinConf(context.Context, *connect.Request[v1.ZSideSyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.ZSideSyncNetworkFromBitcoinConfResponse], error)
+func (UnimplementedZSideConfServiceHandler) SyncNetworkFromBitcoinConf(context.Context, *v1.ZSideSyncNetworkFromBitcoinConfRequest) (*v1.ZSideSyncNetworkFromBitcoinConfResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "orchestrator.v1.ZSideConfService.SyncNetworkFromBitcoinConf is not implemented")
 }
 
-// NewZSideConfServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewZSideConfServiceHandler(svc ZSideConfServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	zSideConfServiceMethods := v1.File_orchestrator_v1_zside_conf_proto.Services().ByName("ZSideConfService").Methods()
-	zSideConfServiceGetZSideConfigHandler := connect.NewUnaryHandler(
-		ZSideConfServiceGetZSideConfigProcedure,
-		svc.GetZSideConfig,
-		connect.WithSchema(zSideConfServiceMethods.ByName("GetZSideConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideConfServiceWriteZSideConfigHandler := connect.NewUnaryHandler(
-		ZSideConfServiceWriteZSideConfigProcedure,
-		svc.WriteZSideConfig,
-		connect.WithSchema(zSideConfServiceMethods.ByName("WriteZSideConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideConfServiceSyncNetworkFromBitcoinConfHandler := connect.NewUnaryHandler(
-		ZSideConfServiceSyncNetworkFromBitcoinConfProcedure,
-		svc.SyncNetworkFromBitcoinConf,
-		connect.WithSchema(zSideConfServiceMethods.ByName("SyncNetworkFromBitcoinConf")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/orchestrator.v1.ZSideConfService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ZSideConfServiceGetZSideConfigProcedure:
-			zSideConfServiceGetZSideConfigHandler.ServeHTTP(w, r)
-		case ZSideConfServiceWriteZSideConfigProcedure:
-			zSideConfServiceWriteZSideConfigHandler.ServeHTTP(w, r)
-		case ZSideConfServiceSyncNetworkFromBitcoinConfProcedure:
-			zSideConfServiceSyncNetworkFromBitcoinConfHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+type zSideConfServiceClient struct {
+	client *connect.Client
 }
 
-// UnimplementedZSideConfServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedZSideConfServiceHandler struct{}
+func (c *zSideConfServiceClient) GetZSideConfig(ctx context.Context, req *v1.GetZSideConfigRequest) (*v1.GetZSideConfigResponse, error) {
+	var res v1.GetZSideConfigResponse
+	if err := c.client.CallUnary(ctx, zSideConfServiceGetZSideConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideConfServiceClient) WriteZSideConfig(ctx context.Context, req *v1.WriteZSideConfigRequest) (*v1.WriteZSideConfigResponse, error) {
+	var res v1.WriteZSideConfigResponse
+	if err := c.client.CallUnary(ctx, zSideConfServiceWriteZSideConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedZSideConfServiceHandler) GetZSideConfig(context.Context, *connect.Request[v1.GetZSideConfigRequest]) (*connect.Response[v1.GetZSideConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.ZSideConfService.GetZSideConfig is not implemented"))
+func (c *zSideConfServiceClient) SyncNetworkFromBitcoinConf(ctx context.Context, req *v1.ZSideSyncNetworkFromBitcoinConfRequest) (*v1.ZSideSyncNetworkFromBitcoinConfResponse, error) {
+	var res v1.ZSideSyncNetworkFromBitcoinConfResponse
+	if err := c.client.CallUnary(ctx, zSideConfServiceSyncNetworkFromBitcoinConfSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideConfServiceHandler) WriteZSideConfig(context.Context, *connect.Request[v1.WriteZSideConfigRequest]) (*connect.Response[v1.WriteZSideConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.ZSideConfService.WriteZSideConfig is not implemented"))
+type zSideConfServiceHandler struct{ svc ZSideConfServiceHandler }
+
+func (h zSideConfServiceHandler) getZSideConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetZSideConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetZSideConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideConfServiceHandler) SyncNetworkFromBitcoinConf(context.Context, *connect.Request[v1.ZSideSyncNetworkFromBitcoinConfRequest]) (*connect.Response[v1.ZSideSyncNetworkFromBitcoinConfResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("orchestrator.v1.ZSideConfService.SyncNetworkFromBitcoinConf is not implemented"))
+func (h zSideConfServiceHandler) writeZSideConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WriteZSideConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.WriteZSideConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideConfServiceHandler) syncNetworkFromBitcoinConf(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ZSideSyncNetworkFromBitcoinConfRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SyncNetworkFromBitcoinConf(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/photon/v1/photonv1connect/photon.connect.go b/sidechain-orchestrator/gen/photon/v1/photonv1connect/photon.connect.go
index 4a1d2e7b3f..548cc7384f 100644
--- a/sidechain-orchestrator/gen/photon/v1/photonv1connect/photon.connect.go
+++ b/sidechain-orchestrator/gen/photon/v1/photonv1connect/photon.connect.go
@@ -5,844 +5,971 @@
 package photonv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/photon/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// PhotonServiceName is the fully-qualified name of the PhotonService service.
 	PhotonServiceName = "photon.v1.PhotonService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// PhotonServiceGetBalanceProcedure is the fully-qualified name of the PhotonService's GetBalance
-	// RPC.
+	// PhotonServiceGetBalanceProcedure is the procedure name of the PhotonService's GetBalance RPC.
 	PhotonServiceGetBalanceProcedure = "/photon.v1.PhotonService/GetBalance"
-	// PhotonServiceGetBlockCountProcedure is the fully-qualified name of the PhotonService's
-	// GetBlockCount RPC.
+	// PhotonServiceGetBlockCountProcedure is the procedure name of the PhotonService's GetBlockCount
+	// RPC.
 	PhotonServiceGetBlockCountProcedure = "/photon.v1.PhotonService/GetBlockCount"
-	// PhotonServiceStopProcedure is the fully-qualified name of the PhotonService's Stop RPC.
+	// PhotonServiceStopProcedure is the procedure name of the PhotonService's Stop RPC.
 	PhotonServiceStopProcedure = "/photon.v1.PhotonService/Stop"
-	// PhotonServiceGetNewAddressProcedure is the fully-qualified name of the PhotonService's
-	// GetNewAddress RPC.
+	// PhotonServiceGetNewAddressProcedure is the procedure name of the PhotonService's GetNewAddress
+	// RPC.
 	PhotonServiceGetNewAddressProcedure = "/photon.v1.PhotonService/GetNewAddress"
-	// PhotonServiceWithdrawProcedure is the fully-qualified name of the PhotonService's Withdraw RPC.
+	// PhotonServiceWithdrawProcedure is the procedure name of the PhotonService's Withdraw RPC.
 	PhotonServiceWithdrawProcedure = "/photon.v1.PhotonService/Withdraw"
-	// PhotonServiceTransferProcedure is the fully-qualified name of the PhotonService's Transfer RPC.
+	// PhotonServiceTransferProcedure is the procedure name of the PhotonService's Transfer RPC.
 	PhotonServiceTransferProcedure = "/photon.v1.PhotonService/Transfer"
-	// PhotonServiceGetSidechainWealthProcedure is the fully-qualified name of the PhotonService's
+	// PhotonServiceGetSidechainWealthProcedure is the procedure name of the PhotonService's
 	// GetSidechainWealth RPC.
 	PhotonServiceGetSidechainWealthProcedure = "/photon.v1.PhotonService/GetSidechainWealth"
-	// PhotonServiceCreateDepositProcedure is the fully-qualified name of the PhotonService's
-	// CreateDeposit RPC.
+	// PhotonServiceCreateDepositProcedure is the procedure name of the PhotonService's CreateDeposit
+	// RPC.
 	PhotonServiceCreateDepositProcedure = "/photon.v1.PhotonService/CreateDeposit"
-	// PhotonServiceGetPendingWithdrawalBundleProcedure is the fully-qualified name of the
-	// PhotonService's GetPendingWithdrawalBundle RPC.
+	// PhotonServiceGetPendingWithdrawalBundleProcedure is the procedure name of the PhotonService's
+	// GetPendingWithdrawalBundle RPC.
 	PhotonServiceGetPendingWithdrawalBundleProcedure = "/photon.v1.PhotonService/GetPendingWithdrawalBundle"
-	// PhotonServiceConnectPeerProcedure is the fully-qualified name of the PhotonService's ConnectPeer
-	// RPC.
+	// PhotonServiceConnectPeerProcedure is the procedure name of the PhotonService's ConnectPeer RPC.
 	PhotonServiceConnectPeerProcedure = "/photon.v1.PhotonService/ConnectPeer"
-	// PhotonServiceForgetPeerProcedure is the fully-qualified name of the PhotonService's ForgetPeer
-	// RPC.
+	// PhotonServiceForgetPeerProcedure is the procedure name of the PhotonService's ForgetPeer RPC.
 	PhotonServiceForgetPeerProcedure = "/photon.v1.PhotonService/ForgetPeer"
-	// PhotonServiceListPeersProcedure is the fully-qualified name of the PhotonService's ListPeers RPC.
+	// PhotonServiceListPeersProcedure is the procedure name of the PhotonService's ListPeers RPC.
 	PhotonServiceListPeersProcedure = "/photon.v1.PhotonService/ListPeers"
-	// PhotonServiceMineProcedure is the fully-qualified name of the PhotonService's Mine RPC.
+	// PhotonServiceMineProcedure is the procedure name of the PhotonService's Mine RPC.
 	PhotonServiceMineProcedure = "/photon.v1.PhotonService/Mine"
-	// PhotonServiceGetBlockProcedure is the fully-qualified name of the PhotonService's GetBlock RPC.
+	// PhotonServiceGetBlockProcedure is the procedure name of the PhotonService's GetBlock RPC.
 	PhotonServiceGetBlockProcedure = "/photon.v1.PhotonService/GetBlock"
-	// PhotonServiceGetBestMainchainBlockHashProcedure is the fully-qualified name of the
-	// PhotonService's GetBestMainchainBlockHash RPC.
+	// PhotonServiceGetBestMainchainBlockHashProcedure is the procedure name of the PhotonService's
+	// GetBestMainchainBlockHash RPC.
 	PhotonServiceGetBestMainchainBlockHashProcedure = "/photon.v1.PhotonService/GetBestMainchainBlockHash"
-	// PhotonServiceGetBestSidechainBlockHashProcedure is the fully-qualified name of the
-	// PhotonService's GetBestSidechainBlockHash RPC.
+	// PhotonServiceGetBestSidechainBlockHashProcedure is the procedure name of the PhotonService's
+	// GetBestSidechainBlockHash RPC.
 	PhotonServiceGetBestSidechainBlockHashProcedure = "/photon.v1.PhotonService/GetBestSidechainBlockHash"
-	// PhotonServiceGetBmmInclusionsProcedure is the fully-qualified name of the PhotonService's
+	// PhotonServiceGetBmmInclusionsProcedure is the procedure name of the PhotonService's
 	// GetBmmInclusions RPC.
 	PhotonServiceGetBmmInclusionsProcedure = "/photon.v1.PhotonService/GetBmmInclusions"
-	// PhotonServiceGetWalletUtxosProcedure is the fully-qualified name of the PhotonService's
-	// GetWalletUtxos RPC.
+	// PhotonServiceGetWalletUtxosProcedure is the procedure name of the PhotonService's GetWalletUtxos
+	// RPC.
 	PhotonServiceGetWalletUtxosProcedure = "/photon.v1.PhotonService/GetWalletUtxos"
-	// PhotonServiceListUtxosProcedure is the fully-qualified name of the PhotonService's ListUtxos RPC.
+	// PhotonServiceListUtxosProcedure is the procedure name of the PhotonService's ListUtxos RPC.
 	PhotonServiceListUtxosProcedure = "/photon.v1.PhotonService/ListUtxos"
-	// PhotonServiceRemoveFromMempoolProcedure is the fully-qualified name of the PhotonService's
+	// PhotonServiceRemoveFromMempoolProcedure is the procedure name of the PhotonService's
 	// RemoveFromMempool RPC.
 	PhotonServiceRemoveFromMempoolProcedure = "/photon.v1.PhotonService/RemoveFromMempool"
-	// PhotonServiceGetLatestFailedWithdrawalBundleHeightProcedure is the fully-qualified name of the
+	// PhotonServiceGetLatestFailedWithdrawalBundleHeightProcedure is the procedure name of the
 	// PhotonService's GetLatestFailedWithdrawalBundleHeight RPC.
 	PhotonServiceGetLatestFailedWithdrawalBundleHeightProcedure = "/photon.v1.PhotonService/GetLatestFailedWithdrawalBundleHeight"
-	// PhotonServiceGenerateMnemonicProcedure is the fully-qualified name of the PhotonService's
+	// PhotonServiceGenerateMnemonicProcedure is the procedure name of the PhotonService's
 	// GenerateMnemonic RPC.
 	PhotonServiceGenerateMnemonicProcedure = "/photon.v1.PhotonService/GenerateMnemonic"
-	// PhotonServiceSetSeedFromMnemonicProcedure is the fully-qualified name of the PhotonService's
+	// PhotonServiceSetSeedFromMnemonicProcedure is the procedure name of the PhotonService's
 	// SetSeedFromMnemonic RPC.
 	PhotonServiceSetSeedFromMnemonicProcedure = "/photon.v1.PhotonService/SetSeedFromMnemonic"
-	// PhotonServiceCallRawProcedure is the fully-qualified name of the PhotonService's CallRaw RPC.
+	// PhotonServiceCallRawProcedure is the procedure name of the PhotonService's CallRaw RPC.
 	PhotonServiceCallRawProcedure = "/photon.v1.PhotonService/CallRaw"
-	// PhotonServiceGetWalletAddressesProcedure is the fully-qualified name of the PhotonService's
+	// PhotonServiceGetWalletAddressesProcedure is the procedure name of the PhotonService's
 	// GetWalletAddresses RPC.
 	PhotonServiceGetWalletAddressesProcedure = "/photon.v1.PhotonService/GetWalletAddresses"
 )
 
+var (
+	photonServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetBalance"),
+			Procedure:  PhotonServiceGetBalanceProcedure,
+		}
+	})
+	photonServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetBlockCount"),
+			Procedure:  PhotonServiceGetBlockCountProcedure,
+		}
+	})
+	photonServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("Stop"),
+			Procedure:  PhotonServiceStopProcedure,
+		}
+	})
+	photonServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetNewAddress"),
+			Procedure:  PhotonServiceGetNewAddressProcedure,
+		}
+	})
+	photonServiceWithdrawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("Withdraw"),
+			Procedure:  PhotonServiceWithdrawProcedure,
+		}
+	})
+	photonServiceTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("Transfer"),
+			Procedure:  PhotonServiceTransferProcedure,
+		}
+	})
+	photonServiceGetSidechainWealthSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetSidechainWealth"),
+			Procedure:  PhotonServiceGetSidechainWealthProcedure,
+		}
+	})
+	photonServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("CreateDeposit"),
+			Procedure:  PhotonServiceCreateDepositProcedure,
+		}
+	})
+	photonServiceGetPendingWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetPendingWithdrawalBundle"),
+			Procedure:  PhotonServiceGetPendingWithdrawalBundleProcedure,
+		}
+	})
+	photonServiceConnectPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("ConnectPeer"),
+			Procedure:  PhotonServiceConnectPeerProcedure,
+		}
+	})
+	photonServiceForgetPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("ForgetPeer"),
+			Procedure:  PhotonServiceForgetPeerProcedure,
+		}
+	})
+	photonServiceListPeersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("ListPeers"),
+			Procedure:  PhotonServiceListPeersProcedure,
+		}
+	})
+	photonServiceMineSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("Mine"),
+			Procedure:  PhotonServiceMineProcedure,
+		}
+	})
+	photonServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetBlock"),
+			Procedure:  PhotonServiceGetBlockProcedure,
+		}
+	})
+	photonServiceGetBestMainchainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetBestMainchainBlockHash"),
+			Procedure:  PhotonServiceGetBestMainchainBlockHashProcedure,
+		}
+	})
+	photonServiceGetBestSidechainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetBestSidechainBlockHash"),
+			Procedure:  PhotonServiceGetBestSidechainBlockHashProcedure,
+		}
+	})
+	photonServiceGetBmmInclusionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetBmmInclusions"),
+			Procedure:  PhotonServiceGetBmmInclusionsProcedure,
+		}
+	})
+	photonServiceGetWalletUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetWalletUtxos"),
+			Procedure:  PhotonServiceGetWalletUtxosProcedure,
+		}
+	})
+	photonServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("ListUtxos"),
+			Procedure:  PhotonServiceListUtxosProcedure,
+		}
+	})
+	photonServiceRemoveFromMempoolSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("RemoveFromMempool"),
+			Procedure:  PhotonServiceRemoveFromMempoolProcedure,
+		}
+	})
+	photonServiceGetLatestFailedWithdrawalBundleHeightSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetLatestFailedWithdrawalBundleHeight"),
+			Procedure:  PhotonServiceGetLatestFailedWithdrawalBundleHeightProcedure,
+		}
+	})
+	photonServiceGenerateMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GenerateMnemonic"),
+			Procedure:  PhotonServiceGenerateMnemonicProcedure,
+		}
+	})
+	photonServiceSetSeedFromMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("SetSeedFromMnemonic"),
+			Procedure:  PhotonServiceSetSeedFromMnemonicProcedure,
+		}
+	})
+	photonServiceCallRawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("CallRaw"),
+			Procedure:  PhotonServiceCallRawProcedure,
+		}
+	})
+	photonServiceGetWalletAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods().ByName("GetWalletAddresses"),
+			Procedure:  PhotonServiceGetWalletAddressesProcedure,
+		}
+	})
+)
+
 // PhotonServiceClient is a client for the photon.v1.PhotonService service.
 type PhotonServiceClient interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the photon node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// Forget a peer.
-	ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-}
-
-// NewPhotonServiceClient constructs a client for the photon.v1.PhotonService service. By default,
-// it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and
-// sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC()
-// or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewPhotonServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) PhotonServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	photonServiceMethods := v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods()
-	return &photonServiceClient{
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+PhotonServiceGetBalanceProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+PhotonServiceGetBlockCountProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+PhotonServiceStopProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+PhotonServiceGetNewAddressProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		withdraw: connect.NewClient[v1.WithdrawRequest, v1.WithdrawResponse](
-			httpClient,
-			baseURL+PhotonServiceWithdrawProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("Withdraw")),
-			connect.WithClientOptions(opts...),
-		),
-		transfer: connect.NewClient[v1.TransferRequest, v1.TransferResponse](
-			httpClient,
-			baseURL+PhotonServiceTransferProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("Transfer")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainWealth: connect.NewClient[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse](
-			httpClient,
-			baseURL+PhotonServiceGetSidechainWealthProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetSidechainWealth")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+PhotonServiceCreateDepositProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingWithdrawalBundle: connect.NewClient[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse](
-			httpClient,
-			baseURL+PhotonServiceGetPendingWithdrawalBundleProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetPendingWithdrawalBundle")),
-			connect.WithClientOptions(opts...),
-		),
-		connectPeer: connect.NewClient[v1.ConnectPeerRequest, v1.ConnectPeerResponse](
-			httpClient,
-			baseURL+PhotonServiceConnectPeerProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("ConnectPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		forgetPeer: connect.NewClient[v1.ForgetPeerRequest, v1.ForgetPeerResponse](
-			httpClient,
-			baseURL+PhotonServiceForgetPeerProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("ForgetPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		listPeers: connect.NewClient[v1.ListPeersRequest, v1.ListPeersResponse](
-			httpClient,
-			baseURL+PhotonServiceListPeersProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("ListPeers")),
-			connect.WithClientOptions(opts...),
-		),
-		mine: connect.NewClient[v1.MineRequest, v1.MineResponse](
-			httpClient,
-			baseURL+PhotonServiceMineProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("Mine")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+PhotonServiceGetBlockProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestMainchainBlockHash: connect.NewClient[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse](
-			httpClient,
-			baseURL+PhotonServiceGetBestMainchainBlockHashProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetBestMainchainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestSidechainBlockHash: connect.NewClient[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse](
-			httpClient,
-			baseURL+PhotonServiceGetBestSidechainBlockHashProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetBestSidechainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmInclusions: connect.NewClient[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse](
-			httpClient,
-			baseURL+PhotonServiceGetBmmInclusionsProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetBmmInclusions")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletUtxos: connect.NewClient[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse](
-			httpClient,
-			baseURL+PhotonServiceGetWalletUtxosProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetWalletUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+PhotonServiceListUtxosProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		removeFromMempool: connect.NewClient[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse](
-			httpClient,
-			baseURL+PhotonServiceRemoveFromMempoolProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("RemoveFromMempool")),
-			connect.WithClientOptions(opts...),
-		),
-		getLatestFailedWithdrawalBundleHeight: connect.NewClient[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse](
-			httpClient,
-			baseURL+PhotonServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-			connect.WithClientOptions(opts...),
-		),
-		generateMnemonic: connect.NewClient[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse](
-			httpClient,
-			baseURL+PhotonServiceGenerateMnemonicProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GenerateMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		setSeedFromMnemonic: connect.NewClient[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse](
-			httpClient,
-			baseURL+PhotonServiceSetSeedFromMnemonicProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("SetSeedFromMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		callRaw: connect.NewClient[v1.CallRawRequest, v1.CallRawResponse](
-			httpClient,
-			baseURL+PhotonServiceCallRawProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("CallRaw")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletAddresses: connect.NewClient[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse](
-			httpClient,
-			baseURL+PhotonServiceGetWalletAddressesProcedure,
-			connect.WithSchema(photonServiceMethods.ByName("GetWalletAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// photonServiceClient implements PhotonServiceClient.
-type photonServiceClient struct {
-	getBalance                            *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getBlockCount                         *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	stop                                  *connect.Client[v1.StopRequest, v1.StopResponse]
-	getNewAddress                         *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	withdraw                              *connect.Client[v1.WithdrawRequest, v1.WithdrawResponse]
-	transfer                              *connect.Client[v1.TransferRequest, v1.TransferResponse]
-	getSidechainWealth                    *connect.Client[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse]
-	createDeposit                         *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	getPendingWithdrawalBundle            *connect.Client[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse]
-	connectPeer                           *connect.Client[v1.ConnectPeerRequest, v1.ConnectPeerResponse]
-	forgetPeer                            *connect.Client[v1.ForgetPeerRequest, v1.ForgetPeerResponse]
-	listPeers                             *connect.Client[v1.ListPeersRequest, v1.ListPeersResponse]
-	mine                                  *connect.Client[v1.MineRequest, v1.MineResponse]
-	getBlock                              *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	getBestMainchainBlockHash             *connect.Client[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse]
-	getBestSidechainBlockHash             *connect.Client[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse]
-	getBmmInclusions                      *connect.Client[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse]
-	getWalletUtxos                        *connect.Client[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse]
-	listUtxos                             *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	removeFromMempool                     *connect.Client[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse]
-	getLatestFailedWithdrawalBundleHeight *connect.Client[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse]
-	generateMnemonic                      *connect.Client[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse]
-	setSeedFromMnemonic                   *connect.Client[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse]
-	callRaw                               *connect.Client[v1.CallRawRequest, v1.CallRawResponse]
-	getWalletAddresses                    *connect.Client[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse]
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+}
+
+// NewPhotonServiceClient constructs a client for the photon.v1.PhotonService service. Multiple
+// service clients may share a single connect.Client.
+func NewPhotonServiceClient(client *connect.Client) PhotonServiceClient {
+	return &photonServiceClient{client: client}
 }
 
-// GetBalance calls photon.v1.PhotonService.GetBalance.
-func (c *photonServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// PhotonServiceHandler is an implementation of the photon.v1.PhotonService service.
+type PhotonServiceHandler interface {
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+}
+
+// RegisterPhotonServiceHandler registers svc as the photon.v1.PhotonService implementation on
+// server.
+func RegisterPhotonServiceHandler(server *connect.Server, svc PhotonServiceHandler) {
+	adapter := photonServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: photonServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: photonServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: photonServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: photonServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: photonServiceWithdrawSpec(), Handler: adapter.withdraw},
+		connect.Method{Spec: photonServiceTransferSpec(), Handler: adapter.transfer},
+		connect.Method{Spec: photonServiceGetSidechainWealthSpec(), Handler: adapter.getSidechainWealth},
+		connect.Method{Spec: photonServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: photonServiceGetPendingWithdrawalBundleSpec(), Handler: adapter.getPendingWithdrawalBundle},
+		connect.Method{Spec: photonServiceConnectPeerSpec(), Handler: adapter.connectPeer},
+		connect.Method{Spec: photonServiceForgetPeerSpec(), Handler: adapter.forgetPeer},
+		connect.Method{Spec: photonServiceListPeersSpec(), Handler: adapter.listPeers},
+		connect.Method{Spec: photonServiceMineSpec(), Handler: adapter.mine},
+		connect.Method{Spec: photonServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: photonServiceGetBestMainchainBlockHashSpec(), Handler: adapter.getBestMainchainBlockHash},
+		connect.Method{Spec: photonServiceGetBestSidechainBlockHashSpec(), Handler: adapter.getBestSidechainBlockHash},
+		connect.Method{Spec: photonServiceGetBmmInclusionsSpec(), Handler: adapter.getBmmInclusions},
+		connect.Method{Spec: photonServiceGetWalletUtxosSpec(), Handler: adapter.getWalletUtxos},
+		connect.Method{Spec: photonServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: photonServiceRemoveFromMempoolSpec(), Handler: adapter.removeFromMempool},
+		connect.Method{Spec: photonServiceGetLatestFailedWithdrawalBundleHeightSpec(), Handler: adapter.getLatestFailedWithdrawalBundleHeight},
+		connect.Method{Spec: photonServiceGenerateMnemonicSpec(), Handler: adapter.generateMnemonic},
+		connect.Method{Spec: photonServiceSetSeedFromMnemonicSpec(), Handler: adapter.setSeedFromMnemonic},
+		connect.Method{Spec: photonServiceCallRawSpec(), Handler: adapter.callRaw},
+		connect.Method{Spec: photonServiceGetWalletAddressesSpec(), Handler: adapter.getWalletAddresses},
+	)
 }
 
-// GetBlockCount calls photon.v1.PhotonService.GetBlockCount.
-func (c *photonServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// UnimplementedPhotonServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedPhotonServiceHandler struct{}
+
+func (UnimplementedPhotonServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetBalance is not implemented")
 }
 
-// Stop calls photon.v1.PhotonService.Stop.
-func (c *photonServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetBlockCount is not implemented")
 }
 
-// GetNewAddress calls photon.v1.PhotonService.GetNewAddress.
-func (c *photonServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.Stop is not implemented")
 }
 
-// Withdraw calls photon.v1.PhotonService.Withdraw.
-func (c *photonServiceClient) Withdraw(ctx context.Context, req *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return c.withdraw.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetNewAddress is not implemented")
 }
 
-// Transfer calls photon.v1.PhotonService.Transfer.
-func (c *photonServiceClient) Transfer(ctx context.Context, req *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return c.transfer.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.Withdraw is not implemented")
 }
 
-// GetSidechainWealth calls photon.v1.PhotonService.GetSidechainWealth.
-func (c *photonServiceClient) GetSidechainWealth(ctx context.Context, req *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return c.getSidechainWealth.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.Transfer is not implemented")
 }
 
-// CreateDeposit calls photon.v1.PhotonService.CreateDeposit.
-func (c *photonServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetSidechainWealth is not implemented")
 }
 
-// GetPendingWithdrawalBundle calls photon.v1.PhotonService.GetPendingWithdrawalBundle.
-func (c *photonServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return c.getPendingWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.CreateDeposit is not implemented")
 }
 
-// ConnectPeer calls photon.v1.PhotonService.ConnectPeer.
-func (c *photonServiceClient) ConnectPeer(ctx context.Context, req *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return c.connectPeer.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetPendingWithdrawalBundle is not implemented")
 }
 
-// ForgetPeer calls photon.v1.PhotonService.ForgetPeer.
-func (c *photonServiceClient) ForgetPeer(ctx context.Context, req *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error) {
-	return c.forgetPeer.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.ConnectPeer is not implemented")
 }
 
-// ListPeers calls photon.v1.PhotonService.ListPeers.
-func (c *photonServiceClient) ListPeers(ctx context.Context, req *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return c.listPeers.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) ForgetPeer(context.Context, *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.ForgetPeer is not implemented")
 }
 
-// Mine calls photon.v1.PhotonService.Mine.
-func (c *photonServiceClient) Mine(ctx context.Context, req *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return c.mine.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.ListPeers is not implemented")
 }
 
-// GetBlock calls photon.v1.PhotonService.GetBlock.
-func (c *photonServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.Mine is not implemented")
 }
 
-// GetBestMainchainBlockHash calls photon.v1.PhotonService.GetBestMainchainBlockHash.
-func (c *photonServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return c.getBestMainchainBlockHash.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetBlock is not implemented")
 }
 
-// GetBestSidechainBlockHash calls photon.v1.PhotonService.GetBestSidechainBlockHash.
-func (c *photonServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return c.getBestSidechainBlockHash.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetBestMainchainBlockHash is not implemented")
 }
 
-// GetBmmInclusions calls photon.v1.PhotonService.GetBmmInclusions.
-func (c *photonServiceClient) GetBmmInclusions(ctx context.Context, req *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return c.getBmmInclusions.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetBestSidechainBlockHash is not implemented")
 }
 
-// GetWalletUtxos calls photon.v1.PhotonService.GetWalletUtxos.
-func (c *photonServiceClient) GetWalletUtxos(ctx context.Context, req *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return c.getWalletUtxos.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetBmmInclusions is not implemented")
 }
 
-// ListUtxos calls photon.v1.PhotonService.ListUtxos.
-func (c *photonServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetWalletUtxos is not implemented")
 }
 
-// RemoveFromMempool calls photon.v1.PhotonService.RemoveFromMempool.
-func (c *photonServiceClient) RemoveFromMempool(ctx context.Context, req *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return c.removeFromMempool.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.ListUtxos is not implemented")
 }
 
-// GetLatestFailedWithdrawalBundleHeight calls
-// photon.v1.PhotonService.GetLatestFailedWithdrawalBundleHeight.
-func (c *photonServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return c.getLatestFailedWithdrawalBundleHeight.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.RemoveFromMempool is not implemented")
 }
 
-// GenerateMnemonic calls photon.v1.PhotonService.GenerateMnemonic.
-func (c *photonServiceClient) GenerateMnemonic(ctx context.Context, req *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return c.generateMnemonic.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetLatestFailedWithdrawalBundleHeight is not implemented")
 }
 
-// SetSeedFromMnemonic calls photon.v1.PhotonService.SetSeedFromMnemonic.
-func (c *photonServiceClient) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return c.setSeedFromMnemonic.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GenerateMnemonic is not implemented")
 }
 
-// CallRaw calls photon.v1.PhotonService.CallRaw.
-func (c *photonServiceClient) CallRaw(ctx context.Context, req *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return c.callRaw.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.SetSeedFromMnemonic is not implemented")
 }
 
-// GetWalletAddresses calls photon.v1.PhotonService.GetWalletAddresses.
-func (c *photonServiceClient) GetWalletAddresses(ctx context.Context, req *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return c.getWalletAddresses.CallUnary(ctx, req)
+func (UnimplementedPhotonServiceHandler) CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.CallRaw is not implemented")
 }
 
-// PhotonServiceHandler is an implementation of the photon.v1.PhotonService service.
-type PhotonServiceHandler interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the photon node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// Forget a peer.
-	ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-}
-
-// NewPhotonServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewPhotonServiceHandler(svc PhotonServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	photonServiceMethods := v1.File_photon_v1_photon_proto.Services().ByName("PhotonService").Methods()
-	photonServiceGetBalanceHandler := connect.NewUnaryHandler(
-		PhotonServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(photonServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		PhotonServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(photonServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceStopHandler := connect.NewUnaryHandler(
-		PhotonServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(photonServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		PhotonServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(photonServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceWithdrawHandler := connect.NewUnaryHandler(
-		PhotonServiceWithdrawProcedure,
-		svc.Withdraw,
-		connect.WithSchema(photonServiceMethods.ByName("Withdraw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceTransferHandler := connect.NewUnaryHandler(
-		PhotonServiceTransferProcedure,
-		svc.Transfer,
-		connect.WithSchema(photonServiceMethods.ByName("Transfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetSidechainWealthHandler := connect.NewUnaryHandler(
-		PhotonServiceGetSidechainWealthProcedure,
-		svc.GetSidechainWealth,
-		connect.WithSchema(photonServiceMethods.ByName("GetSidechainWealth")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceCreateDepositHandler := connect.NewUnaryHandler(
-		PhotonServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(photonServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetPendingWithdrawalBundleHandler := connect.NewUnaryHandler(
-		PhotonServiceGetPendingWithdrawalBundleProcedure,
-		svc.GetPendingWithdrawalBundle,
-		connect.WithSchema(photonServiceMethods.ByName("GetPendingWithdrawalBundle")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceConnectPeerHandler := connect.NewUnaryHandler(
-		PhotonServiceConnectPeerProcedure,
-		svc.ConnectPeer,
-		connect.WithSchema(photonServiceMethods.ByName("ConnectPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceForgetPeerHandler := connect.NewUnaryHandler(
-		PhotonServiceForgetPeerProcedure,
-		svc.ForgetPeer,
-		connect.WithSchema(photonServiceMethods.ByName("ForgetPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceListPeersHandler := connect.NewUnaryHandler(
-		PhotonServiceListPeersProcedure,
-		svc.ListPeers,
-		connect.WithSchema(photonServiceMethods.ByName("ListPeers")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceMineHandler := connect.NewUnaryHandler(
-		PhotonServiceMineProcedure,
-		svc.Mine,
-		connect.WithSchema(photonServiceMethods.ByName("Mine")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetBlockHandler := connect.NewUnaryHandler(
-		PhotonServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(photonServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetBestMainchainBlockHashHandler := connect.NewUnaryHandler(
-		PhotonServiceGetBestMainchainBlockHashProcedure,
-		svc.GetBestMainchainBlockHash,
-		connect.WithSchema(photonServiceMethods.ByName("GetBestMainchainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetBestSidechainBlockHashHandler := connect.NewUnaryHandler(
-		PhotonServiceGetBestSidechainBlockHashProcedure,
-		svc.GetBestSidechainBlockHash,
-		connect.WithSchema(photonServiceMethods.ByName("GetBestSidechainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetBmmInclusionsHandler := connect.NewUnaryHandler(
-		PhotonServiceGetBmmInclusionsProcedure,
-		svc.GetBmmInclusions,
-		connect.WithSchema(photonServiceMethods.ByName("GetBmmInclusions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetWalletUtxosHandler := connect.NewUnaryHandler(
-		PhotonServiceGetWalletUtxosProcedure,
-		svc.GetWalletUtxos,
-		connect.WithSchema(photonServiceMethods.ByName("GetWalletUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceListUtxosHandler := connect.NewUnaryHandler(
-		PhotonServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(photonServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceRemoveFromMempoolHandler := connect.NewUnaryHandler(
-		PhotonServiceRemoveFromMempoolProcedure,
-		svc.RemoveFromMempool,
-		connect.WithSchema(photonServiceMethods.ByName("RemoveFromMempool")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetLatestFailedWithdrawalBundleHeightHandler := connect.NewUnaryHandler(
-		PhotonServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-		svc.GetLatestFailedWithdrawalBundleHeight,
-		connect.WithSchema(photonServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGenerateMnemonicHandler := connect.NewUnaryHandler(
-		PhotonServiceGenerateMnemonicProcedure,
-		svc.GenerateMnemonic,
-		connect.WithSchema(photonServiceMethods.ByName("GenerateMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceSetSeedFromMnemonicHandler := connect.NewUnaryHandler(
-		PhotonServiceSetSeedFromMnemonicProcedure,
-		svc.SetSeedFromMnemonic,
-		connect.WithSchema(photonServiceMethods.ByName("SetSeedFromMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceCallRawHandler := connect.NewUnaryHandler(
-		PhotonServiceCallRawProcedure,
-		svc.CallRaw,
-		connect.WithSchema(photonServiceMethods.ByName("CallRaw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	photonServiceGetWalletAddressesHandler := connect.NewUnaryHandler(
-		PhotonServiceGetWalletAddressesProcedure,
-		svc.GetWalletAddresses,
-		connect.WithSchema(photonServiceMethods.ByName("GetWalletAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/photon.v1.PhotonService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case PhotonServiceGetBalanceProcedure:
-			photonServiceGetBalanceHandler.ServeHTTP(w, r)
-		case PhotonServiceGetBlockCountProcedure:
-			photonServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case PhotonServiceStopProcedure:
-			photonServiceStopHandler.ServeHTTP(w, r)
-		case PhotonServiceGetNewAddressProcedure:
-			photonServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case PhotonServiceWithdrawProcedure:
-			photonServiceWithdrawHandler.ServeHTTP(w, r)
-		case PhotonServiceTransferProcedure:
-			photonServiceTransferHandler.ServeHTTP(w, r)
-		case PhotonServiceGetSidechainWealthProcedure:
-			photonServiceGetSidechainWealthHandler.ServeHTTP(w, r)
-		case PhotonServiceCreateDepositProcedure:
-			photonServiceCreateDepositHandler.ServeHTTP(w, r)
-		case PhotonServiceGetPendingWithdrawalBundleProcedure:
-			photonServiceGetPendingWithdrawalBundleHandler.ServeHTTP(w, r)
-		case PhotonServiceConnectPeerProcedure:
-			photonServiceConnectPeerHandler.ServeHTTP(w, r)
-		case PhotonServiceForgetPeerProcedure:
-			photonServiceForgetPeerHandler.ServeHTTP(w, r)
-		case PhotonServiceListPeersProcedure:
-			photonServiceListPeersHandler.ServeHTTP(w, r)
-		case PhotonServiceMineProcedure:
-			photonServiceMineHandler.ServeHTTP(w, r)
-		case PhotonServiceGetBlockProcedure:
-			photonServiceGetBlockHandler.ServeHTTP(w, r)
-		case PhotonServiceGetBestMainchainBlockHashProcedure:
-			photonServiceGetBestMainchainBlockHashHandler.ServeHTTP(w, r)
-		case PhotonServiceGetBestSidechainBlockHashProcedure:
-			photonServiceGetBestSidechainBlockHashHandler.ServeHTTP(w, r)
-		case PhotonServiceGetBmmInclusionsProcedure:
-			photonServiceGetBmmInclusionsHandler.ServeHTTP(w, r)
-		case PhotonServiceGetWalletUtxosProcedure:
-			photonServiceGetWalletUtxosHandler.ServeHTTP(w, r)
-		case PhotonServiceListUtxosProcedure:
-			photonServiceListUtxosHandler.ServeHTTP(w, r)
-		case PhotonServiceRemoveFromMempoolProcedure:
-			photonServiceRemoveFromMempoolHandler.ServeHTTP(w, r)
-		case PhotonServiceGetLatestFailedWithdrawalBundleHeightProcedure:
-			photonServiceGetLatestFailedWithdrawalBundleHeightHandler.ServeHTTP(w, r)
-		case PhotonServiceGenerateMnemonicProcedure:
-			photonServiceGenerateMnemonicHandler.ServeHTTP(w, r)
-		case PhotonServiceSetSeedFromMnemonicProcedure:
-			photonServiceSetSeedFromMnemonicHandler.ServeHTTP(w, r)
-		case PhotonServiceCallRawProcedure:
-			photonServiceCallRawHandler.ServeHTTP(w, r)
-		case PhotonServiceGetWalletAddressesProcedure:
-			photonServiceGetWalletAddressesHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedPhotonServiceHandler) GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "photon.v1.PhotonService.GetWalletAddresses is not implemented")
 }
 
-// UnimplementedPhotonServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedPhotonServiceHandler struct{}
+type photonServiceClient struct {
+	client *connect.Client
+}
+
+func (c *photonServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, photonServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
 
-func (UnimplementedPhotonServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetBalance is not implemented"))
+func (c *photonServiceClient) Withdraw(ctx context.Context, req *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	var res v1.WithdrawResponse
+	if err := c.client.CallUnary(ctx, photonServiceWithdrawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) Transfer(ctx context.Context, req *v1.TransferRequest) (*v1.TransferResponse, error) {
+	var res v1.TransferResponse
+	if err := c.client.CallUnary(ctx, photonServiceTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetSidechainWealth(ctx context.Context, req *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	var res v1.GetSidechainWealthResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetSidechainWealthSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, photonServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	var res v1.GetPendingWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetPendingWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) ConnectPeer(ctx context.Context, req *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	var res v1.ConnectPeerResponse
+	if err := c.client.CallUnary(ctx, photonServiceConnectPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) ForgetPeer(ctx context.Context, req *v1.ForgetPeerRequest) (*v1.ForgetPeerResponse, error) {
+	var res v1.ForgetPeerResponse
+	if err := c.client.CallUnary(ctx, photonServiceForgetPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) ListPeers(ctx context.Context, req *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	var res v1.ListPeersResponse
+	if err := c.client.CallUnary(ctx, photonServiceListPeersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) Mine(ctx context.Context, req *v1.MineRequest) (*v1.MineResponse, error) {
+	var res v1.MineResponse
+	if err := c.client.CallUnary(ctx, photonServiceMineSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	var res v1.GetBestMainchainBlockHashResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetBestMainchainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	var res v1.GetBestSidechainBlockHashResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetBestSidechainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetBmmInclusions(ctx context.Context, req *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	var res v1.GetBmmInclusionsResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetBmmInclusionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetWalletUtxos(ctx context.Context, req *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	var res v1.GetWalletUtxosResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetWalletUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, photonServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) RemoveFromMempool(ctx context.Context, req *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	var res v1.RemoveFromMempoolResponse
+	if err := c.client.CallUnary(ctx, photonServiceRemoveFromMempoolSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	var res v1.GetLatestFailedWithdrawalBundleHeightResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetLatestFailedWithdrawalBundleHeightSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) GenerateMnemonic(ctx context.Context, req *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	var res v1.GenerateMnemonicResponse
+	if err := c.client.CallUnary(ctx, photonServiceGenerateMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) SetSeedFromMnemonic(ctx context.Context, req *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	var res v1.SetSeedFromMnemonicResponse
+	if err := c.client.CallUnary(ctx, photonServiceSetSeedFromMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *photonServiceClient) CallRaw(ctx context.Context, req *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	var res v1.CallRawResponse
+	if err := c.client.CallUnary(ctx, photonServiceCallRawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedPhotonServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetBlockCount is not implemented"))
+func (c *photonServiceClient) GetWalletAddresses(ctx context.Context, req *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	var res v1.GetWalletAddressesResponse
+	if err := c.client.CallUnary(ctx, photonServiceGetWalletAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedPhotonServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.Stop is not implemented"))
+type photonServiceHandler struct{ svc PhotonServiceHandler }
+
+func (h photonServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetNewAddress is not implemented"))
+func (h photonServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.Withdraw is not implemented"))
+func (h photonServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.Transfer is not implemented"))
+func (h photonServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetSidechainWealth is not implemented"))
+func (h photonServiceHandler) withdraw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WithdrawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Withdraw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.CreateDeposit is not implemented"))
+func (h photonServiceHandler) transfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Transfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetPendingWithdrawalBundle is not implemented"))
+func (h photonServiceHandler) getSidechainWealth(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainWealthRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainWealth(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.ConnectPeer is not implemented"))
+func (h photonServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) ForgetPeer(context.Context, *connect.Request[v1.ForgetPeerRequest]) (*connect.Response[v1.ForgetPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.ForgetPeer is not implemented"))
+func (h photonServiceHandler) getPendingWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.ListPeers is not implemented"))
+func (h photonServiceHandler) connectPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.Mine is not implemented"))
+func (h photonServiceHandler) forgetPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ForgetPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ForgetPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetBlock is not implemented"))
+func (h photonServiceHandler) listPeers(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPeersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPeers(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetBestMainchainBlockHash is not implemented"))
+func (h photonServiceHandler) mine(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MineRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Mine(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetBestSidechainBlockHash is not implemented"))
+func (h photonServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h photonServiceHandler) getBestMainchainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestMainchainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestMainchainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h photonServiceHandler) getBestSidechainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestSidechainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestSidechainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetBmmInclusions is not implemented"))
+func (h photonServiceHandler) getBmmInclusions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmInclusionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmInclusions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetWalletUtxos is not implemented"))
+func (h photonServiceHandler) getWalletUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.ListUtxos is not implemented"))
+func (h photonServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.RemoveFromMempool is not implemented"))
+func (h photonServiceHandler) removeFromMempool(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RemoveFromMempoolRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RemoveFromMempool(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetLatestFailedWithdrawalBundleHeight is not implemented"))
+func (h photonServiceHandler) getLatestFailedWithdrawalBundleHeight(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetLatestFailedWithdrawalBundleHeightRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetLatestFailedWithdrawalBundleHeight(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GenerateMnemonic is not implemented"))
+func (h photonServiceHandler) generateMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.SetSeedFromMnemonic is not implemented"))
+func (h photonServiceHandler) setSeedFromMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSeedFromMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSeedFromMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.CallRaw is not implemented"))
+func (h photonServiceHandler) callRaw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CallRawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CallRaw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedPhotonServiceHandler) GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("photon.v1.PhotonService.GetWalletAddresses is not implemented"))
+func (h photonServiceHandler) getWalletAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/stratum/v1/stratumv1connect/stratum.connect.go b/sidechain-orchestrator/gen/stratum/v1/stratumv1connect/stratum.connect.go
index baefc5f858..a43f67875c 100644
--- a/sidechain-orchestrator/gen/stratum/v1/stratumv1connect/stratum.connect.go
+++ b/sidechain-orchestrator/gen/stratum/v1/stratumv1connect/stratum.connect.go
@@ -5,353 +5,386 @@
 package stratumv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/stratum/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// StratumServiceName is the fully-qualified name of the StratumService service.
 	StratumServiceName = "stratum.v1.StratumService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// StratumServiceStartStratumProcedure is the fully-qualified name of the StratumService's
-	// StartStratum RPC.
+	// StratumServiceStartStratumProcedure is the procedure name of the StratumService's StartStratum
+	// RPC.
 	StratumServiceStartStratumProcedure = "/stratum.v1.StratumService/StartStratum"
-	// StratumServiceStopStratumProcedure is the fully-qualified name of the StratumService's
-	// StopStratum RPC.
+	// StratumServiceStopStratumProcedure is the procedure name of the StratumService's StopStratum RPC.
 	StratumServiceStopStratumProcedure = "/stratum.v1.StratumService/StopStratum"
-	// StratumServiceGetStratumStatusProcedure is the fully-qualified name of the StratumService's
+	// StratumServiceGetStratumStatusProcedure is the procedure name of the StratumService's
 	// GetStratumStatus RPC.
 	StratumServiceGetStratumStatusProcedure = "/stratum.v1.StratumService/GetStratumStatus"
-	// StratumServiceSetTargetProcedure is the fully-qualified name of the StratumService's SetTarget
-	// RPC.
+	// StratumServiceSetTargetProcedure is the procedure name of the StratumService's SetTarget RPC.
 	StratumServiceSetTargetProcedure = "/stratum.v1.StratumService/SetTarget"
-	// StratumServiceListTargetsProcedure is the fully-qualified name of the StratumService's
-	// ListTargets RPC.
+	// StratumServiceListTargetsProcedure is the procedure name of the StratumService's ListTargets RPC.
 	StratumServiceListTargetsProcedure = "/stratum.v1.StratumService/ListTargets"
-	// StratumServiceSetWorkModeProcedure is the fully-qualified name of the StratumService's
-	// SetWorkMode RPC.
+	// StratumServiceSetWorkModeProcedure is the procedure name of the StratumService's SetWorkMode RPC.
 	StratumServiceSetWorkModeProcedure = "/stratum.v1.StratumService/SetWorkMode"
-	// StratumServiceSetMiningSettingsProcedure is the fully-qualified name of the StratumService's
+	// StratumServiceSetMiningSettingsProcedure is the procedure name of the StratumService's
 	// SetMiningSettings RPC.
 	StratumServiceSetMiningSettingsProcedure = "/stratum.v1.StratumService/SetMiningSettings"
-	// StratumServiceGetHashrateHistoryProcedure is the fully-qualified name of the StratumService's
+	// StratumServiceGetHashrateHistoryProcedure is the procedure name of the StratumService's
 	// GetHashrateHistory RPC.
 	StratumServiceGetHashrateHistoryProcedure = "/stratum.v1.StratumService/GetHashrateHistory"
-	// StratumServiceListPoolBlocksProcedure is the fully-qualified name of the StratumService's
+	// StratumServiceListPoolBlocksProcedure is the procedure name of the StratumService's
 	// ListPoolBlocks RPC.
 	StratumServiceListPoolBlocksProcedure = "/stratum.v1.StratumService/ListPoolBlocks"
 )
 
+var (
+	stratumServiceStartStratumSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("StartStratum"),
+			Procedure:  StratumServiceStartStratumProcedure,
+		}
+	})
+	stratumServiceStopStratumSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("StopStratum"),
+			Procedure:  StratumServiceStopStratumProcedure,
+		}
+	})
+	stratumServiceGetStratumStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("GetStratumStatus"),
+			Procedure:  StratumServiceGetStratumStatusProcedure,
+		}
+	})
+	stratumServiceSetTargetSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("SetTarget"),
+			Procedure:  StratumServiceSetTargetProcedure,
+		}
+	})
+	stratumServiceListTargetsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("ListTargets"),
+			Procedure:  StratumServiceListTargetsProcedure,
+		}
+	})
+	stratumServiceSetWorkModeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("SetWorkMode"),
+			Procedure:  StratumServiceSetWorkModeProcedure,
+		}
+	})
+	stratumServiceSetMiningSettingsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("SetMiningSettings"),
+			Procedure:  StratumServiceSetMiningSettingsProcedure,
+		}
+	})
+	stratumServiceGetHashrateHistorySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("GetHashrateHistory"),
+			Procedure:  StratumServiceGetHashrateHistoryProcedure,
+		}
+	})
+	stratumServiceListPoolBlocksSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods().ByName("ListPoolBlocks"),
+			Procedure:  StratumServiceListPoolBlocksProcedure,
+		}
+	})
+)
+
 // StratumServiceClient is a client for the stratum.v1.StratumService service.
 type StratumServiceClient interface {
-	StartStratum(context.Context, *connect.Request[v1.StartStratumRequest]) (*connect.Response[v1.StartStratumResponse], error)
-	StopStratum(context.Context, *connect.Request[v1.StopStratumRequest]) (*connect.Response[v1.StopStratumResponse], error)
-	GetStratumStatus(context.Context, *connect.Request[v1.GetStratumStatusRequest]) (*connect.Response[v1.GetStratumStatusResponse], error)
-	// SetTarget selects where the miners' work goes. A running server switches
-	// at once and sends clean jobs.
-	SetTarget(context.Context, *connect.Request[v1.SetTargetRequest]) (*connect.Response[v1.SetTargetResponse], error)
-	// ListTargets returns the catalog pools of the running network.
-	ListTargets(context.Context, *connect.Request[v1.ListTargetsRequest]) (*connect.Response[v1.ListTargetsResponse], error)
-	// SetWorkMode changes the power mode of a connected miner over its device API.
-	SetWorkMode(context.Context, *connect.Request[v1.SetWorkModeRequest]) (*connect.Response[v1.SetWorkModeResponse], error)
-	// SetMiningSettings changes the fields it carries and leaves the rest. The
-	// hasher on this computer starts the server first when the server is stopped.
-	SetMiningSettings(context.Context, *connect.Request[v1.SetMiningSettingsRequest]) (*connect.Response[v1.SetMiningSettingsResponse], error)
-	// GetHashrateHistory returns the hashrate of all miners together over a range.
-	GetHashrateHistory(context.Context, *connect.Request[v1.GetHashrateHistoryRequest]) (*connect.Response[v1.GetHashrateHistoryResponse], error)
-	// ListPoolBlocks returns the blocks the upstream pool found, newest first.
-	ListPoolBlocks(context.Context, *connect.Request[v1.ListPoolBlocksRequest]) (*connect.Response[v1.ListPoolBlocksResponse], error)
-}
-
-// NewStratumServiceClient constructs a client for the stratum.v1.StratumService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewStratumServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) StratumServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	stratumServiceMethods := v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods()
-	return &stratumServiceClient{
-		startStratum: connect.NewClient[v1.StartStratumRequest, v1.StartStratumResponse](
-			httpClient,
-			baseURL+StratumServiceStartStratumProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("StartStratum")),
-			connect.WithClientOptions(opts...),
-		),
-		stopStratum: connect.NewClient[v1.StopStratumRequest, v1.StopStratumResponse](
-			httpClient,
-			baseURL+StratumServiceStopStratumProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("StopStratum")),
-			connect.WithClientOptions(opts...),
-		),
-		getStratumStatus: connect.NewClient[v1.GetStratumStatusRequest, v1.GetStratumStatusResponse](
-			httpClient,
-			baseURL+StratumServiceGetStratumStatusProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("GetStratumStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		setTarget: connect.NewClient[v1.SetTargetRequest, v1.SetTargetResponse](
-			httpClient,
-			baseURL+StratumServiceSetTargetProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("SetTarget")),
-			connect.WithClientOptions(opts...),
-		),
-		listTargets: connect.NewClient[v1.ListTargetsRequest, v1.ListTargetsResponse](
-			httpClient,
-			baseURL+StratumServiceListTargetsProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("ListTargets")),
-			connect.WithClientOptions(opts...),
-		),
-		setWorkMode: connect.NewClient[v1.SetWorkModeRequest, v1.SetWorkModeResponse](
-			httpClient,
-			baseURL+StratumServiceSetWorkModeProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("SetWorkMode")),
-			connect.WithClientOptions(opts...),
-		),
-		setMiningSettings: connect.NewClient[v1.SetMiningSettingsRequest, v1.SetMiningSettingsResponse](
-			httpClient,
-			baseURL+StratumServiceSetMiningSettingsProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("SetMiningSettings")),
-			connect.WithClientOptions(opts...),
-		),
-		getHashrateHistory: connect.NewClient[v1.GetHashrateHistoryRequest, v1.GetHashrateHistoryResponse](
-			httpClient,
-			baseURL+StratumServiceGetHashrateHistoryProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("GetHashrateHistory")),
-			connect.WithClientOptions(opts...),
-		),
-		listPoolBlocks: connect.NewClient[v1.ListPoolBlocksRequest, v1.ListPoolBlocksResponse](
-			httpClient,
-			baseURL+StratumServiceListPoolBlocksProcedure,
-			connect.WithSchema(stratumServiceMethods.ByName("ListPoolBlocks")),
-			connect.WithClientOptions(opts...),
-		),
-	}
+	StartStratum(context.Context, *v1.StartStratumRequest) (*v1.StartStratumResponse, error)
+	StopStratum(context.Context, *v1.StopStratumRequest) (*v1.StopStratumResponse, error)
+	GetStratumStatus(context.Context, *v1.GetStratumStatusRequest) (*v1.GetStratumStatusResponse, error)
+	SetTarget(context.Context, *v1.SetTargetRequest) (*v1.SetTargetResponse, error)
+	ListTargets(context.Context, *v1.ListTargetsRequest) (*v1.ListTargetsResponse, error)
+	SetWorkMode(context.Context, *v1.SetWorkModeRequest) (*v1.SetWorkModeResponse, error)
+	SetMiningSettings(context.Context, *v1.SetMiningSettingsRequest) (*v1.SetMiningSettingsResponse, error)
+	GetHashrateHistory(context.Context, *v1.GetHashrateHistoryRequest) (*v1.GetHashrateHistoryResponse, error)
+	ListPoolBlocks(context.Context, *v1.ListPoolBlocksRequest) (*v1.ListPoolBlocksResponse, error)
 }
 
-// stratumServiceClient implements StratumServiceClient.
-type stratumServiceClient struct {
-	startStratum       *connect.Client[v1.StartStratumRequest, v1.StartStratumResponse]
-	stopStratum        *connect.Client[v1.StopStratumRequest, v1.StopStratumResponse]
-	getStratumStatus   *connect.Client[v1.GetStratumStatusRequest, v1.GetStratumStatusResponse]
-	setTarget          *connect.Client[v1.SetTargetRequest, v1.SetTargetResponse]
-	listTargets        *connect.Client[v1.ListTargetsRequest, v1.ListTargetsResponse]
-	setWorkMode        *connect.Client[v1.SetWorkModeRequest, v1.SetWorkModeResponse]
-	setMiningSettings  *connect.Client[v1.SetMiningSettingsRequest, v1.SetMiningSettingsResponse]
-	getHashrateHistory *connect.Client[v1.GetHashrateHistoryRequest, v1.GetHashrateHistoryResponse]
-	listPoolBlocks     *connect.Client[v1.ListPoolBlocksRequest, v1.ListPoolBlocksResponse]
+// NewStratumServiceClient constructs a client for the stratum.v1.StratumService service. Multiple
+// service clients may share a single connect.Client.
+func NewStratumServiceClient(client *connect.Client) StratumServiceClient {
+	return &stratumServiceClient{client: client}
 }
 
-// StartStratum calls stratum.v1.StratumService.StartStratum.
-func (c *stratumServiceClient) StartStratum(ctx context.Context, req *connect.Request[v1.StartStratumRequest]) (*connect.Response[v1.StartStratumResponse], error) {
-	return c.startStratum.CallUnary(ctx, req)
+// StratumServiceHandler is an implementation of the stratum.v1.StratumService service.
+type StratumServiceHandler interface {
+	StartStratum(context.Context, *v1.StartStratumRequest) (*v1.StartStratumResponse, error)
+	StopStratum(context.Context, *v1.StopStratumRequest) (*v1.StopStratumResponse, error)
+	GetStratumStatus(context.Context, *v1.GetStratumStatusRequest) (*v1.GetStratumStatusResponse, error)
+	SetTarget(context.Context, *v1.SetTargetRequest) (*v1.SetTargetResponse, error)
+	ListTargets(context.Context, *v1.ListTargetsRequest) (*v1.ListTargetsResponse, error)
+	SetWorkMode(context.Context, *v1.SetWorkModeRequest) (*v1.SetWorkModeResponse, error)
+	SetMiningSettings(context.Context, *v1.SetMiningSettingsRequest) (*v1.SetMiningSettingsResponse, error)
+	GetHashrateHistory(context.Context, *v1.GetHashrateHistoryRequest) (*v1.GetHashrateHistoryResponse, error)
+	ListPoolBlocks(context.Context, *v1.ListPoolBlocksRequest) (*v1.ListPoolBlocksResponse, error)
 }
 
-// StopStratum calls stratum.v1.StratumService.StopStratum.
-func (c *stratumServiceClient) StopStratum(ctx context.Context, req *connect.Request[v1.StopStratumRequest]) (*connect.Response[v1.StopStratumResponse], error) {
-	return c.stopStratum.CallUnary(ctx, req)
+// RegisterStratumServiceHandler registers svc as the stratum.v1.StratumService implementation on
+// server.
+func RegisterStratumServiceHandler(server *connect.Server, svc StratumServiceHandler) {
+	adapter := stratumServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: stratumServiceStartStratumSpec(), Handler: adapter.startStratum},
+		connect.Method{Spec: stratumServiceStopStratumSpec(), Handler: adapter.stopStratum},
+		connect.Method{Spec: stratumServiceGetStratumStatusSpec(), Handler: adapter.getStratumStatus},
+		connect.Method{Spec: stratumServiceSetTargetSpec(), Handler: adapter.setTarget},
+		connect.Method{Spec: stratumServiceListTargetsSpec(), Handler: adapter.listTargets},
+		connect.Method{Spec: stratumServiceSetWorkModeSpec(), Handler: adapter.setWorkMode},
+		connect.Method{Spec: stratumServiceSetMiningSettingsSpec(), Handler: adapter.setMiningSettings},
+		connect.Method{Spec: stratumServiceGetHashrateHistorySpec(), Handler: adapter.getHashrateHistory},
+		connect.Method{Spec: stratumServiceListPoolBlocksSpec(), Handler: adapter.listPoolBlocks},
+	)
 }
 
-// GetStratumStatus calls stratum.v1.StratumService.GetStratumStatus.
-func (c *stratumServiceClient) GetStratumStatus(ctx context.Context, req *connect.Request[v1.GetStratumStatusRequest]) (*connect.Response[v1.GetStratumStatusResponse], error) {
-	return c.getStratumStatus.CallUnary(ctx, req)
+// UnimplementedStratumServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedStratumServiceHandler struct{}
+
+func (UnimplementedStratumServiceHandler) StartStratum(context.Context, *v1.StartStratumRequest) (*v1.StartStratumResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.StartStratum is not implemented")
 }
 
-// SetTarget calls stratum.v1.StratumService.SetTarget.
-func (c *stratumServiceClient) SetTarget(ctx context.Context, req *connect.Request[v1.SetTargetRequest]) (*connect.Response[v1.SetTargetResponse], error) {
-	return c.setTarget.CallUnary(ctx, req)
+func (UnimplementedStratumServiceHandler) StopStratum(context.Context, *v1.StopStratumRequest) (*v1.StopStratumResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.StopStratum is not implemented")
 }
 
-// ListTargets calls stratum.v1.StratumService.ListTargets.
-func (c *stratumServiceClient) ListTargets(ctx context.Context, req *connect.Request[v1.ListTargetsRequest]) (*connect.Response[v1.ListTargetsResponse], error) {
-	return c.listTargets.CallUnary(ctx, req)
+func (UnimplementedStratumServiceHandler) GetStratumStatus(context.Context, *v1.GetStratumStatusRequest) (*v1.GetStratumStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.GetStratumStatus is not implemented")
 }
 
-// SetWorkMode calls stratum.v1.StratumService.SetWorkMode.
-func (c *stratumServiceClient) SetWorkMode(ctx context.Context, req *connect.Request[v1.SetWorkModeRequest]) (*connect.Response[v1.SetWorkModeResponse], error) {
-	return c.setWorkMode.CallUnary(ctx, req)
+func (UnimplementedStratumServiceHandler) SetTarget(context.Context, *v1.SetTargetRequest) (*v1.SetTargetResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.SetTarget is not implemented")
 }
 
-// SetMiningSettings calls stratum.v1.StratumService.SetMiningSettings.
-func (c *stratumServiceClient) SetMiningSettings(ctx context.Context, req *connect.Request[v1.SetMiningSettingsRequest]) (*connect.Response[v1.SetMiningSettingsResponse], error) {
-	return c.setMiningSettings.CallUnary(ctx, req)
+func (UnimplementedStratumServiceHandler) ListTargets(context.Context, *v1.ListTargetsRequest) (*v1.ListTargetsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.ListTargets is not implemented")
 }
 
-// GetHashrateHistory calls stratum.v1.StratumService.GetHashrateHistory.
-func (c *stratumServiceClient) GetHashrateHistory(ctx context.Context, req *connect.Request[v1.GetHashrateHistoryRequest]) (*connect.Response[v1.GetHashrateHistoryResponse], error) {
-	return c.getHashrateHistory.CallUnary(ctx, req)
+func (UnimplementedStratumServiceHandler) SetWorkMode(context.Context, *v1.SetWorkModeRequest) (*v1.SetWorkModeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.SetWorkMode is not implemented")
 }
 
-// ListPoolBlocks calls stratum.v1.StratumService.ListPoolBlocks.
-func (c *stratumServiceClient) ListPoolBlocks(ctx context.Context, req *connect.Request[v1.ListPoolBlocksRequest]) (*connect.Response[v1.ListPoolBlocksResponse], error) {
-	return c.listPoolBlocks.CallUnary(ctx, req)
+func (UnimplementedStratumServiceHandler) SetMiningSettings(context.Context, *v1.SetMiningSettingsRequest) (*v1.SetMiningSettingsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.SetMiningSettings is not implemented")
 }
 
-// StratumServiceHandler is an implementation of the stratum.v1.StratumService service.
-type StratumServiceHandler interface {
-	StartStratum(context.Context, *connect.Request[v1.StartStratumRequest]) (*connect.Response[v1.StartStratumResponse], error)
-	StopStratum(context.Context, *connect.Request[v1.StopStratumRequest]) (*connect.Response[v1.StopStratumResponse], error)
-	GetStratumStatus(context.Context, *connect.Request[v1.GetStratumStatusRequest]) (*connect.Response[v1.GetStratumStatusResponse], error)
-	// SetTarget selects where the miners' work goes. A running server switches
-	// at once and sends clean jobs.
-	SetTarget(context.Context, *connect.Request[v1.SetTargetRequest]) (*connect.Response[v1.SetTargetResponse], error)
-	// ListTargets returns the catalog pools of the running network.
-	ListTargets(context.Context, *connect.Request[v1.ListTargetsRequest]) (*connect.Response[v1.ListTargetsResponse], error)
-	// SetWorkMode changes the power mode of a connected miner over its device API.
-	SetWorkMode(context.Context, *connect.Request[v1.SetWorkModeRequest]) (*connect.Response[v1.SetWorkModeResponse], error)
-	// SetMiningSettings changes the fields it carries and leaves the rest. The
-	// hasher on this computer starts the server first when the server is stopped.
-	SetMiningSettings(context.Context, *connect.Request[v1.SetMiningSettingsRequest]) (*connect.Response[v1.SetMiningSettingsResponse], error)
-	// GetHashrateHistory returns the hashrate of all miners together over a range.
-	GetHashrateHistory(context.Context, *connect.Request[v1.GetHashrateHistoryRequest]) (*connect.Response[v1.GetHashrateHistoryResponse], error)
-	// ListPoolBlocks returns the blocks the upstream pool found, newest first.
-	ListPoolBlocks(context.Context, *connect.Request[v1.ListPoolBlocksRequest]) (*connect.Response[v1.ListPoolBlocksResponse], error)
-}
-
-// NewStratumServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewStratumServiceHandler(svc StratumServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	stratumServiceMethods := v1.File_stratum_v1_stratum_proto.Services().ByName("StratumService").Methods()
-	stratumServiceStartStratumHandler := connect.NewUnaryHandler(
-		StratumServiceStartStratumProcedure,
-		svc.StartStratum,
-		connect.WithSchema(stratumServiceMethods.ByName("StartStratum")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceStopStratumHandler := connect.NewUnaryHandler(
-		StratumServiceStopStratumProcedure,
-		svc.StopStratum,
-		connect.WithSchema(stratumServiceMethods.ByName("StopStratum")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceGetStratumStatusHandler := connect.NewUnaryHandler(
-		StratumServiceGetStratumStatusProcedure,
-		svc.GetStratumStatus,
-		connect.WithSchema(stratumServiceMethods.ByName("GetStratumStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceSetTargetHandler := connect.NewUnaryHandler(
-		StratumServiceSetTargetProcedure,
-		svc.SetTarget,
-		connect.WithSchema(stratumServiceMethods.ByName("SetTarget")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceListTargetsHandler := connect.NewUnaryHandler(
-		StratumServiceListTargetsProcedure,
-		svc.ListTargets,
-		connect.WithSchema(stratumServiceMethods.ByName("ListTargets")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceSetWorkModeHandler := connect.NewUnaryHandler(
-		StratumServiceSetWorkModeProcedure,
-		svc.SetWorkMode,
-		connect.WithSchema(stratumServiceMethods.ByName("SetWorkMode")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceSetMiningSettingsHandler := connect.NewUnaryHandler(
-		StratumServiceSetMiningSettingsProcedure,
-		svc.SetMiningSettings,
-		connect.WithSchema(stratumServiceMethods.ByName("SetMiningSettings")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceGetHashrateHistoryHandler := connect.NewUnaryHandler(
-		StratumServiceGetHashrateHistoryProcedure,
-		svc.GetHashrateHistory,
-		connect.WithSchema(stratumServiceMethods.ByName("GetHashrateHistory")),
-		connect.WithHandlerOptions(opts...),
-	)
-	stratumServiceListPoolBlocksHandler := connect.NewUnaryHandler(
-		StratumServiceListPoolBlocksProcedure,
-		svc.ListPoolBlocks,
-		connect.WithSchema(stratumServiceMethods.ByName("ListPoolBlocks")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/stratum.v1.StratumService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case StratumServiceStartStratumProcedure:
-			stratumServiceStartStratumHandler.ServeHTTP(w, r)
-		case StratumServiceStopStratumProcedure:
-			stratumServiceStopStratumHandler.ServeHTTP(w, r)
-		case StratumServiceGetStratumStatusProcedure:
-			stratumServiceGetStratumStatusHandler.ServeHTTP(w, r)
-		case StratumServiceSetTargetProcedure:
-			stratumServiceSetTargetHandler.ServeHTTP(w, r)
-		case StratumServiceListTargetsProcedure:
-			stratumServiceListTargetsHandler.ServeHTTP(w, r)
-		case StratumServiceSetWorkModeProcedure:
-			stratumServiceSetWorkModeHandler.ServeHTTP(w, r)
-		case StratumServiceSetMiningSettingsProcedure:
-			stratumServiceSetMiningSettingsHandler.ServeHTTP(w, r)
-		case StratumServiceGetHashrateHistoryProcedure:
-			stratumServiceGetHashrateHistoryHandler.ServeHTTP(w, r)
-		case StratumServiceListPoolBlocksProcedure:
-			stratumServiceListPoolBlocksHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedStratumServiceHandler) GetHashrateHistory(context.Context, *v1.GetHashrateHistoryRequest) (*v1.GetHashrateHistoryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.GetHashrateHistory is not implemented")
 }
 
-// UnimplementedStratumServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedStratumServiceHandler struct{}
+func (UnimplementedStratumServiceHandler) ListPoolBlocks(context.Context, *v1.ListPoolBlocksRequest) (*v1.ListPoolBlocksResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "stratum.v1.StratumService.ListPoolBlocks is not implemented")
+}
 
-func (UnimplementedStratumServiceHandler) StartStratum(context.Context, *connect.Request[v1.StartStratumRequest]) (*connect.Response[v1.StartStratumResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.StartStratum is not implemented"))
+type stratumServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedStratumServiceHandler) StopStratum(context.Context, *connect.Request[v1.StopStratumRequest]) (*connect.Response[v1.StopStratumResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.StopStratum is not implemented"))
+func (c *stratumServiceClient) StartStratum(ctx context.Context, req *v1.StartStratumRequest) (*v1.StartStratumResponse, error) {
+	var res v1.StartStratumResponse
+	if err := c.client.CallUnary(ctx, stratumServiceStartStratumSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedStratumServiceHandler) GetStratumStatus(context.Context, *connect.Request[v1.GetStratumStatusRequest]) (*connect.Response[v1.GetStratumStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.GetStratumStatus is not implemented"))
+func (c *stratumServiceClient) StopStratum(ctx context.Context, req *v1.StopStratumRequest) (*v1.StopStratumResponse, error) {
+	var res v1.StopStratumResponse
+	if err := c.client.CallUnary(ctx, stratumServiceStopStratumSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedStratumServiceHandler) SetTarget(context.Context, *connect.Request[v1.SetTargetRequest]) (*connect.Response[v1.SetTargetResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.SetTarget is not implemented"))
+func (c *stratumServiceClient) GetStratumStatus(ctx context.Context, req *v1.GetStratumStatusRequest) (*v1.GetStratumStatusResponse, error) {
+	var res v1.GetStratumStatusResponse
+	if err := c.client.CallUnary(ctx, stratumServiceGetStratumStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedStratumServiceHandler) ListTargets(context.Context, *connect.Request[v1.ListTargetsRequest]) (*connect.Response[v1.ListTargetsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.ListTargets is not implemented"))
+func (c *stratumServiceClient) SetTarget(ctx context.Context, req *v1.SetTargetRequest) (*v1.SetTargetResponse, error) {
+	var res v1.SetTargetResponse
+	if err := c.client.CallUnary(ctx, stratumServiceSetTargetSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedStratumServiceHandler) SetWorkMode(context.Context, *connect.Request[v1.SetWorkModeRequest]) (*connect.Response[v1.SetWorkModeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.SetWorkMode is not implemented"))
+func (c *stratumServiceClient) ListTargets(ctx context.Context, req *v1.ListTargetsRequest) (*v1.ListTargetsResponse, error) {
+	var res v1.ListTargetsResponse
+	if err := c.client.CallUnary(ctx, stratumServiceListTargetsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedStratumServiceHandler) SetMiningSettings(context.Context, *connect.Request[v1.SetMiningSettingsRequest]) (*connect.Response[v1.SetMiningSettingsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.SetMiningSettings is not implemented"))
+func (c *stratumServiceClient) SetWorkMode(ctx context.Context, req *v1.SetWorkModeRequest) (*v1.SetWorkModeResponse, error) {
+	var res v1.SetWorkModeResponse
+	if err := c.client.CallUnary(ctx, stratumServiceSetWorkModeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedStratumServiceHandler) GetHashrateHistory(context.Context, *connect.Request[v1.GetHashrateHistoryRequest]) (*connect.Response[v1.GetHashrateHistoryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.GetHashrateHistory is not implemented"))
+func (c *stratumServiceClient) SetMiningSettings(ctx context.Context, req *v1.SetMiningSettingsRequest) (*v1.SetMiningSettingsResponse, error) {
+	var res v1.SetMiningSettingsResponse
+	if err := c.client.CallUnary(ctx, stratumServiceSetMiningSettingsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *stratumServiceClient) GetHashrateHistory(ctx context.Context, req *v1.GetHashrateHistoryRequest) (*v1.GetHashrateHistoryResponse, error) {
+	var res v1.GetHashrateHistoryResponse
+	if err := c.client.CallUnary(ctx, stratumServiceGetHashrateHistorySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedStratumServiceHandler) ListPoolBlocks(context.Context, *connect.Request[v1.ListPoolBlocksRequest]) (*connect.Response[v1.ListPoolBlocksResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("stratum.v1.StratumService.ListPoolBlocks is not implemented"))
+func (c *stratumServiceClient) ListPoolBlocks(ctx context.Context, req *v1.ListPoolBlocksRequest) (*v1.ListPoolBlocksResponse, error) {
+	var res v1.ListPoolBlocksResponse
+	if err := c.client.CallUnary(ctx, stratumServiceListPoolBlocksSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type stratumServiceHandler struct{ svc StratumServiceHandler }
+
+func (h stratumServiceHandler) startStratum(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StartStratumRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StartStratum(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) stopStratum(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopStratumRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.StopStratum(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) getStratumStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetStratumStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetStratumStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) setTarget(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetTargetRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetTarget(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) listTargets(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListTargetsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTargets(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) setWorkMode(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetWorkModeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetWorkMode(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) setMiningSettings(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetMiningSettingsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetMiningSettings(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) getHashrateHistory(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetHashrateHistoryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetHashrateHistory(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h stratumServiceHandler) listPoolBlocks(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPoolBlocksRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPoolBlocks(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/thunder/v1/thunderv1connect/thunder.connect.go b/sidechain-orchestrator/gen/thunder/v1/thunderv1connect/thunder.connect.go
index 9ac050f48a..0e9ec3de09 100644
--- a/sidechain-orchestrator/gen/thunder/v1/thunderv1connect/thunder.connect.go
+++ b/sidechain-orchestrator/gen/thunder/v1/thunderv1connect/thunder.connect.go
@@ -5,817 +5,935 @@
 package thunderv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/thunder/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ThunderServiceName is the fully-qualified name of the ThunderService service.
 	ThunderServiceName = "thunder.v1.ThunderService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ThunderServiceGetBalanceProcedure is the fully-qualified name of the ThunderService's GetBalance
-	// RPC.
+	// ThunderServiceGetBalanceProcedure is the procedure name of the ThunderService's GetBalance RPC.
 	ThunderServiceGetBalanceProcedure = "/thunder.v1.ThunderService/GetBalance"
-	// ThunderServiceGetBlockCountProcedure is the fully-qualified name of the ThunderService's
-	// GetBlockCount RPC.
+	// ThunderServiceGetBlockCountProcedure is the procedure name of the ThunderService's GetBlockCount
+	// RPC.
 	ThunderServiceGetBlockCountProcedure = "/thunder.v1.ThunderService/GetBlockCount"
-	// ThunderServiceStopProcedure is the fully-qualified name of the ThunderService's Stop RPC.
+	// ThunderServiceStopProcedure is the procedure name of the ThunderService's Stop RPC.
 	ThunderServiceStopProcedure = "/thunder.v1.ThunderService/Stop"
-	// ThunderServiceGetNewAddressProcedure is the fully-qualified name of the ThunderService's
-	// GetNewAddress RPC.
+	// ThunderServiceGetNewAddressProcedure is the procedure name of the ThunderService's GetNewAddress
+	// RPC.
 	ThunderServiceGetNewAddressProcedure = "/thunder.v1.ThunderService/GetNewAddress"
-	// ThunderServiceWithdrawProcedure is the fully-qualified name of the ThunderService's Withdraw RPC.
+	// ThunderServiceWithdrawProcedure is the procedure name of the ThunderService's Withdraw RPC.
 	ThunderServiceWithdrawProcedure = "/thunder.v1.ThunderService/Withdraw"
-	// ThunderServiceTransferProcedure is the fully-qualified name of the ThunderService's Transfer RPC.
+	// ThunderServiceTransferProcedure is the procedure name of the ThunderService's Transfer RPC.
 	ThunderServiceTransferProcedure = "/thunder.v1.ThunderService/Transfer"
-	// ThunderServiceGetSidechainWealthProcedure is the fully-qualified name of the ThunderService's
+	// ThunderServiceGetSidechainWealthProcedure is the procedure name of the ThunderService's
 	// GetSidechainWealth RPC.
 	ThunderServiceGetSidechainWealthProcedure = "/thunder.v1.ThunderService/GetSidechainWealth"
-	// ThunderServiceCreateDepositProcedure is the fully-qualified name of the ThunderService's
-	// CreateDeposit RPC.
+	// ThunderServiceCreateDepositProcedure is the procedure name of the ThunderService's CreateDeposit
+	// RPC.
 	ThunderServiceCreateDepositProcedure = "/thunder.v1.ThunderService/CreateDeposit"
-	// ThunderServiceGetPendingWithdrawalBundleProcedure is the fully-qualified name of the
-	// ThunderService's GetPendingWithdrawalBundle RPC.
+	// ThunderServiceGetPendingWithdrawalBundleProcedure is the procedure name of the ThunderService's
+	// GetPendingWithdrawalBundle RPC.
 	ThunderServiceGetPendingWithdrawalBundleProcedure = "/thunder.v1.ThunderService/GetPendingWithdrawalBundle"
-	// ThunderServiceConnectPeerProcedure is the fully-qualified name of the ThunderService's
-	// ConnectPeer RPC.
+	// ThunderServiceConnectPeerProcedure is the procedure name of the ThunderService's ConnectPeer RPC.
 	ThunderServiceConnectPeerProcedure = "/thunder.v1.ThunderService/ConnectPeer"
-	// ThunderServiceListPeersProcedure is the fully-qualified name of the ThunderService's ListPeers
-	// RPC.
+	// ThunderServiceListPeersProcedure is the procedure name of the ThunderService's ListPeers RPC.
 	ThunderServiceListPeersProcedure = "/thunder.v1.ThunderService/ListPeers"
-	// ThunderServiceMineProcedure is the fully-qualified name of the ThunderService's Mine RPC.
+	// ThunderServiceMineProcedure is the procedure name of the ThunderService's Mine RPC.
 	ThunderServiceMineProcedure = "/thunder.v1.ThunderService/Mine"
-	// ThunderServiceGetBlockProcedure is the fully-qualified name of the ThunderService's GetBlock RPC.
+	// ThunderServiceGetBlockProcedure is the procedure name of the ThunderService's GetBlock RPC.
 	ThunderServiceGetBlockProcedure = "/thunder.v1.ThunderService/GetBlock"
-	// ThunderServiceGetBestMainchainBlockHashProcedure is the fully-qualified name of the
-	// ThunderService's GetBestMainchainBlockHash RPC.
+	// ThunderServiceGetBestMainchainBlockHashProcedure is the procedure name of the ThunderService's
+	// GetBestMainchainBlockHash RPC.
 	ThunderServiceGetBestMainchainBlockHashProcedure = "/thunder.v1.ThunderService/GetBestMainchainBlockHash"
-	// ThunderServiceGetBestSidechainBlockHashProcedure is the fully-qualified name of the
-	// ThunderService's GetBestSidechainBlockHash RPC.
+	// ThunderServiceGetBestSidechainBlockHashProcedure is the procedure name of the ThunderService's
+	// GetBestSidechainBlockHash RPC.
 	ThunderServiceGetBestSidechainBlockHashProcedure = "/thunder.v1.ThunderService/GetBestSidechainBlockHash"
-	// ThunderServiceGetBmmInclusionsProcedure is the fully-qualified name of the ThunderService's
+	// ThunderServiceGetBmmInclusionsProcedure is the procedure name of the ThunderService's
 	// GetBmmInclusions RPC.
 	ThunderServiceGetBmmInclusionsProcedure = "/thunder.v1.ThunderService/GetBmmInclusions"
-	// ThunderServiceGetWalletUtxosProcedure is the fully-qualified name of the ThunderService's
+	// ThunderServiceGetWalletUtxosProcedure is the procedure name of the ThunderService's
 	// GetWalletUtxos RPC.
 	ThunderServiceGetWalletUtxosProcedure = "/thunder.v1.ThunderService/GetWalletUtxos"
-	// ThunderServiceListUtxosProcedure is the fully-qualified name of the ThunderService's ListUtxos
-	// RPC.
+	// ThunderServiceListUtxosProcedure is the procedure name of the ThunderService's ListUtxos RPC.
 	ThunderServiceListUtxosProcedure = "/thunder.v1.ThunderService/ListUtxos"
-	// ThunderServiceRemoveFromMempoolProcedure is the fully-qualified name of the ThunderService's
+	// ThunderServiceRemoveFromMempoolProcedure is the procedure name of the ThunderService's
 	// RemoveFromMempool RPC.
 	ThunderServiceRemoveFromMempoolProcedure = "/thunder.v1.ThunderService/RemoveFromMempool"
-	// ThunderServiceGetLatestFailedWithdrawalBundleHeightProcedure is the fully-qualified name of the
+	// ThunderServiceGetLatestFailedWithdrawalBundleHeightProcedure is the procedure name of the
 	// ThunderService's GetLatestFailedWithdrawalBundleHeight RPC.
 	ThunderServiceGetLatestFailedWithdrawalBundleHeightProcedure = "/thunder.v1.ThunderService/GetLatestFailedWithdrawalBundleHeight"
-	// ThunderServiceGenerateMnemonicProcedure is the fully-qualified name of the ThunderService's
+	// ThunderServiceGenerateMnemonicProcedure is the procedure name of the ThunderService's
 	// GenerateMnemonic RPC.
 	ThunderServiceGenerateMnemonicProcedure = "/thunder.v1.ThunderService/GenerateMnemonic"
-	// ThunderServiceSetSeedFromMnemonicProcedure is the fully-qualified name of the ThunderService's
+	// ThunderServiceSetSeedFromMnemonicProcedure is the procedure name of the ThunderService's
 	// SetSeedFromMnemonic RPC.
 	ThunderServiceSetSeedFromMnemonicProcedure = "/thunder.v1.ThunderService/SetSeedFromMnemonic"
-	// ThunderServiceCallRawProcedure is the fully-qualified name of the ThunderService's CallRaw RPC.
+	// ThunderServiceCallRawProcedure is the procedure name of the ThunderService's CallRaw RPC.
 	ThunderServiceCallRawProcedure = "/thunder.v1.ThunderService/CallRaw"
-	// ThunderServiceListWalletTransactionsProcedure is the fully-qualified name of the ThunderService's
+	// ThunderServiceListWalletTransactionsProcedure is the procedure name of the ThunderService's
 	// ListWalletTransactions RPC.
 	ThunderServiceListWalletTransactionsProcedure = "/thunder.v1.ThunderService/ListWalletTransactions"
 )
 
+var (
+	thunderServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetBalance"),
+			Procedure:  ThunderServiceGetBalanceProcedure,
+		}
+	})
+	thunderServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetBlockCount"),
+			Procedure:  ThunderServiceGetBlockCountProcedure,
+		}
+	})
+	thunderServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("Stop"),
+			Procedure:  ThunderServiceStopProcedure,
+		}
+	})
+	thunderServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetNewAddress"),
+			Procedure:  ThunderServiceGetNewAddressProcedure,
+		}
+	})
+	thunderServiceWithdrawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("Withdraw"),
+			Procedure:  ThunderServiceWithdrawProcedure,
+		}
+	})
+	thunderServiceTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("Transfer"),
+			Procedure:  ThunderServiceTransferProcedure,
+		}
+	})
+	thunderServiceGetSidechainWealthSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetSidechainWealth"),
+			Procedure:  ThunderServiceGetSidechainWealthProcedure,
+		}
+	})
+	thunderServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("CreateDeposit"),
+			Procedure:  ThunderServiceCreateDepositProcedure,
+		}
+	})
+	thunderServiceGetPendingWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetPendingWithdrawalBundle"),
+			Procedure:  ThunderServiceGetPendingWithdrawalBundleProcedure,
+		}
+	})
+	thunderServiceConnectPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("ConnectPeer"),
+			Procedure:  ThunderServiceConnectPeerProcedure,
+		}
+	})
+	thunderServiceListPeersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("ListPeers"),
+			Procedure:  ThunderServiceListPeersProcedure,
+		}
+	})
+	thunderServiceMineSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("Mine"),
+			Procedure:  ThunderServiceMineProcedure,
+		}
+	})
+	thunderServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetBlock"),
+			Procedure:  ThunderServiceGetBlockProcedure,
+		}
+	})
+	thunderServiceGetBestMainchainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetBestMainchainBlockHash"),
+			Procedure:  ThunderServiceGetBestMainchainBlockHashProcedure,
+		}
+	})
+	thunderServiceGetBestSidechainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetBestSidechainBlockHash"),
+			Procedure:  ThunderServiceGetBestSidechainBlockHashProcedure,
+		}
+	})
+	thunderServiceGetBmmInclusionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetBmmInclusions"),
+			Procedure:  ThunderServiceGetBmmInclusionsProcedure,
+		}
+	})
+	thunderServiceGetWalletUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetWalletUtxos"),
+			Procedure:  ThunderServiceGetWalletUtxosProcedure,
+		}
+	})
+	thunderServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("ListUtxos"),
+			Procedure:  ThunderServiceListUtxosProcedure,
+		}
+	})
+	thunderServiceRemoveFromMempoolSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("RemoveFromMempool"),
+			Procedure:  ThunderServiceRemoveFromMempoolProcedure,
+		}
+	})
+	thunderServiceGetLatestFailedWithdrawalBundleHeightSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GetLatestFailedWithdrawalBundleHeight"),
+			Procedure:  ThunderServiceGetLatestFailedWithdrawalBundleHeightProcedure,
+		}
+	})
+	thunderServiceGenerateMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("GenerateMnemonic"),
+			Procedure:  ThunderServiceGenerateMnemonicProcedure,
+		}
+	})
+	thunderServiceSetSeedFromMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("SetSeedFromMnemonic"),
+			Procedure:  ThunderServiceSetSeedFromMnemonicProcedure,
+		}
+	})
+	thunderServiceCallRawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("CallRaw"),
+			Procedure:  ThunderServiceCallRawProcedure,
+		}
+	})
+	thunderServiceListWalletTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods().ByName("ListWalletTransactions"),
+			Procedure:  ThunderServiceListWalletTransactionsProcedure,
+		}
+	})
+)
+
 // ThunderServiceClient is a client for the thunder.v1.ThunderService service.
 type ThunderServiceClient interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the thunder node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Lists the wallet transaction history through the Esplora index. The node
-	// itself keeps no address history.
-	ListWalletTransactions(context.Context, *connect.Request[v1.ListWalletTransactionsRequest]) (*connect.Response[v1.ListWalletTransactionsResponse], error)
-}
-
-// NewThunderServiceClient constructs a client for the thunder.v1.ThunderService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewThunderServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ThunderServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	thunderServiceMethods := v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods()
-	return &thunderServiceClient{
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+ThunderServiceGetBalanceProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+ThunderServiceGetBlockCountProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+ThunderServiceStopProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+ThunderServiceGetNewAddressProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		withdraw: connect.NewClient[v1.WithdrawRequest, v1.WithdrawResponse](
-			httpClient,
-			baseURL+ThunderServiceWithdrawProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("Withdraw")),
-			connect.WithClientOptions(opts...),
-		),
-		transfer: connect.NewClient[v1.TransferRequest, v1.TransferResponse](
-			httpClient,
-			baseURL+ThunderServiceTransferProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("Transfer")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainWealth: connect.NewClient[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse](
-			httpClient,
-			baseURL+ThunderServiceGetSidechainWealthProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetSidechainWealth")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+ThunderServiceCreateDepositProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingWithdrawalBundle: connect.NewClient[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse](
-			httpClient,
-			baseURL+ThunderServiceGetPendingWithdrawalBundleProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetPendingWithdrawalBundle")),
-			connect.WithClientOptions(opts...),
-		),
-		connectPeer: connect.NewClient[v1.ConnectPeerRequest, v1.ConnectPeerResponse](
-			httpClient,
-			baseURL+ThunderServiceConnectPeerProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("ConnectPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		listPeers: connect.NewClient[v1.ListPeersRequest, v1.ListPeersResponse](
-			httpClient,
-			baseURL+ThunderServiceListPeersProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("ListPeers")),
-			connect.WithClientOptions(opts...),
-		),
-		mine: connect.NewClient[v1.MineRequest, v1.MineResponse](
-			httpClient,
-			baseURL+ThunderServiceMineProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("Mine")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+ThunderServiceGetBlockProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestMainchainBlockHash: connect.NewClient[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse](
-			httpClient,
-			baseURL+ThunderServiceGetBestMainchainBlockHashProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetBestMainchainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestSidechainBlockHash: connect.NewClient[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse](
-			httpClient,
-			baseURL+ThunderServiceGetBestSidechainBlockHashProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetBestSidechainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmInclusions: connect.NewClient[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse](
-			httpClient,
-			baseURL+ThunderServiceGetBmmInclusionsProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetBmmInclusions")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletUtxos: connect.NewClient[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse](
-			httpClient,
-			baseURL+ThunderServiceGetWalletUtxosProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetWalletUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+ThunderServiceListUtxosProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		removeFromMempool: connect.NewClient[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse](
-			httpClient,
-			baseURL+ThunderServiceRemoveFromMempoolProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("RemoveFromMempool")),
-			connect.WithClientOptions(opts...),
-		),
-		getLatestFailedWithdrawalBundleHeight: connect.NewClient[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse](
-			httpClient,
-			baseURL+ThunderServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-			connect.WithClientOptions(opts...),
-		),
-		generateMnemonic: connect.NewClient[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse](
-			httpClient,
-			baseURL+ThunderServiceGenerateMnemonicProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("GenerateMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		setSeedFromMnemonic: connect.NewClient[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse](
-			httpClient,
-			baseURL+ThunderServiceSetSeedFromMnemonicProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("SetSeedFromMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		callRaw: connect.NewClient[v1.CallRawRequest, v1.CallRawResponse](
-			httpClient,
-			baseURL+ThunderServiceCallRawProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("CallRaw")),
-			connect.WithClientOptions(opts...),
-		),
-		listWalletTransactions: connect.NewClient[v1.ListWalletTransactionsRequest, v1.ListWalletTransactionsResponse](
-			httpClient,
-			baseURL+ThunderServiceListWalletTransactionsProcedure,
-			connect.WithSchema(thunderServiceMethods.ByName("ListWalletTransactions")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// thunderServiceClient implements ThunderServiceClient.
-type thunderServiceClient struct {
-	getBalance                            *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getBlockCount                         *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	stop                                  *connect.Client[v1.StopRequest, v1.StopResponse]
-	getNewAddress                         *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	withdraw                              *connect.Client[v1.WithdrawRequest, v1.WithdrawResponse]
-	transfer                              *connect.Client[v1.TransferRequest, v1.TransferResponse]
-	getSidechainWealth                    *connect.Client[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse]
-	createDeposit                         *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	getPendingWithdrawalBundle            *connect.Client[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse]
-	connectPeer                           *connect.Client[v1.ConnectPeerRequest, v1.ConnectPeerResponse]
-	listPeers                             *connect.Client[v1.ListPeersRequest, v1.ListPeersResponse]
-	mine                                  *connect.Client[v1.MineRequest, v1.MineResponse]
-	getBlock                              *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	getBestMainchainBlockHash             *connect.Client[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse]
-	getBestSidechainBlockHash             *connect.Client[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse]
-	getBmmInclusions                      *connect.Client[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse]
-	getWalletUtxos                        *connect.Client[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse]
-	listUtxos                             *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	removeFromMempool                     *connect.Client[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse]
-	getLatestFailedWithdrawalBundleHeight *connect.Client[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse]
-	generateMnemonic                      *connect.Client[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse]
-	setSeedFromMnemonic                   *connect.Client[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse]
-	callRaw                               *connect.Client[v1.CallRawRequest, v1.CallRawResponse]
-	listWalletTransactions                *connect.Client[v1.ListWalletTransactionsRequest, v1.ListWalletTransactionsResponse]
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	ListWalletTransactions(context.Context, *v1.ListWalletTransactionsRequest) (*v1.ListWalletTransactionsResponse, error)
+}
+
+// NewThunderServiceClient constructs a client for the thunder.v1.ThunderService service. Multiple
+// service clients may share a single connect.Client.
+func NewThunderServiceClient(client *connect.Client) ThunderServiceClient {
+	return &thunderServiceClient{client: client}
 }
 
-// GetBalance calls thunder.v1.ThunderService.GetBalance.
-func (c *thunderServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// ThunderServiceHandler is an implementation of the thunder.v1.ThunderService service.
+type ThunderServiceHandler interface {
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	ListWalletTransactions(context.Context, *v1.ListWalletTransactionsRequest) (*v1.ListWalletTransactionsResponse, error)
+}
+
+// RegisterThunderServiceHandler registers svc as the thunder.v1.ThunderService implementation on
+// server.
+func RegisterThunderServiceHandler(server *connect.Server, svc ThunderServiceHandler) {
+	adapter := thunderServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: thunderServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: thunderServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: thunderServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: thunderServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: thunderServiceWithdrawSpec(), Handler: adapter.withdraw},
+		connect.Method{Spec: thunderServiceTransferSpec(), Handler: adapter.transfer},
+		connect.Method{Spec: thunderServiceGetSidechainWealthSpec(), Handler: adapter.getSidechainWealth},
+		connect.Method{Spec: thunderServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: thunderServiceGetPendingWithdrawalBundleSpec(), Handler: adapter.getPendingWithdrawalBundle},
+		connect.Method{Spec: thunderServiceConnectPeerSpec(), Handler: adapter.connectPeer},
+		connect.Method{Spec: thunderServiceListPeersSpec(), Handler: adapter.listPeers},
+		connect.Method{Spec: thunderServiceMineSpec(), Handler: adapter.mine},
+		connect.Method{Spec: thunderServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: thunderServiceGetBestMainchainBlockHashSpec(), Handler: adapter.getBestMainchainBlockHash},
+		connect.Method{Spec: thunderServiceGetBestSidechainBlockHashSpec(), Handler: adapter.getBestSidechainBlockHash},
+		connect.Method{Spec: thunderServiceGetBmmInclusionsSpec(), Handler: adapter.getBmmInclusions},
+		connect.Method{Spec: thunderServiceGetWalletUtxosSpec(), Handler: adapter.getWalletUtxos},
+		connect.Method{Spec: thunderServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: thunderServiceRemoveFromMempoolSpec(), Handler: adapter.removeFromMempool},
+		connect.Method{Spec: thunderServiceGetLatestFailedWithdrawalBundleHeightSpec(), Handler: adapter.getLatestFailedWithdrawalBundleHeight},
+		connect.Method{Spec: thunderServiceGenerateMnemonicSpec(), Handler: adapter.generateMnemonic},
+		connect.Method{Spec: thunderServiceSetSeedFromMnemonicSpec(), Handler: adapter.setSeedFromMnemonic},
+		connect.Method{Spec: thunderServiceCallRawSpec(), Handler: adapter.callRaw},
+		connect.Method{Spec: thunderServiceListWalletTransactionsSpec(), Handler: adapter.listWalletTransactions},
+	)
 }
 
-// GetBlockCount calls thunder.v1.ThunderService.GetBlockCount.
-func (c *thunderServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// UnimplementedThunderServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedThunderServiceHandler struct{}
+
+func (UnimplementedThunderServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetBalance is not implemented")
 }
 
-// Stop calls thunder.v1.ThunderService.Stop.
-func (c *thunderServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetBlockCount is not implemented")
 }
 
-// GetNewAddress calls thunder.v1.ThunderService.GetNewAddress.
-func (c *thunderServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.Stop is not implemented")
 }
 
-// Withdraw calls thunder.v1.ThunderService.Withdraw.
-func (c *thunderServiceClient) Withdraw(ctx context.Context, req *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return c.withdraw.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetNewAddress is not implemented")
 }
 
-// Transfer calls thunder.v1.ThunderService.Transfer.
-func (c *thunderServiceClient) Transfer(ctx context.Context, req *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return c.transfer.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.Withdraw is not implemented")
 }
 
-// GetSidechainWealth calls thunder.v1.ThunderService.GetSidechainWealth.
-func (c *thunderServiceClient) GetSidechainWealth(ctx context.Context, req *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return c.getSidechainWealth.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.Transfer is not implemented")
 }
 
-// CreateDeposit calls thunder.v1.ThunderService.CreateDeposit.
-func (c *thunderServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetSidechainWealth is not implemented")
 }
 
-// GetPendingWithdrawalBundle calls thunder.v1.ThunderService.GetPendingWithdrawalBundle.
-func (c *thunderServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return c.getPendingWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.CreateDeposit is not implemented")
 }
 
-// ConnectPeer calls thunder.v1.ThunderService.ConnectPeer.
-func (c *thunderServiceClient) ConnectPeer(ctx context.Context, req *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return c.connectPeer.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetPendingWithdrawalBundle is not implemented")
 }
 
-// ListPeers calls thunder.v1.ThunderService.ListPeers.
-func (c *thunderServiceClient) ListPeers(ctx context.Context, req *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return c.listPeers.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.ConnectPeer is not implemented")
 }
 
-// Mine calls thunder.v1.ThunderService.Mine.
-func (c *thunderServiceClient) Mine(ctx context.Context, req *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return c.mine.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.ListPeers is not implemented")
 }
 
-// GetBlock calls thunder.v1.ThunderService.GetBlock.
-func (c *thunderServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.Mine is not implemented")
 }
 
-// GetBestMainchainBlockHash calls thunder.v1.ThunderService.GetBestMainchainBlockHash.
-func (c *thunderServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return c.getBestMainchainBlockHash.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetBlock is not implemented")
 }
 
-// GetBestSidechainBlockHash calls thunder.v1.ThunderService.GetBestSidechainBlockHash.
-func (c *thunderServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return c.getBestSidechainBlockHash.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetBestMainchainBlockHash is not implemented")
 }
 
-// GetBmmInclusions calls thunder.v1.ThunderService.GetBmmInclusions.
-func (c *thunderServiceClient) GetBmmInclusions(ctx context.Context, req *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return c.getBmmInclusions.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetBestSidechainBlockHash is not implemented")
 }
 
-// GetWalletUtxos calls thunder.v1.ThunderService.GetWalletUtxos.
-func (c *thunderServiceClient) GetWalletUtxos(ctx context.Context, req *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return c.getWalletUtxos.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetBmmInclusions is not implemented")
 }
 
-// ListUtxos calls thunder.v1.ThunderService.ListUtxos.
-func (c *thunderServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetWalletUtxos is not implemented")
 }
 
-// RemoveFromMempool calls thunder.v1.ThunderService.RemoveFromMempool.
-func (c *thunderServiceClient) RemoveFromMempool(ctx context.Context, req *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return c.removeFromMempool.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.ListUtxos is not implemented")
 }
 
-// GetLatestFailedWithdrawalBundleHeight calls
-// thunder.v1.ThunderService.GetLatestFailedWithdrawalBundleHeight.
-func (c *thunderServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return c.getLatestFailedWithdrawalBundleHeight.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.RemoveFromMempool is not implemented")
 }
 
-// GenerateMnemonic calls thunder.v1.ThunderService.GenerateMnemonic.
-func (c *thunderServiceClient) GenerateMnemonic(ctx context.Context, req *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return c.generateMnemonic.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GetLatestFailedWithdrawalBundleHeight is not implemented")
 }
 
-// SetSeedFromMnemonic calls thunder.v1.ThunderService.SetSeedFromMnemonic.
-func (c *thunderServiceClient) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return c.setSeedFromMnemonic.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.GenerateMnemonic is not implemented")
 }
 
-// CallRaw calls thunder.v1.ThunderService.CallRaw.
-func (c *thunderServiceClient) CallRaw(ctx context.Context, req *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return c.callRaw.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.SetSeedFromMnemonic is not implemented")
 }
 
-// ListWalletTransactions calls thunder.v1.ThunderService.ListWalletTransactions.
-func (c *thunderServiceClient) ListWalletTransactions(ctx context.Context, req *connect.Request[v1.ListWalletTransactionsRequest]) (*connect.Response[v1.ListWalletTransactionsResponse], error) {
-	return c.listWalletTransactions.CallUnary(ctx, req)
+func (UnimplementedThunderServiceHandler) CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.CallRaw is not implemented")
 }
 
-// ThunderServiceHandler is an implementation of the thunder.v1.ThunderService service.
-type ThunderServiceHandler interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the thunder node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Lists the wallet transaction history through the Esplora index. The node
-	// itself keeps no address history.
-	ListWalletTransactions(context.Context, *connect.Request[v1.ListWalletTransactionsRequest]) (*connect.Response[v1.ListWalletTransactionsResponse], error)
-}
-
-// NewThunderServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewThunderServiceHandler(svc ThunderServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	thunderServiceMethods := v1.File_thunder_v1_thunder_proto.Services().ByName("ThunderService").Methods()
-	thunderServiceGetBalanceHandler := connect.NewUnaryHandler(
-		ThunderServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(thunderServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		ThunderServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(thunderServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceStopHandler := connect.NewUnaryHandler(
-		ThunderServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(thunderServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		ThunderServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(thunderServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceWithdrawHandler := connect.NewUnaryHandler(
-		ThunderServiceWithdrawProcedure,
-		svc.Withdraw,
-		connect.WithSchema(thunderServiceMethods.ByName("Withdraw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceTransferHandler := connect.NewUnaryHandler(
-		ThunderServiceTransferProcedure,
-		svc.Transfer,
-		connect.WithSchema(thunderServiceMethods.ByName("Transfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetSidechainWealthHandler := connect.NewUnaryHandler(
-		ThunderServiceGetSidechainWealthProcedure,
-		svc.GetSidechainWealth,
-		connect.WithSchema(thunderServiceMethods.ByName("GetSidechainWealth")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceCreateDepositHandler := connect.NewUnaryHandler(
-		ThunderServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(thunderServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetPendingWithdrawalBundleHandler := connect.NewUnaryHandler(
-		ThunderServiceGetPendingWithdrawalBundleProcedure,
-		svc.GetPendingWithdrawalBundle,
-		connect.WithSchema(thunderServiceMethods.ByName("GetPendingWithdrawalBundle")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceConnectPeerHandler := connect.NewUnaryHandler(
-		ThunderServiceConnectPeerProcedure,
-		svc.ConnectPeer,
-		connect.WithSchema(thunderServiceMethods.ByName("ConnectPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceListPeersHandler := connect.NewUnaryHandler(
-		ThunderServiceListPeersProcedure,
-		svc.ListPeers,
-		connect.WithSchema(thunderServiceMethods.ByName("ListPeers")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceMineHandler := connect.NewUnaryHandler(
-		ThunderServiceMineProcedure,
-		svc.Mine,
-		connect.WithSchema(thunderServiceMethods.ByName("Mine")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetBlockHandler := connect.NewUnaryHandler(
-		ThunderServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(thunderServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetBestMainchainBlockHashHandler := connect.NewUnaryHandler(
-		ThunderServiceGetBestMainchainBlockHashProcedure,
-		svc.GetBestMainchainBlockHash,
-		connect.WithSchema(thunderServiceMethods.ByName("GetBestMainchainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetBestSidechainBlockHashHandler := connect.NewUnaryHandler(
-		ThunderServiceGetBestSidechainBlockHashProcedure,
-		svc.GetBestSidechainBlockHash,
-		connect.WithSchema(thunderServiceMethods.ByName("GetBestSidechainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetBmmInclusionsHandler := connect.NewUnaryHandler(
-		ThunderServiceGetBmmInclusionsProcedure,
-		svc.GetBmmInclusions,
-		connect.WithSchema(thunderServiceMethods.ByName("GetBmmInclusions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetWalletUtxosHandler := connect.NewUnaryHandler(
-		ThunderServiceGetWalletUtxosProcedure,
-		svc.GetWalletUtxos,
-		connect.WithSchema(thunderServiceMethods.ByName("GetWalletUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceListUtxosHandler := connect.NewUnaryHandler(
-		ThunderServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(thunderServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceRemoveFromMempoolHandler := connect.NewUnaryHandler(
-		ThunderServiceRemoveFromMempoolProcedure,
-		svc.RemoveFromMempool,
-		connect.WithSchema(thunderServiceMethods.ByName("RemoveFromMempool")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGetLatestFailedWithdrawalBundleHeightHandler := connect.NewUnaryHandler(
-		ThunderServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-		svc.GetLatestFailedWithdrawalBundleHeight,
-		connect.WithSchema(thunderServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceGenerateMnemonicHandler := connect.NewUnaryHandler(
-		ThunderServiceGenerateMnemonicProcedure,
-		svc.GenerateMnemonic,
-		connect.WithSchema(thunderServiceMethods.ByName("GenerateMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceSetSeedFromMnemonicHandler := connect.NewUnaryHandler(
-		ThunderServiceSetSeedFromMnemonicProcedure,
-		svc.SetSeedFromMnemonic,
-		connect.WithSchema(thunderServiceMethods.ByName("SetSeedFromMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceCallRawHandler := connect.NewUnaryHandler(
-		ThunderServiceCallRawProcedure,
-		svc.CallRaw,
-		connect.WithSchema(thunderServiceMethods.ByName("CallRaw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	thunderServiceListWalletTransactionsHandler := connect.NewUnaryHandler(
-		ThunderServiceListWalletTransactionsProcedure,
-		svc.ListWalletTransactions,
-		connect.WithSchema(thunderServiceMethods.ByName("ListWalletTransactions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/thunder.v1.ThunderService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ThunderServiceGetBalanceProcedure:
-			thunderServiceGetBalanceHandler.ServeHTTP(w, r)
-		case ThunderServiceGetBlockCountProcedure:
-			thunderServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case ThunderServiceStopProcedure:
-			thunderServiceStopHandler.ServeHTTP(w, r)
-		case ThunderServiceGetNewAddressProcedure:
-			thunderServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case ThunderServiceWithdrawProcedure:
-			thunderServiceWithdrawHandler.ServeHTTP(w, r)
-		case ThunderServiceTransferProcedure:
-			thunderServiceTransferHandler.ServeHTTP(w, r)
-		case ThunderServiceGetSidechainWealthProcedure:
-			thunderServiceGetSidechainWealthHandler.ServeHTTP(w, r)
-		case ThunderServiceCreateDepositProcedure:
-			thunderServiceCreateDepositHandler.ServeHTTP(w, r)
-		case ThunderServiceGetPendingWithdrawalBundleProcedure:
-			thunderServiceGetPendingWithdrawalBundleHandler.ServeHTTP(w, r)
-		case ThunderServiceConnectPeerProcedure:
-			thunderServiceConnectPeerHandler.ServeHTTP(w, r)
-		case ThunderServiceListPeersProcedure:
-			thunderServiceListPeersHandler.ServeHTTP(w, r)
-		case ThunderServiceMineProcedure:
-			thunderServiceMineHandler.ServeHTTP(w, r)
-		case ThunderServiceGetBlockProcedure:
-			thunderServiceGetBlockHandler.ServeHTTP(w, r)
-		case ThunderServiceGetBestMainchainBlockHashProcedure:
-			thunderServiceGetBestMainchainBlockHashHandler.ServeHTTP(w, r)
-		case ThunderServiceGetBestSidechainBlockHashProcedure:
-			thunderServiceGetBestSidechainBlockHashHandler.ServeHTTP(w, r)
-		case ThunderServiceGetBmmInclusionsProcedure:
-			thunderServiceGetBmmInclusionsHandler.ServeHTTP(w, r)
-		case ThunderServiceGetWalletUtxosProcedure:
-			thunderServiceGetWalletUtxosHandler.ServeHTTP(w, r)
-		case ThunderServiceListUtxosProcedure:
-			thunderServiceListUtxosHandler.ServeHTTP(w, r)
-		case ThunderServiceRemoveFromMempoolProcedure:
-			thunderServiceRemoveFromMempoolHandler.ServeHTTP(w, r)
-		case ThunderServiceGetLatestFailedWithdrawalBundleHeightProcedure:
-			thunderServiceGetLatestFailedWithdrawalBundleHeightHandler.ServeHTTP(w, r)
-		case ThunderServiceGenerateMnemonicProcedure:
-			thunderServiceGenerateMnemonicHandler.ServeHTTP(w, r)
-		case ThunderServiceSetSeedFromMnemonicProcedure:
-			thunderServiceSetSeedFromMnemonicHandler.ServeHTTP(w, r)
-		case ThunderServiceCallRawProcedure:
-			thunderServiceCallRawHandler.ServeHTTP(w, r)
-		case ThunderServiceListWalletTransactionsProcedure:
-			thunderServiceListWalletTransactionsHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedThunderServiceHandler) ListWalletTransactions(context.Context, *v1.ListWalletTransactionsRequest) (*v1.ListWalletTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "thunder.v1.ThunderService.ListWalletTransactions is not implemented")
 }
 
-// UnimplementedThunderServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedThunderServiceHandler struct{}
+type thunderServiceClient struct {
+	client *connect.Client
+}
 
-func (UnimplementedThunderServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetBalance is not implemented"))
+func (c *thunderServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetBlockCount is not implemented"))
+func (c *thunderServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.Stop is not implemented"))
+func (c *thunderServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, thunderServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetNewAddress is not implemented"))
+func (c *thunderServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.Withdraw is not implemented"))
+func (c *thunderServiceClient) Withdraw(ctx context.Context, req *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	var res v1.WithdrawResponse
+	if err := c.client.CallUnary(ctx, thunderServiceWithdrawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.Transfer is not implemented"))
+func (c *thunderServiceClient) Transfer(ctx context.Context, req *v1.TransferRequest) (*v1.TransferResponse, error) {
+	var res v1.TransferResponse
+	if err := c.client.CallUnary(ctx, thunderServiceTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetSidechainWealth is not implemented"))
+func (c *thunderServiceClient) GetSidechainWealth(ctx context.Context, req *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	var res v1.GetSidechainWealthResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetSidechainWealthSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.CreateDeposit is not implemented"))
+func (c *thunderServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, thunderServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetPendingWithdrawalBundle is not implemented"))
+func (c *thunderServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	var res v1.GetPendingWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetPendingWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.ConnectPeer is not implemented"))
+func (c *thunderServiceClient) ConnectPeer(ctx context.Context, req *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	var res v1.ConnectPeerResponse
+	if err := c.client.CallUnary(ctx, thunderServiceConnectPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.ListPeers is not implemented"))
+func (c *thunderServiceClient) ListPeers(ctx context.Context, req *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	var res v1.ListPeersResponse
+	if err := c.client.CallUnary(ctx, thunderServiceListPeersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.Mine is not implemented"))
+func (c *thunderServiceClient) Mine(ctx context.Context, req *v1.MineRequest) (*v1.MineResponse, error) {
+	var res v1.MineResponse
+	if err := c.client.CallUnary(ctx, thunderServiceMineSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetBlock is not implemented"))
+func (c *thunderServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *thunderServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	var res v1.GetBestMainchainBlockHashResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetBestMainchainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *thunderServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	var res v1.GetBestSidechainBlockHashResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetBestSidechainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetBestMainchainBlockHash is not implemented"))
+func (c *thunderServiceClient) GetBmmInclusions(ctx context.Context, req *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	var res v1.GetBmmInclusionsResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetBmmInclusionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *thunderServiceClient) GetWalletUtxos(ctx context.Context, req *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	var res v1.GetWalletUtxosResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetWalletUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *thunderServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, thunderServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetBestSidechainBlockHash is not implemented"))
+func (c *thunderServiceClient) RemoveFromMempool(ctx context.Context, req *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	var res v1.RemoveFromMempoolResponse
+	if err := c.client.CallUnary(ctx, thunderServiceRemoveFromMempoolSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetBmmInclusions is not implemented"))
+func (c *thunderServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	var res v1.GetLatestFailedWithdrawalBundleHeightResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGetLatestFailedWithdrawalBundleHeightSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetWalletUtxos is not implemented"))
+func (c *thunderServiceClient) GenerateMnemonic(ctx context.Context, req *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	var res v1.GenerateMnemonicResponse
+	if err := c.client.CallUnary(ctx, thunderServiceGenerateMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.ListUtxos is not implemented"))
+func (c *thunderServiceClient) SetSeedFromMnemonic(ctx context.Context, req *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	var res v1.SetSeedFromMnemonicResponse
+	if err := c.client.CallUnary(ctx, thunderServiceSetSeedFromMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.RemoveFromMempool is not implemented"))
+func (c *thunderServiceClient) CallRaw(ctx context.Context, req *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	var res v1.CallRawResponse
+	if err := c.client.CallUnary(ctx, thunderServiceCallRawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GetLatestFailedWithdrawalBundleHeight is not implemented"))
+func (c *thunderServiceClient) ListWalletTransactions(ctx context.Context, req *v1.ListWalletTransactionsRequest) (*v1.ListWalletTransactionsResponse, error) {
+	var res v1.ListWalletTransactionsResponse
+	if err := c.client.CallUnary(ctx, thunderServiceListWalletTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedThunderServiceHandler) GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.GenerateMnemonic is not implemented"))
+type thunderServiceHandler struct{ svc ThunderServiceHandler }
+
+func (h thunderServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedThunderServiceHandler) SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.SetSeedFromMnemonic is not implemented"))
+func (h thunderServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedThunderServiceHandler) CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.CallRaw is not implemented"))
+func (h thunderServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) withdraw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WithdrawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Withdraw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) transfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Transfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getSidechainWealth(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainWealthRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainWealth(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getPendingWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) connectPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedThunderServiceHandler) ListWalletTransactions(context.Context, *connect.Request[v1.ListWalletTransactionsRequest]) (*connect.Response[v1.ListWalletTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("thunder.v1.ThunderService.ListWalletTransactions is not implemented"))
+func (h thunderServiceHandler) listPeers(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPeersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPeers(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) mine(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MineRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Mine(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getBestMainchainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestMainchainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestMainchainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getBestSidechainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestSidechainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestSidechainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getBmmInclusions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmInclusionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmInclusions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getWalletUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) removeFromMempool(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RemoveFromMempoolRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RemoveFromMempool(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) getLatestFailedWithdrawalBundleHeight(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetLatestFailedWithdrawalBundleHeightRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetLatestFailedWithdrawalBundleHeight(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) generateMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) setSeedFromMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSeedFromMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSeedFromMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) callRaw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CallRawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CallRaw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h thunderServiceHandler) listWalletTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListWalletTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListWalletTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/truthcoin/v1/truthcoinv1connect/truthcoin.connect.go b/sidechain-orchestrator/gen/truthcoin/v1/truthcoinv1connect/truthcoin.connect.go
index 2897e26a38..33c2172507 100644
--- a/sidechain-orchestrator/gen/truthcoin/v1/truthcoinv1connect/truthcoin.connect.go
+++ b/sidechain-orchestrator/gen/truthcoin/v1/truthcoinv1connect/truthcoin.connect.go
@@ -5,1873 +5,2187 @@
 package truthcoinv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/truthcoin/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// TruthcoinServiceName is the fully-qualified name of the TruthcoinService service.
 	TruthcoinServiceName = "truthcoin.v1.TruthcoinService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// TruthcoinServiceGetBalanceProcedure is the fully-qualified name of the TruthcoinService's
-	// GetBalance RPC.
+	// TruthcoinServiceGetBalanceProcedure is the procedure name of the TruthcoinService's GetBalance
+	// RPC.
 	TruthcoinServiceGetBalanceProcedure = "/truthcoin.v1.TruthcoinService/GetBalance"
-	// TruthcoinServiceGetBlockCountProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetBlockCountProcedure is the procedure name of the TruthcoinService's
 	// GetBlockCount RPC.
 	TruthcoinServiceGetBlockCountProcedure = "/truthcoin.v1.TruthcoinService/GetBlockCount"
-	// TruthcoinServiceStopProcedure is the fully-qualified name of the TruthcoinService's Stop RPC.
+	// TruthcoinServiceStopProcedure is the procedure name of the TruthcoinService's Stop RPC.
 	TruthcoinServiceStopProcedure = "/truthcoin.v1.TruthcoinService/Stop"
-	// TruthcoinServiceGetNewAddressProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetNewAddressProcedure is the procedure name of the TruthcoinService's
 	// GetNewAddress RPC.
 	TruthcoinServiceGetNewAddressProcedure = "/truthcoin.v1.TruthcoinService/GetNewAddress"
-	// TruthcoinServiceWithdrawProcedure is the fully-qualified name of the TruthcoinService's Withdraw
-	// RPC.
+	// TruthcoinServiceWithdrawProcedure is the procedure name of the TruthcoinService's Withdraw RPC.
 	TruthcoinServiceWithdrawProcedure = "/truthcoin.v1.TruthcoinService/Withdraw"
-	// TruthcoinServiceTransferProcedure is the fully-qualified name of the TruthcoinService's Transfer
-	// RPC.
+	// TruthcoinServiceTransferProcedure is the procedure name of the TruthcoinService's Transfer RPC.
 	TruthcoinServiceTransferProcedure = "/truthcoin.v1.TruthcoinService/Transfer"
-	// TruthcoinServiceGetSidechainWealthProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetSidechainWealthProcedure is the procedure name of the TruthcoinService's
 	// GetSidechainWealth RPC.
 	TruthcoinServiceGetSidechainWealthProcedure = "/truthcoin.v1.TruthcoinService/GetSidechainWealth"
-	// TruthcoinServiceCreateDepositProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceCreateDepositProcedure is the procedure name of the TruthcoinService's
 	// CreateDeposit RPC.
 	TruthcoinServiceCreateDepositProcedure = "/truthcoin.v1.TruthcoinService/CreateDeposit"
-	// TruthcoinServiceGetPendingWithdrawalBundleProcedure is the fully-qualified name of the
+	// TruthcoinServiceGetPendingWithdrawalBundleProcedure is the procedure name of the
 	// TruthcoinService's GetPendingWithdrawalBundle RPC.
 	TruthcoinServiceGetPendingWithdrawalBundleProcedure = "/truthcoin.v1.TruthcoinService/GetPendingWithdrawalBundle"
-	// TruthcoinServiceConnectPeerProcedure is the fully-qualified name of the TruthcoinService's
-	// ConnectPeer RPC.
+	// TruthcoinServiceConnectPeerProcedure is the procedure name of the TruthcoinService's ConnectPeer
+	// RPC.
 	TruthcoinServiceConnectPeerProcedure = "/truthcoin.v1.TruthcoinService/ConnectPeer"
-	// TruthcoinServiceListPeersProcedure is the fully-qualified name of the TruthcoinService's
-	// ListPeers RPC.
+	// TruthcoinServiceListPeersProcedure is the procedure name of the TruthcoinService's ListPeers RPC.
 	TruthcoinServiceListPeersProcedure = "/truthcoin.v1.TruthcoinService/ListPeers"
-	// TruthcoinServiceMineProcedure is the fully-qualified name of the TruthcoinService's Mine RPC.
+	// TruthcoinServiceMineProcedure is the procedure name of the TruthcoinService's Mine RPC.
 	TruthcoinServiceMineProcedure = "/truthcoin.v1.TruthcoinService/Mine"
-	// TruthcoinServiceGetBlockProcedure is the fully-qualified name of the TruthcoinService's GetBlock
-	// RPC.
+	// TruthcoinServiceGetBlockProcedure is the procedure name of the TruthcoinService's GetBlock RPC.
 	TruthcoinServiceGetBlockProcedure = "/truthcoin.v1.TruthcoinService/GetBlock"
-	// TruthcoinServiceGetBestMainchainBlockHashProcedure is the fully-qualified name of the
+	// TruthcoinServiceGetBestMainchainBlockHashProcedure is the procedure name of the
 	// TruthcoinService's GetBestMainchainBlockHash RPC.
 	TruthcoinServiceGetBestMainchainBlockHashProcedure = "/truthcoin.v1.TruthcoinService/GetBestMainchainBlockHash"
-	// TruthcoinServiceGetBestSidechainBlockHashProcedure is the fully-qualified name of the
+	// TruthcoinServiceGetBestSidechainBlockHashProcedure is the procedure name of the
 	// TruthcoinService's GetBestSidechainBlockHash RPC.
 	TruthcoinServiceGetBestSidechainBlockHashProcedure = "/truthcoin.v1.TruthcoinService/GetBestSidechainBlockHash"
-	// TruthcoinServiceGetBmmInclusionsProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetBmmInclusionsProcedure is the procedure name of the TruthcoinService's
 	// GetBmmInclusions RPC.
 	TruthcoinServiceGetBmmInclusionsProcedure = "/truthcoin.v1.TruthcoinService/GetBmmInclusions"
-	// TruthcoinServiceGetWalletUtxosProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetWalletUtxosProcedure is the procedure name of the TruthcoinService's
 	// GetWalletUtxos RPC.
 	TruthcoinServiceGetWalletUtxosProcedure = "/truthcoin.v1.TruthcoinService/GetWalletUtxos"
-	// TruthcoinServiceListUtxosProcedure is the fully-qualified name of the TruthcoinService's
-	// ListUtxos RPC.
+	// TruthcoinServiceListUtxosProcedure is the procedure name of the TruthcoinService's ListUtxos RPC.
 	TruthcoinServiceListUtxosProcedure = "/truthcoin.v1.TruthcoinService/ListUtxos"
-	// TruthcoinServiceRemoveFromMempoolProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceRemoveFromMempoolProcedure is the procedure name of the TruthcoinService's
 	// RemoveFromMempool RPC.
 	TruthcoinServiceRemoveFromMempoolProcedure = "/truthcoin.v1.TruthcoinService/RemoveFromMempool"
-	// TruthcoinServiceGetLatestFailedWithdrawalBundleHeightProcedure is the fully-qualified name of the
+	// TruthcoinServiceGetLatestFailedWithdrawalBundleHeightProcedure is the procedure name of the
 	// TruthcoinService's GetLatestFailedWithdrawalBundleHeight RPC.
 	TruthcoinServiceGetLatestFailedWithdrawalBundleHeightProcedure = "/truthcoin.v1.TruthcoinService/GetLatestFailedWithdrawalBundleHeight"
-	// TruthcoinServiceGenerateMnemonicProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGenerateMnemonicProcedure is the procedure name of the TruthcoinService's
 	// GenerateMnemonic RPC.
 	TruthcoinServiceGenerateMnemonicProcedure = "/truthcoin.v1.TruthcoinService/GenerateMnemonic"
-	// TruthcoinServiceSetSeedFromMnemonicProcedure is the fully-qualified name of the
-	// TruthcoinService's SetSeedFromMnemonic RPC.
+	// TruthcoinServiceSetSeedFromMnemonicProcedure is the procedure name of the TruthcoinService's
+	// SetSeedFromMnemonic RPC.
 	TruthcoinServiceSetSeedFromMnemonicProcedure = "/truthcoin.v1.TruthcoinService/SetSeedFromMnemonic"
-	// TruthcoinServiceCallRawProcedure is the fully-qualified name of the TruthcoinService's CallRaw
-	// RPC.
+	// TruthcoinServiceCallRawProcedure is the procedure name of the TruthcoinService's CallRaw RPC.
 	TruthcoinServiceCallRawProcedure = "/truthcoin.v1.TruthcoinService/CallRaw"
-	// TruthcoinServiceRefreshWalletProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceRefreshWalletProcedure is the procedure name of the TruthcoinService's
 	// RefreshWallet RPC.
 	TruthcoinServiceRefreshWalletProcedure = "/truthcoin.v1.TruthcoinService/RefreshWallet"
-	// TruthcoinServiceGetTransactionProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetTransactionProcedure is the procedure name of the TruthcoinService's
 	// GetTransaction RPC.
 	TruthcoinServiceGetTransactionProcedure = "/truthcoin.v1.TruthcoinService/GetTransaction"
-	// TruthcoinServiceGetTransactionInfoProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetTransactionInfoProcedure is the procedure name of the TruthcoinService's
 	// GetTransactionInfo RPC.
 	TruthcoinServiceGetTransactionInfoProcedure = "/truthcoin.v1.TruthcoinService/GetTransactionInfo"
-	// TruthcoinServiceGetWalletAddressesProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetWalletAddressesProcedure is the procedure name of the TruthcoinService's
 	// GetWalletAddresses RPC.
 	TruthcoinServiceGetWalletAddressesProcedure = "/truthcoin.v1.TruthcoinService/GetWalletAddresses"
-	// TruthcoinServiceMyUtxosProcedure is the fully-qualified name of the TruthcoinService's MyUtxos
-	// RPC.
+	// TruthcoinServiceMyUtxosProcedure is the procedure name of the TruthcoinService's MyUtxos RPC.
 	TruthcoinServiceMyUtxosProcedure = "/truthcoin.v1.TruthcoinService/MyUtxos"
-	// TruthcoinServiceMyUnconfirmedUtxosProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceMyUnconfirmedUtxosProcedure is the procedure name of the TruthcoinService's
 	// MyUnconfirmedUtxos RPC.
 	TruthcoinServiceMyUnconfirmedUtxosProcedure = "/truthcoin.v1.TruthcoinService/MyUnconfirmedUtxos"
-	// TruthcoinServiceCalculateInitialLiquidityProcedure is the fully-qualified name of the
+	// TruthcoinServiceCalculateInitialLiquidityProcedure is the procedure name of the
 	// TruthcoinService's CalculateInitialLiquidity RPC.
 	TruthcoinServiceCalculateInitialLiquidityProcedure = "/truthcoin.v1.TruthcoinService/CalculateInitialLiquidity"
-	// TruthcoinServiceMarketCreateProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceMarketCreateProcedure is the procedure name of the TruthcoinService's
 	// MarketCreate RPC.
 	TruthcoinServiceMarketCreateProcedure = "/truthcoin.v1.TruthcoinService/MarketCreate"
-	// TruthcoinServiceMarketListProcedure is the fully-qualified name of the TruthcoinService's
-	// MarketList RPC.
+	// TruthcoinServiceMarketListProcedure is the procedure name of the TruthcoinService's MarketList
+	// RPC.
 	TruthcoinServiceMarketListProcedure = "/truthcoin.v1.TruthcoinService/MarketList"
-	// TruthcoinServiceMarketGetProcedure is the fully-qualified name of the TruthcoinService's
-	// MarketGet RPC.
+	// TruthcoinServiceMarketGetProcedure is the procedure name of the TruthcoinService's MarketGet RPC.
 	TruthcoinServiceMarketGetProcedure = "/truthcoin.v1.TruthcoinService/MarketGet"
-	// TruthcoinServiceMarketBuyProcedure is the fully-qualified name of the TruthcoinService's
-	// MarketBuy RPC.
+	// TruthcoinServiceMarketBuyProcedure is the procedure name of the TruthcoinService's MarketBuy RPC.
 	TruthcoinServiceMarketBuyProcedure = "/truthcoin.v1.TruthcoinService/MarketBuy"
-	// TruthcoinServiceMarketSellProcedure is the fully-qualified name of the TruthcoinService's
-	// MarketSell RPC.
+	// TruthcoinServiceMarketSellProcedure is the procedure name of the TruthcoinService's MarketSell
+	// RPC.
 	TruthcoinServiceMarketSellProcedure = "/truthcoin.v1.TruthcoinService/MarketSell"
-	// TruthcoinServiceMarketPositionsProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceMarketPositionsProcedure is the procedure name of the TruthcoinService's
 	// MarketPositions RPC.
 	TruthcoinServiceMarketPositionsProcedure = "/truthcoin.v1.TruthcoinService/MarketPositions"
-	// TruthcoinServiceMarketAmplifyBetaProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceMarketAmplifyBetaProcedure is the procedure name of the TruthcoinService's
 	// MarketAmplifyBeta RPC.
 	TruthcoinServiceMarketAmplifyBetaProcedure = "/truthcoin.v1.TruthcoinService/MarketAmplifyBeta"
-	// TruthcoinServiceSlotStatusProcedure is the fully-qualified name of the TruthcoinService's
-	// SlotStatus RPC.
-	TruthcoinServiceSlotStatusProcedure = "/truthcoin.v1.TruthcoinService/SlotStatus"
-	// TruthcoinServiceSlotListProcedure is the fully-qualified name of the TruthcoinService's SlotList
+	// TruthcoinServiceSlotStatusProcedure is the procedure name of the TruthcoinService's SlotStatus
 	// RPC.
+	TruthcoinServiceSlotStatusProcedure = "/truthcoin.v1.TruthcoinService/SlotStatus"
+	// TruthcoinServiceSlotListProcedure is the procedure name of the TruthcoinService's SlotList RPC.
 	TruthcoinServiceSlotListProcedure = "/truthcoin.v1.TruthcoinService/SlotList"
-	// TruthcoinServiceSlotGetProcedure is the fully-qualified name of the TruthcoinService's SlotGet
-	// RPC.
+	// TruthcoinServiceSlotGetProcedure is the procedure name of the TruthcoinService's SlotGet RPC.
 	TruthcoinServiceSlotGetProcedure = "/truthcoin.v1.TruthcoinService/SlotGet"
-	// TruthcoinServiceSlotClaimProcedure is the fully-qualified name of the TruthcoinService's
-	// SlotClaim RPC.
+	// TruthcoinServiceSlotClaimProcedure is the procedure name of the TruthcoinService's SlotClaim RPC.
 	TruthcoinServiceSlotClaimProcedure = "/truthcoin.v1.TruthcoinService/SlotClaim"
-	// TruthcoinServiceSlotClaimCategoryProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceSlotClaimCategoryProcedure is the procedure name of the TruthcoinService's
 	// SlotClaimCategory RPC.
 	TruthcoinServiceSlotClaimCategoryProcedure = "/truthcoin.v1.TruthcoinService/SlotClaimCategory"
-	// TruthcoinServiceGetVoterAddressProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetVoterAddressProcedure is the procedure name of the TruthcoinService's
 	// GetVoterAddress RPC.
 	TruthcoinServiceGetVoterAddressProcedure = "/truthcoin.v1.TruthcoinService/GetVoterAddress"
-	// TruthcoinServiceVoteVoterProcedure is the fully-qualified name of the TruthcoinService's
-	// VoteVoter RPC.
+	// TruthcoinServiceVoteVoterProcedure is the procedure name of the TruthcoinService's VoteVoter RPC.
 	TruthcoinServiceVoteVoterProcedure = "/truthcoin.v1.TruthcoinService/VoteVoter"
-	// TruthcoinServiceVoteVotersProcedure is the fully-qualified name of the TruthcoinService's
-	// VoteVoters RPC.
+	// TruthcoinServiceVoteVotersProcedure is the procedure name of the TruthcoinService's VoteVoters
+	// RPC.
 	TruthcoinServiceVoteVotersProcedure = "/truthcoin.v1.TruthcoinService/VoteVoters"
-	// TruthcoinServiceVoteSubmitProcedure is the fully-qualified name of the TruthcoinService's
-	// VoteSubmit RPC.
-	TruthcoinServiceVoteSubmitProcedure = "/truthcoin.v1.TruthcoinService/VoteSubmit"
-	// TruthcoinServiceVoteListProcedure is the fully-qualified name of the TruthcoinService's VoteList
+	// TruthcoinServiceVoteSubmitProcedure is the procedure name of the TruthcoinService's VoteSubmit
 	// RPC.
+	TruthcoinServiceVoteSubmitProcedure = "/truthcoin.v1.TruthcoinService/VoteSubmit"
+	// TruthcoinServiceVoteListProcedure is the procedure name of the TruthcoinService's VoteList RPC.
 	TruthcoinServiceVoteListProcedure = "/truthcoin.v1.TruthcoinService/VoteList"
-	// TruthcoinServiceVotePeriodProcedure is the fully-qualified name of the TruthcoinService's
-	// VotePeriod RPC.
+	// TruthcoinServiceVotePeriodProcedure is the procedure name of the TruthcoinService's VotePeriod
+	// RPC.
 	TruthcoinServiceVotePeriodProcedure = "/truthcoin.v1.TruthcoinService/VotePeriod"
-	// TruthcoinServiceVotecoinTransferProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceVotecoinTransferProcedure is the procedure name of the TruthcoinService's
 	// VotecoinTransfer RPC.
 	TruthcoinServiceVotecoinTransferProcedure = "/truthcoin.v1.TruthcoinService/VotecoinTransfer"
-	// TruthcoinServiceVotecoinBalanceProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceVotecoinBalanceProcedure is the procedure name of the TruthcoinService's
 	// VotecoinBalance RPC.
 	TruthcoinServiceVotecoinBalanceProcedure = "/truthcoin.v1.TruthcoinService/VotecoinBalance"
-	// TruthcoinServiceTransferVotecoinProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceTransferVotecoinProcedure is the procedure name of the TruthcoinService's
 	// TransferVotecoin RPC.
 	TruthcoinServiceTransferVotecoinProcedure = "/truthcoin.v1.TruthcoinService/TransferVotecoin"
-	// TruthcoinServiceGetNewEncryptionKeyProcedure is the fully-qualified name of the
-	// TruthcoinService's GetNewEncryptionKey RPC.
+	// TruthcoinServiceGetNewEncryptionKeyProcedure is the procedure name of the TruthcoinService's
+	// GetNewEncryptionKey RPC.
 	TruthcoinServiceGetNewEncryptionKeyProcedure = "/truthcoin.v1.TruthcoinService/GetNewEncryptionKey"
-	// TruthcoinServiceGetNewVerifyingKeyProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceGetNewVerifyingKeyProcedure is the procedure name of the TruthcoinService's
 	// GetNewVerifyingKey RPC.
 	TruthcoinServiceGetNewVerifyingKeyProcedure = "/truthcoin.v1.TruthcoinService/GetNewVerifyingKey"
-	// TruthcoinServiceEncryptMsgProcedure is the fully-qualified name of the TruthcoinService's
-	// EncryptMsg RPC.
+	// TruthcoinServiceEncryptMsgProcedure is the procedure name of the TruthcoinService's EncryptMsg
+	// RPC.
 	TruthcoinServiceEncryptMsgProcedure = "/truthcoin.v1.TruthcoinService/EncryptMsg"
-	// TruthcoinServiceDecryptMsgProcedure is the fully-qualified name of the TruthcoinService's
-	// DecryptMsg RPC.
+	// TruthcoinServiceDecryptMsgProcedure is the procedure name of the TruthcoinService's DecryptMsg
+	// RPC.
 	TruthcoinServiceDecryptMsgProcedure = "/truthcoin.v1.TruthcoinService/DecryptMsg"
-	// TruthcoinServiceSignArbitraryMsgProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceSignArbitraryMsgProcedure is the procedure name of the TruthcoinService's
 	// SignArbitraryMsg RPC.
 	TruthcoinServiceSignArbitraryMsgProcedure = "/truthcoin.v1.TruthcoinService/SignArbitraryMsg"
-	// TruthcoinServiceSignArbitraryMsgAsAddrProcedure is the fully-qualified name of the
-	// TruthcoinService's SignArbitraryMsgAsAddr RPC.
+	// TruthcoinServiceSignArbitraryMsgAsAddrProcedure is the procedure name of the TruthcoinService's
+	// SignArbitraryMsgAsAddr RPC.
 	TruthcoinServiceSignArbitraryMsgAsAddrProcedure = "/truthcoin.v1.TruthcoinService/SignArbitraryMsgAsAddr"
-	// TruthcoinServiceVerifySignatureProcedure is the fully-qualified name of the TruthcoinService's
+	// TruthcoinServiceVerifySignatureProcedure is the procedure name of the TruthcoinService's
 	// VerifySignature RPC.
 	TruthcoinServiceVerifySignatureProcedure = "/truthcoin.v1.TruthcoinService/VerifySignature"
 )
 
+var (
+	truthcoinServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetBalance"),
+			Procedure:  TruthcoinServiceGetBalanceProcedure,
+		}
+	})
+	truthcoinServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetBlockCount"),
+			Procedure:  TruthcoinServiceGetBlockCountProcedure,
+		}
+	})
+	truthcoinServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("Stop"),
+			Procedure:  TruthcoinServiceStopProcedure,
+		}
+	})
+	truthcoinServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetNewAddress"),
+			Procedure:  TruthcoinServiceGetNewAddressProcedure,
+		}
+	})
+	truthcoinServiceWithdrawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("Withdraw"),
+			Procedure:  TruthcoinServiceWithdrawProcedure,
+		}
+	})
+	truthcoinServiceTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("Transfer"),
+			Procedure:  TruthcoinServiceTransferProcedure,
+		}
+	})
+	truthcoinServiceGetSidechainWealthSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetSidechainWealth"),
+			Procedure:  TruthcoinServiceGetSidechainWealthProcedure,
+		}
+	})
+	truthcoinServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("CreateDeposit"),
+			Procedure:  TruthcoinServiceCreateDepositProcedure,
+		}
+	})
+	truthcoinServiceGetPendingWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetPendingWithdrawalBundle"),
+			Procedure:  TruthcoinServiceGetPendingWithdrawalBundleProcedure,
+		}
+	})
+	truthcoinServiceConnectPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("ConnectPeer"),
+			Procedure:  TruthcoinServiceConnectPeerProcedure,
+		}
+	})
+	truthcoinServiceListPeersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("ListPeers"),
+			Procedure:  TruthcoinServiceListPeersProcedure,
+		}
+	})
+	truthcoinServiceMineSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("Mine"),
+			Procedure:  TruthcoinServiceMineProcedure,
+		}
+	})
+	truthcoinServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetBlock"),
+			Procedure:  TruthcoinServiceGetBlockProcedure,
+		}
+	})
+	truthcoinServiceGetBestMainchainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetBestMainchainBlockHash"),
+			Procedure:  TruthcoinServiceGetBestMainchainBlockHashProcedure,
+		}
+	})
+	truthcoinServiceGetBestSidechainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetBestSidechainBlockHash"),
+			Procedure:  TruthcoinServiceGetBestSidechainBlockHashProcedure,
+		}
+	})
+	truthcoinServiceGetBmmInclusionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetBmmInclusions"),
+			Procedure:  TruthcoinServiceGetBmmInclusionsProcedure,
+		}
+	})
+	truthcoinServiceGetWalletUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetWalletUtxos"),
+			Procedure:  TruthcoinServiceGetWalletUtxosProcedure,
+		}
+	})
+	truthcoinServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("ListUtxos"),
+			Procedure:  TruthcoinServiceListUtxosProcedure,
+		}
+	})
+	truthcoinServiceRemoveFromMempoolSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("RemoveFromMempool"),
+			Procedure:  TruthcoinServiceRemoveFromMempoolProcedure,
+		}
+	})
+	truthcoinServiceGetLatestFailedWithdrawalBundleHeightSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetLatestFailedWithdrawalBundleHeight"),
+			Procedure:  TruthcoinServiceGetLatestFailedWithdrawalBundleHeightProcedure,
+		}
+	})
+	truthcoinServiceGenerateMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GenerateMnemonic"),
+			Procedure:  TruthcoinServiceGenerateMnemonicProcedure,
+		}
+	})
+	truthcoinServiceSetSeedFromMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SetSeedFromMnemonic"),
+			Procedure:  TruthcoinServiceSetSeedFromMnemonicProcedure,
+		}
+	})
+	truthcoinServiceCallRawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("CallRaw"),
+			Procedure:  TruthcoinServiceCallRawProcedure,
+		}
+	})
+	truthcoinServiceRefreshWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("RefreshWallet"),
+			Procedure:  TruthcoinServiceRefreshWalletProcedure,
+		}
+	})
+	truthcoinServiceGetTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetTransaction"),
+			Procedure:  TruthcoinServiceGetTransactionProcedure,
+		}
+	})
+	truthcoinServiceGetTransactionInfoSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetTransactionInfo"),
+			Procedure:  TruthcoinServiceGetTransactionInfoProcedure,
+		}
+	})
+	truthcoinServiceGetWalletAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetWalletAddresses"),
+			Procedure:  TruthcoinServiceGetWalletAddressesProcedure,
+		}
+	})
+	truthcoinServiceMyUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MyUtxos"),
+			Procedure:  TruthcoinServiceMyUtxosProcedure,
+		}
+	})
+	truthcoinServiceMyUnconfirmedUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MyUnconfirmedUtxos"),
+			Procedure:  TruthcoinServiceMyUnconfirmedUtxosProcedure,
+		}
+	})
+	truthcoinServiceCalculateInitialLiquiditySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("CalculateInitialLiquidity"),
+			Procedure:  TruthcoinServiceCalculateInitialLiquidityProcedure,
+		}
+	})
+	truthcoinServiceMarketCreateSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MarketCreate"),
+			Procedure:  TruthcoinServiceMarketCreateProcedure,
+		}
+	})
+	truthcoinServiceMarketListSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MarketList"),
+			Procedure:  TruthcoinServiceMarketListProcedure,
+		}
+	})
+	truthcoinServiceMarketGetSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MarketGet"),
+			Procedure:  TruthcoinServiceMarketGetProcedure,
+		}
+	})
+	truthcoinServiceMarketBuySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MarketBuy"),
+			Procedure:  TruthcoinServiceMarketBuyProcedure,
+		}
+	})
+	truthcoinServiceMarketSellSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MarketSell"),
+			Procedure:  TruthcoinServiceMarketSellProcedure,
+		}
+	})
+	truthcoinServiceMarketPositionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MarketPositions"),
+			Procedure:  TruthcoinServiceMarketPositionsProcedure,
+		}
+	})
+	truthcoinServiceMarketAmplifyBetaSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("MarketAmplifyBeta"),
+			Procedure:  TruthcoinServiceMarketAmplifyBetaProcedure,
+		}
+	})
+	truthcoinServiceSlotStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SlotStatus"),
+			Procedure:  TruthcoinServiceSlotStatusProcedure,
+		}
+	})
+	truthcoinServiceSlotListSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SlotList"),
+			Procedure:  TruthcoinServiceSlotListProcedure,
+		}
+	})
+	truthcoinServiceSlotGetSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SlotGet"),
+			Procedure:  TruthcoinServiceSlotGetProcedure,
+		}
+	})
+	truthcoinServiceSlotClaimSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SlotClaim"),
+			Procedure:  TruthcoinServiceSlotClaimProcedure,
+		}
+	})
+	truthcoinServiceSlotClaimCategorySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SlotClaimCategory"),
+			Procedure:  TruthcoinServiceSlotClaimCategoryProcedure,
+		}
+	})
+	truthcoinServiceGetVoterAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetVoterAddress"),
+			Procedure:  TruthcoinServiceGetVoterAddressProcedure,
+		}
+	})
+	truthcoinServiceVoteVoterSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VoteVoter"),
+			Procedure:  TruthcoinServiceVoteVoterProcedure,
+		}
+	})
+	truthcoinServiceVoteVotersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VoteVoters"),
+			Procedure:  TruthcoinServiceVoteVotersProcedure,
+		}
+	})
+	truthcoinServiceVoteSubmitSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VoteSubmit"),
+			Procedure:  TruthcoinServiceVoteSubmitProcedure,
+		}
+	})
+	truthcoinServiceVoteListSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VoteList"),
+			Procedure:  TruthcoinServiceVoteListProcedure,
+		}
+	})
+	truthcoinServiceVotePeriodSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VotePeriod"),
+			Procedure:  TruthcoinServiceVotePeriodProcedure,
+		}
+	})
+	truthcoinServiceVotecoinTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VotecoinTransfer"),
+			Procedure:  TruthcoinServiceVotecoinTransferProcedure,
+		}
+	})
+	truthcoinServiceVotecoinBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VotecoinBalance"),
+			Procedure:  TruthcoinServiceVotecoinBalanceProcedure,
+		}
+	})
+	truthcoinServiceTransferVotecoinSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("TransferVotecoin"),
+			Procedure:  TruthcoinServiceTransferVotecoinProcedure,
+		}
+	})
+	truthcoinServiceGetNewEncryptionKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetNewEncryptionKey"),
+			Procedure:  TruthcoinServiceGetNewEncryptionKeyProcedure,
+		}
+	})
+	truthcoinServiceGetNewVerifyingKeySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("GetNewVerifyingKey"),
+			Procedure:  TruthcoinServiceGetNewVerifyingKeyProcedure,
+		}
+	})
+	truthcoinServiceEncryptMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("EncryptMsg"),
+			Procedure:  TruthcoinServiceEncryptMsgProcedure,
+		}
+	})
+	truthcoinServiceDecryptMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("DecryptMsg"),
+			Procedure:  TruthcoinServiceDecryptMsgProcedure,
+		}
+	})
+	truthcoinServiceSignArbitraryMsgSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SignArbitraryMsg"),
+			Procedure:  TruthcoinServiceSignArbitraryMsgProcedure,
+		}
+	})
+	truthcoinServiceSignArbitraryMsgAsAddrSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("SignArbitraryMsgAsAddr"),
+			Procedure:  TruthcoinServiceSignArbitraryMsgAsAddrProcedure,
+		}
+	})
+	truthcoinServiceVerifySignatureSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods().ByName("VerifySignature"),
+			Procedure:  TruthcoinServiceVerifySignatureProcedure,
+		}
+	})
+)
+
 // TruthcoinServiceClient is a client for the truthcoin.v1.TruthcoinService service.
 type TruthcoinServiceClient interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the truthcoin node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Refresh wallet state.
-	RefreshWallet(context.Context, *connect.Request[v1.RefreshWalletRequest]) (*connect.Response[v1.RefreshWalletResponse], error)
-	// Get transaction by txid.
-	GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error)
-	// Get transaction info.
-	GetTransactionInfo(context.Context, *connect.Request[v1.GetTransactionInfoRequest]) (*connect.Response[v1.GetTransactionInfoResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// Get owned UTXOs (confirmed).
-	MyUtxos(context.Context, *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error)
-	// Get owned UTXOs (unconfirmed).
-	MyUnconfirmedUtxos(context.Context, *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error)
-	// Calculate initial liquidity required for market creation.
-	CalculateInitialLiquidity(context.Context, *connect.Request[v1.CalculateInitialLiquidityRequest]) (*connect.Response[v1.CalculateInitialLiquidityResponse], error)
-	// Create a new prediction market.
-	MarketCreate(context.Context, *connect.Request[v1.MarketCreateRequest]) (*connect.Response[v1.MarketCreateResponse], error)
-	// List all markets.
-	MarketList(context.Context, *connect.Request[v1.MarketListRequest]) (*connect.Response[v1.MarketListResponse], error)
-	// Get a specific market.
-	MarketGet(context.Context, *connect.Request[v1.MarketGetRequest]) (*connect.Response[v1.MarketGetResponse], error)
-	// Buy shares in a market.
-	MarketBuy(context.Context, *connect.Request[v1.MarketBuyRequest]) (*connect.Response[v1.MarketBuyResponse], error)
-	// Sell shares in a market.
-	MarketSell(context.Context, *connect.Request[v1.MarketSellRequest]) (*connect.Response[v1.MarketSellResponse], error)
-	// Get positions in a market.
-	MarketPositions(context.Context, *connect.Request[v1.MarketPositionsRequest]) (*connect.Response[v1.MarketPositionsResponse], error)
-	// Add liquidity to a market that a wallet address created.
-	MarketAmplifyBeta(context.Context, *connect.Request[v1.MarketAmplifyBetaRequest]) (*connect.Response[v1.MarketAmplifyBetaResponse], error)
-	// Get slot system status and configuration.
-	SlotStatus(context.Context, *connect.Request[v1.SlotStatusRequest]) (*connect.Response[v1.SlotStatusResponse], error)
-	// List slots with optional filtering.
-	SlotList(context.Context, *connect.Request[v1.SlotListRequest]) (*connect.Response[v1.SlotListResponse], error)
-	// Get a specific slot by ID.
-	SlotGet(context.Context, *connect.Request[v1.SlotGetRequest]) (*connect.Response[v1.SlotGetResponse], error)
-	// Claim a decision slot.
-	SlotClaim(context.Context, *connect.Request[v1.SlotClaimRequest]) (*connect.Response[v1.SlotClaimResponse], error)
-	// Claim multiple slots as a category.
-	SlotClaimCategory(context.Context, *connect.Request[v1.SlotClaimCategoryRequest]) (*connect.Response[v1.SlotClaimCategoryResponse], error)
-	// Get the voter address of the wallet.
-	GetVoterAddress(context.Context, *connect.Request[v1.GetVoterAddressRequest]) (*connect.Response[v1.GetVoterAddressResponse], error)
-	// Get voter info.
-	VoteVoter(context.Context, *connect.Request[v1.VoteVoterRequest]) (*connect.Response[v1.VoteVoterResponse], error)
-	// List all voters.
-	VoteVoters(context.Context, *connect.Request[v1.VoteVotersRequest]) (*connect.Response[v1.VoteVotersResponse], error)
-	// Submit votes (batch).
-	VoteSubmit(context.Context, *connect.Request[v1.VoteSubmitRequest]) (*connect.Response[v1.VoteSubmitResponse], error)
-	// List votes with optional filters.
-	VoteList(context.Context, *connect.Request[v1.VoteListRequest]) (*connect.Response[v1.VoteListResponse], error)
-	// Get voting period information.
-	VotePeriod(context.Context, *connect.Request[v1.VotePeriodRequest]) (*connect.Response[v1.VotePeriodResponse], error)
-	// Transfer votecoins.
-	VotecoinTransfer(context.Context, *connect.Request[v1.VotecoinTransferRequest]) (*connect.Response[v1.VotecoinTransferResponse], error)
-	// Get votecoin balance for an address.
-	VotecoinBalance(context.Context, *connect.Request[v1.VotecoinBalanceRequest]) (*connect.Response[v1.VotecoinBalanceResponse], error)
-	// Transfer votecoin (alternative method).
-	TransferVotecoin(context.Context, *connect.Request[v1.TransferVotecoinRequest]) (*connect.Response[v1.TransferVotecoinResponse], error)
-	// Get a new encryption key.
-	GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error)
-	// Get a new verifying key.
-	GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error)
-	// Encrypt a message.
-	EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error)
-	// Decrypt a message.
-	DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error)
-	// Sign an arbitrary message with verifying key.
-	SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error)
-	// Sign an arbitrary message as address.
-	SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error)
-	// Verify a signature.
-	VerifySignature(context.Context, *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error)
-}
-
-// NewTruthcoinServiceClient constructs a client for the truthcoin.v1.TruthcoinService service. By
-// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
-// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
-// connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewTruthcoinServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) TruthcoinServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	truthcoinServiceMethods := v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods()
-	return &truthcoinServiceClient{
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetBalanceProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetBlockCountProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+TruthcoinServiceStopProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetNewAddressProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		withdraw: connect.NewClient[v1.WithdrawRequest, v1.WithdrawResponse](
-			httpClient,
-			baseURL+TruthcoinServiceWithdrawProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("Withdraw")),
-			connect.WithClientOptions(opts...),
-		),
-		transfer: connect.NewClient[v1.TransferRequest, v1.TransferResponse](
-			httpClient,
-			baseURL+TruthcoinServiceTransferProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("Transfer")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainWealth: connect.NewClient[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetSidechainWealthProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetSidechainWealth")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+TruthcoinServiceCreateDepositProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingWithdrawalBundle: connect.NewClient[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetPendingWithdrawalBundleProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetPendingWithdrawalBundle")),
-			connect.WithClientOptions(opts...),
-		),
-		connectPeer: connect.NewClient[v1.ConnectPeerRequest, v1.ConnectPeerResponse](
-			httpClient,
-			baseURL+TruthcoinServiceConnectPeerProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("ConnectPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		listPeers: connect.NewClient[v1.ListPeersRequest, v1.ListPeersResponse](
-			httpClient,
-			baseURL+TruthcoinServiceListPeersProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("ListPeers")),
-			connect.WithClientOptions(opts...),
-		),
-		mine: connect.NewClient[v1.MineRequest, v1.MineResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMineProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("Mine")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetBlockProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestMainchainBlockHash: connect.NewClient[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetBestMainchainBlockHashProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetBestMainchainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestSidechainBlockHash: connect.NewClient[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetBestSidechainBlockHashProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetBestSidechainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmInclusions: connect.NewClient[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetBmmInclusionsProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetBmmInclusions")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletUtxos: connect.NewClient[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetWalletUtxosProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetWalletUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+TruthcoinServiceListUtxosProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		removeFromMempool: connect.NewClient[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse](
-			httpClient,
-			baseURL+TruthcoinServiceRemoveFromMempoolProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("RemoveFromMempool")),
-			connect.WithClientOptions(opts...),
-		),
-		getLatestFailedWithdrawalBundleHeight: connect.NewClient[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-			connect.WithClientOptions(opts...),
-		),
-		generateMnemonic: connect.NewClient[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGenerateMnemonicProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GenerateMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		setSeedFromMnemonic: connect.NewClient[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSetSeedFromMnemonicProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SetSeedFromMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		callRaw: connect.NewClient[v1.CallRawRequest, v1.CallRawResponse](
-			httpClient,
-			baseURL+TruthcoinServiceCallRawProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("CallRaw")),
-			connect.WithClientOptions(opts...),
-		),
-		refreshWallet: connect.NewClient[v1.RefreshWalletRequest, v1.RefreshWalletResponse](
-			httpClient,
-			baseURL+TruthcoinServiceRefreshWalletProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("RefreshWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransaction: connect.NewClient[v1.GetTransactionRequest, v1.GetTransactionResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetTransactionProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransactionInfo: connect.NewClient[v1.GetTransactionInfoRequest, v1.GetTransactionInfoResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetTransactionInfoProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetTransactionInfo")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletAddresses: connect.NewClient[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetWalletAddressesProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetWalletAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		myUtxos: connect.NewClient[v1.MyUtxosRequest, v1.MyUtxosResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMyUtxosProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MyUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		myUnconfirmedUtxos: connect.NewClient[v1.MyUnconfirmedUtxosRequest, v1.MyUnconfirmedUtxosResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMyUnconfirmedUtxosProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MyUnconfirmedUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		calculateInitialLiquidity: connect.NewClient[v1.CalculateInitialLiquidityRequest, v1.CalculateInitialLiquidityResponse](
-			httpClient,
-			baseURL+TruthcoinServiceCalculateInitialLiquidityProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("CalculateInitialLiquidity")),
-			connect.WithClientOptions(opts...),
-		),
-		marketCreate: connect.NewClient[v1.MarketCreateRequest, v1.MarketCreateResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMarketCreateProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MarketCreate")),
-			connect.WithClientOptions(opts...),
-		),
-		marketList: connect.NewClient[v1.MarketListRequest, v1.MarketListResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMarketListProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MarketList")),
-			connect.WithClientOptions(opts...),
-		),
-		marketGet: connect.NewClient[v1.MarketGetRequest, v1.MarketGetResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMarketGetProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MarketGet")),
-			connect.WithClientOptions(opts...),
-		),
-		marketBuy: connect.NewClient[v1.MarketBuyRequest, v1.MarketBuyResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMarketBuyProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MarketBuy")),
-			connect.WithClientOptions(opts...),
-		),
-		marketSell: connect.NewClient[v1.MarketSellRequest, v1.MarketSellResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMarketSellProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MarketSell")),
-			connect.WithClientOptions(opts...),
-		),
-		marketPositions: connect.NewClient[v1.MarketPositionsRequest, v1.MarketPositionsResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMarketPositionsProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MarketPositions")),
-			connect.WithClientOptions(opts...),
-		),
-		marketAmplifyBeta: connect.NewClient[v1.MarketAmplifyBetaRequest, v1.MarketAmplifyBetaResponse](
-			httpClient,
-			baseURL+TruthcoinServiceMarketAmplifyBetaProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("MarketAmplifyBeta")),
-			connect.WithClientOptions(opts...),
-		),
-		slotStatus: connect.NewClient[v1.SlotStatusRequest, v1.SlotStatusResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSlotStatusProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SlotStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		slotList: connect.NewClient[v1.SlotListRequest, v1.SlotListResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSlotListProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SlotList")),
-			connect.WithClientOptions(opts...),
-		),
-		slotGet: connect.NewClient[v1.SlotGetRequest, v1.SlotGetResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSlotGetProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SlotGet")),
-			connect.WithClientOptions(opts...),
-		),
-		slotClaim: connect.NewClient[v1.SlotClaimRequest, v1.SlotClaimResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSlotClaimProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SlotClaim")),
-			connect.WithClientOptions(opts...),
-		),
-		slotClaimCategory: connect.NewClient[v1.SlotClaimCategoryRequest, v1.SlotClaimCategoryResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSlotClaimCategoryProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SlotClaimCategory")),
-			connect.WithClientOptions(opts...),
-		),
-		getVoterAddress: connect.NewClient[v1.GetVoterAddressRequest, v1.GetVoterAddressResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetVoterAddressProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetVoterAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		voteVoter: connect.NewClient[v1.VoteVoterRequest, v1.VoteVoterResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVoteVoterProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VoteVoter")),
-			connect.WithClientOptions(opts...),
-		),
-		voteVoters: connect.NewClient[v1.VoteVotersRequest, v1.VoteVotersResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVoteVotersProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VoteVoters")),
-			connect.WithClientOptions(opts...),
-		),
-		voteSubmit: connect.NewClient[v1.VoteSubmitRequest, v1.VoteSubmitResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVoteSubmitProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VoteSubmit")),
-			connect.WithClientOptions(opts...),
-		),
-		voteList: connect.NewClient[v1.VoteListRequest, v1.VoteListResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVoteListProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VoteList")),
-			connect.WithClientOptions(opts...),
-		),
-		votePeriod: connect.NewClient[v1.VotePeriodRequest, v1.VotePeriodResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVotePeriodProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VotePeriod")),
-			connect.WithClientOptions(opts...),
-		),
-		votecoinTransfer: connect.NewClient[v1.VotecoinTransferRequest, v1.VotecoinTransferResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVotecoinTransferProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VotecoinTransfer")),
-			connect.WithClientOptions(opts...),
-		),
-		votecoinBalance: connect.NewClient[v1.VotecoinBalanceRequest, v1.VotecoinBalanceResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVotecoinBalanceProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VotecoinBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		transferVotecoin: connect.NewClient[v1.TransferVotecoinRequest, v1.TransferVotecoinResponse](
-			httpClient,
-			baseURL+TruthcoinServiceTransferVotecoinProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("TransferVotecoin")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewEncryptionKey: connect.NewClient[v1.GetNewEncryptionKeyRequest, v1.GetNewEncryptionKeyResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetNewEncryptionKeyProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetNewEncryptionKey")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewVerifyingKey: connect.NewClient[v1.GetNewVerifyingKeyRequest, v1.GetNewVerifyingKeyResponse](
-			httpClient,
-			baseURL+TruthcoinServiceGetNewVerifyingKeyProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("GetNewVerifyingKey")),
-			connect.WithClientOptions(opts...),
-		),
-		encryptMsg: connect.NewClient[v1.EncryptMsgRequest, v1.EncryptMsgResponse](
-			httpClient,
-			baseURL+TruthcoinServiceEncryptMsgProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("EncryptMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		decryptMsg: connect.NewClient[v1.DecryptMsgRequest, v1.DecryptMsgResponse](
-			httpClient,
-			baseURL+TruthcoinServiceDecryptMsgProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("DecryptMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		signArbitraryMsg: connect.NewClient[v1.SignArbitraryMsgRequest, v1.SignArbitraryMsgResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSignArbitraryMsgProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SignArbitraryMsg")),
-			connect.WithClientOptions(opts...),
-		),
-		signArbitraryMsgAsAddr: connect.NewClient[v1.SignArbitraryMsgAsAddrRequest, v1.SignArbitraryMsgAsAddrResponse](
-			httpClient,
-			baseURL+TruthcoinServiceSignArbitraryMsgAsAddrProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("SignArbitraryMsgAsAddr")),
-			connect.WithClientOptions(opts...),
-		),
-		verifySignature: connect.NewClient[v1.VerifySignatureRequest, v1.VerifySignatureResponse](
-			httpClient,
-			baseURL+TruthcoinServiceVerifySignatureProcedure,
-			connect.WithSchema(truthcoinServiceMethods.ByName("VerifySignature")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// truthcoinServiceClient implements TruthcoinServiceClient.
-type truthcoinServiceClient struct {
-	getBalance                            *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getBlockCount                         *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	stop                                  *connect.Client[v1.StopRequest, v1.StopResponse]
-	getNewAddress                         *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	withdraw                              *connect.Client[v1.WithdrawRequest, v1.WithdrawResponse]
-	transfer                              *connect.Client[v1.TransferRequest, v1.TransferResponse]
-	getSidechainWealth                    *connect.Client[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse]
-	createDeposit                         *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	getPendingWithdrawalBundle            *connect.Client[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse]
-	connectPeer                           *connect.Client[v1.ConnectPeerRequest, v1.ConnectPeerResponse]
-	listPeers                             *connect.Client[v1.ListPeersRequest, v1.ListPeersResponse]
-	mine                                  *connect.Client[v1.MineRequest, v1.MineResponse]
-	getBlock                              *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	getBestMainchainBlockHash             *connect.Client[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse]
-	getBestSidechainBlockHash             *connect.Client[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse]
-	getBmmInclusions                      *connect.Client[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse]
-	getWalletUtxos                        *connect.Client[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse]
-	listUtxos                             *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	removeFromMempool                     *connect.Client[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse]
-	getLatestFailedWithdrawalBundleHeight *connect.Client[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse]
-	generateMnemonic                      *connect.Client[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse]
-	setSeedFromMnemonic                   *connect.Client[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse]
-	callRaw                               *connect.Client[v1.CallRawRequest, v1.CallRawResponse]
-	refreshWallet                         *connect.Client[v1.RefreshWalletRequest, v1.RefreshWalletResponse]
-	getTransaction                        *connect.Client[v1.GetTransactionRequest, v1.GetTransactionResponse]
-	getTransactionInfo                    *connect.Client[v1.GetTransactionInfoRequest, v1.GetTransactionInfoResponse]
-	getWalletAddresses                    *connect.Client[v1.GetWalletAddressesRequest, v1.GetWalletAddressesResponse]
-	myUtxos                               *connect.Client[v1.MyUtxosRequest, v1.MyUtxosResponse]
-	myUnconfirmedUtxos                    *connect.Client[v1.MyUnconfirmedUtxosRequest, v1.MyUnconfirmedUtxosResponse]
-	calculateInitialLiquidity             *connect.Client[v1.CalculateInitialLiquidityRequest, v1.CalculateInitialLiquidityResponse]
-	marketCreate                          *connect.Client[v1.MarketCreateRequest, v1.MarketCreateResponse]
-	marketList                            *connect.Client[v1.MarketListRequest, v1.MarketListResponse]
-	marketGet                             *connect.Client[v1.MarketGetRequest, v1.MarketGetResponse]
-	marketBuy                             *connect.Client[v1.MarketBuyRequest, v1.MarketBuyResponse]
-	marketSell                            *connect.Client[v1.MarketSellRequest, v1.MarketSellResponse]
-	marketPositions                       *connect.Client[v1.MarketPositionsRequest, v1.MarketPositionsResponse]
-	marketAmplifyBeta                     *connect.Client[v1.MarketAmplifyBetaRequest, v1.MarketAmplifyBetaResponse]
-	slotStatus                            *connect.Client[v1.SlotStatusRequest, v1.SlotStatusResponse]
-	slotList                              *connect.Client[v1.SlotListRequest, v1.SlotListResponse]
-	slotGet                               *connect.Client[v1.SlotGetRequest, v1.SlotGetResponse]
-	slotClaim                             *connect.Client[v1.SlotClaimRequest, v1.SlotClaimResponse]
-	slotClaimCategory                     *connect.Client[v1.SlotClaimCategoryRequest, v1.SlotClaimCategoryResponse]
-	getVoterAddress                       *connect.Client[v1.GetVoterAddressRequest, v1.GetVoterAddressResponse]
-	voteVoter                             *connect.Client[v1.VoteVoterRequest, v1.VoteVoterResponse]
-	voteVoters                            *connect.Client[v1.VoteVotersRequest, v1.VoteVotersResponse]
-	voteSubmit                            *connect.Client[v1.VoteSubmitRequest, v1.VoteSubmitResponse]
-	voteList                              *connect.Client[v1.VoteListRequest, v1.VoteListResponse]
-	votePeriod                            *connect.Client[v1.VotePeriodRequest, v1.VotePeriodResponse]
-	votecoinTransfer                      *connect.Client[v1.VotecoinTransferRequest, v1.VotecoinTransferResponse]
-	votecoinBalance                       *connect.Client[v1.VotecoinBalanceRequest, v1.VotecoinBalanceResponse]
-	transferVotecoin                      *connect.Client[v1.TransferVotecoinRequest, v1.TransferVotecoinResponse]
-	getNewEncryptionKey                   *connect.Client[v1.GetNewEncryptionKeyRequest, v1.GetNewEncryptionKeyResponse]
-	getNewVerifyingKey                    *connect.Client[v1.GetNewVerifyingKeyRequest, v1.GetNewVerifyingKeyResponse]
-	encryptMsg                            *connect.Client[v1.EncryptMsgRequest, v1.EncryptMsgResponse]
-	decryptMsg                            *connect.Client[v1.DecryptMsgRequest, v1.DecryptMsgResponse]
-	signArbitraryMsg                      *connect.Client[v1.SignArbitraryMsgRequest, v1.SignArbitraryMsgResponse]
-	signArbitraryMsgAsAddr                *connect.Client[v1.SignArbitraryMsgAsAddrRequest, v1.SignArbitraryMsgAsAddrResponse]
-	verifySignature                       *connect.Client[v1.VerifySignatureRequest, v1.VerifySignatureResponse]
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	RefreshWallet(context.Context, *v1.RefreshWalletRequest) (*v1.RefreshWalletResponse, error)
+	GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error)
+	GetTransactionInfo(context.Context, *v1.GetTransactionInfoRequest) (*v1.GetTransactionInfoResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	MyUtxos(context.Context, *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error)
+	MyUnconfirmedUtxos(context.Context, *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error)
+	CalculateInitialLiquidity(context.Context, *v1.CalculateInitialLiquidityRequest) (*v1.CalculateInitialLiquidityResponse, error)
+	MarketCreate(context.Context, *v1.MarketCreateRequest) (*v1.MarketCreateResponse, error)
+	MarketList(context.Context, *v1.MarketListRequest) (*v1.MarketListResponse, error)
+	MarketGet(context.Context, *v1.MarketGetRequest) (*v1.MarketGetResponse, error)
+	MarketBuy(context.Context, *v1.MarketBuyRequest) (*v1.MarketBuyResponse, error)
+	MarketSell(context.Context, *v1.MarketSellRequest) (*v1.MarketSellResponse, error)
+	MarketPositions(context.Context, *v1.MarketPositionsRequest) (*v1.MarketPositionsResponse, error)
+	MarketAmplifyBeta(context.Context, *v1.MarketAmplifyBetaRequest) (*v1.MarketAmplifyBetaResponse, error)
+	SlotStatus(context.Context, *v1.SlotStatusRequest) (*v1.SlotStatusResponse, error)
+	SlotList(context.Context, *v1.SlotListRequest) (*v1.SlotListResponse, error)
+	SlotGet(context.Context, *v1.SlotGetRequest) (*v1.SlotGetResponse, error)
+	SlotClaim(context.Context, *v1.SlotClaimRequest) (*v1.SlotClaimResponse, error)
+	SlotClaimCategory(context.Context, *v1.SlotClaimCategoryRequest) (*v1.SlotClaimCategoryResponse, error)
+	GetVoterAddress(context.Context, *v1.GetVoterAddressRequest) (*v1.GetVoterAddressResponse, error)
+	VoteVoter(context.Context, *v1.VoteVoterRequest) (*v1.VoteVoterResponse, error)
+	VoteVoters(context.Context, *v1.VoteVotersRequest) (*v1.VoteVotersResponse, error)
+	VoteSubmit(context.Context, *v1.VoteSubmitRequest) (*v1.VoteSubmitResponse, error)
+	VoteList(context.Context, *v1.VoteListRequest) (*v1.VoteListResponse, error)
+	VotePeriod(context.Context, *v1.VotePeriodRequest) (*v1.VotePeriodResponse, error)
+	VotecoinTransfer(context.Context, *v1.VotecoinTransferRequest) (*v1.VotecoinTransferResponse, error)
+	VotecoinBalance(context.Context, *v1.VotecoinBalanceRequest) (*v1.VotecoinBalanceResponse, error)
+	TransferVotecoin(context.Context, *v1.TransferVotecoinRequest) (*v1.TransferVotecoinResponse, error)
+	GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error)
+	GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error)
+	EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error)
+	DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error)
+	SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error)
+	SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error)
+	VerifySignature(context.Context, *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error)
+}
+
+// NewTruthcoinServiceClient constructs a client for the truthcoin.v1.TruthcoinService service.
+// Multiple service clients may share a single connect.Client.
+func NewTruthcoinServiceClient(client *connect.Client) TruthcoinServiceClient {
+	return &truthcoinServiceClient{client: client}
 }
 
-// GetBalance calls truthcoin.v1.TruthcoinService.GetBalance.
-func (c *truthcoinServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// TruthcoinServiceHandler is an implementation of the truthcoin.v1.TruthcoinService service.
+type TruthcoinServiceHandler interface {
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	RefreshWallet(context.Context, *v1.RefreshWalletRequest) (*v1.RefreshWalletResponse, error)
+	GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error)
+	GetTransactionInfo(context.Context, *v1.GetTransactionInfoRequest) (*v1.GetTransactionInfoResponse, error)
+	GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error)
+	MyUtxos(context.Context, *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error)
+	MyUnconfirmedUtxos(context.Context, *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error)
+	CalculateInitialLiquidity(context.Context, *v1.CalculateInitialLiquidityRequest) (*v1.CalculateInitialLiquidityResponse, error)
+	MarketCreate(context.Context, *v1.MarketCreateRequest) (*v1.MarketCreateResponse, error)
+	MarketList(context.Context, *v1.MarketListRequest) (*v1.MarketListResponse, error)
+	MarketGet(context.Context, *v1.MarketGetRequest) (*v1.MarketGetResponse, error)
+	MarketBuy(context.Context, *v1.MarketBuyRequest) (*v1.MarketBuyResponse, error)
+	MarketSell(context.Context, *v1.MarketSellRequest) (*v1.MarketSellResponse, error)
+	MarketPositions(context.Context, *v1.MarketPositionsRequest) (*v1.MarketPositionsResponse, error)
+	MarketAmplifyBeta(context.Context, *v1.MarketAmplifyBetaRequest) (*v1.MarketAmplifyBetaResponse, error)
+	SlotStatus(context.Context, *v1.SlotStatusRequest) (*v1.SlotStatusResponse, error)
+	SlotList(context.Context, *v1.SlotListRequest) (*v1.SlotListResponse, error)
+	SlotGet(context.Context, *v1.SlotGetRequest) (*v1.SlotGetResponse, error)
+	SlotClaim(context.Context, *v1.SlotClaimRequest) (*v1.SlotClaimResponse, error)
+	SlotClaimCategory(context.Context, *v1.SlotClaimCategoryRequest) (*v1.SlotClaimCategoryResponse, error)
+	GetVoterAddress(context.Context, *v1.GetVoterAddressRequest) (*v1.GetVoterAddressResponse, error)
+	VoteVoter(context.Context, *v1.VoteVoterRequest) (*v1.VoteVoterResponse, error)
+	VoteVoters(context.Context, *v1.VoteVotersRequest) (*v1.VoteVotersResponse, error)
+	VoteSubmit(context.Context, *v1.VoteSubmitRequest) (*v1.VoteSubmitResponse, error)
+	VoteList(context.Context, *v1.VoteListRequest) (*v1.VoteListResponse, error)
+	VotePeriod(context.Context, *v1.VotePeriodRequest) (*v1.VotePeriodResponse, error)
+	VotecoinTransfer(context.Context, *v1.VotecoinTransferRequest) (*v1.VotecoinTransferResponse, error)
+	VotecoinBalance(context.Context, *v1.VotecoinBalanceRequest) (*v1.VotecoinBalanceResponse, error)
+	TransferVotecoin(context.Context, *v1.TransferVotecoinRequest) (*v1.TransferVotecoinResponse, error)
+	GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error)
+	GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error)
+	EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error)
+	DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error)
+	SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error)
+	SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error)
+	VerifySignature(context.Context, *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error)
+}
+
+// RegisterTruthcoinServiceHandler registers svc as the truthcoin.v1.TruthcoinService implementation
+// on server.
+func RegisterTruthcoinServiceHandler(server *connect.Server, svc TruthcoinServiceHandler) {
+	adapter := truthcoinServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: truthcoinServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: truthcoinServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: truthcoinServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: truthcoinServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: truthcoinServiceWithdrawSpec(), Handler: adapter.withdraw},
+		connect.Method{Spec: truthcoinServiceTransferSpec(), Handler: adapter.transfer},
+		connect.Method{Spec: truthcoinServiceGetSidechainWealthSpec(), Handler: adapter.getSidechainWealth},
+		connect.Method{Spec: truthcoinServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: truthcoinServiceGetPendingWithdrawalBundleSpec(), Handler: adapter.getPendingWithdrawalBundle},
+		connect.Method{Spec: truthcoinServiceConnectPeerSpec(), Handler: adapter.connectPeer},
+		connect.Method{Spec: truthcoinServiceListPeersSpec(), Handler: adapter.listPeers},
+		connect.Method{Spec: truthcoinServiceMineSpec(), Handler: adapter.mine},
+		connect.Method{Spec: truthcoinServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: truthcoinServiceGetBestMainchainBlockHashSpec(), Handler: adapter.getBestMainchainBlockHash},
+		connect.Method{Spec: truthcoinServiceGetBestSidechainBlockHashSpec(), Handler: adapter.getBestSidechainBlockHash},
+		connect.Method{Spec: truthcoinServiceGetBmmInclusionsSpec(), Handler: adapter.getBmmInclusions},
+		connect.Method{Spec: truthcoinServiceGetWalletUtxosSpec(), Handler: adapter.getWalletUtxos},
+		connect.Method{Spec: truthcoinServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: truthcoinServiceRemoveFromMempoolSpec(), Handler: adapter.removeFromMempool},
+		connect.Method{Spec: truthcoinServiceGetLatestFailedWithdrawalBundleHeightSpec(), Handler: adapter.getLatestFailedWithdrawalBundleHeight},
+		connect.Method{Spec: truthcoinServiceGenerateMnemonicSpec(), Handler: adapter.generateMnemonic},
+		connect.Method{Spec: truthcoinServiceSetSeedFromMnemonicSpec(), Handler: adapter.setSeedFromMnemonic},
+		connect.Method{Spec: truthcoinServiceCallRawSpec(), Handler: adapter.callRaw},
+		connect.Method{Spec: truthcoinServiceRefreshWalletSpec(), Handler: adapter.refreshWallet},
+		connect.Method{Spec: truthcoinServiceGetTransactionSpec(), Handler: adapter.getTransaction},
+		connect.Method{Spec: truthcoinServiceGetTransactionInfoSpec(), Handler: adapter.getTransactionInfo},
+		connect.Method{Spec: truthcoinServiceGetWalletAddressesSpec(), Handler: adapter.getWalletAddresses},
+		connect.Method{Spec: truthcoinServiceMyUtxosSpec(), Handler: adapter.myUtxos},
+		connect.Method{Spec: truthcoinServiceMyUnconfirmedUtxosSpec(), Handler: adapter.myUnconfirmedUtxos},
+		connect.Method{Spec: truthcoinServiceCalculateInitialLiquiditySpec(), Handler: adapter.calculateInitialLiquidity},
+		connect.Method{Spec: truthcoinServiceMarketCreateSpec(), Handler: adapter.marketCreate},
+		connect.Method{Spec: truthcoinServiceMarketListSpec(), Handler: adapter.marketList},
+		connect.Method{Spec: truthcoinServiceMarketGetSpec(), Handler: adapter.marketGet},
+		connect.Method{Spec: truthcoinServiceMarketBuySpec(), Handler: adapter.marketBuy},
+		connect.Method{Spec: truthcoinServiceMarketSellSpec(), Handler: adapter.marketSell},
+		connect.Method{Spec: truthcoinServiceMarketPositionsSpec(), Handler: adapter.marketPositions},
+		connect.Method{Spec: truthcoinServiceMarketAmplifyBetaSpec(), Handler: adapter.marketAmplifyBeta},
+		connect.Method{Spec: truthcoinServiceSlotStatusSpec(), Handler: adapter.slotStatus},
+		connect.Method{Spec: truthcoinServiceSlotListSpec(), Handler: adapter.slotList},
+		connect.Method{Spec: truthcoinServiceSlotGetSpec(), Handler: adapter.slotGet},
+		connect.Method{Spec: truthcoinServiceSlotClaimSpec(), Handler: adapter.slotClaim},
+		connect.Method{Spec: truthcoinServiceSlotClaimCategorySpec(), Handler: adapter.slotClaimCategory},
+		connect.Method{Spec: truthcoinServiceGetVoterAddressSpec(), Handler: adapter.getVoterAddress},
+		connect.Method{Spec: truthcoinServiceVoteVoterSpec(), Handler: adapter.voteVoter},
+		connect.Method{Spec: truthcoinServiceVoteVotersSpec(), Handler: adapter.voteVoters},
+		connect.Method{Spec: truthcoinServiceVoteSubmitSpec(), Handler: adapter.voteSubmit},
+		connect.Method{Spec: truthcoinServiceVoteListSpec(), Handler: adapter.voteList},
+		connect.Method{Spec: truthcoinServiceVotePeriodSpec(), Handler: adapter.votePeriod},
+		connect.Method{Spec: truthcoinServiceVotecoinTransferSpec(), Handler: adapter.votecoinTransfer},
+		connect.Method{Spec: truthcoinServiceVotecoinBalanceSpec(), Handler: adapter.votecoinBalance},
+		connect.Method{Spec: truthcoinServiceTransferVotecoinSpec(), Handler: adapter.transferVotecoin},
+		connect.Method{Spec: truthcoinServiceGetNewEncryptionKeySpec(), Handler: adapter.getNewEncryptionKey},
+		connect.Method{Spec: truthcoinServiceGetNewVerifyingKeySpec(), Handler: adapter.getNewVerifyingKey},
+		connect.Method{Spec: truthcoinServiceEncryptMsgSpec(), Handler: adapter.encryptMsg},
+		connect.Method{Spec: truthcoinServiceDecryptMsgSpec(), Handler: adapter.decryptMsg},
+		connect.Method{Spec: truthcoinServiceSignArbitraryMsgSpec(), Handler: adapter.signArbitraryMsg},
+		connect.Method{Spec: truthcoinServiceSignArbitraryMsgAsAddrSpec(), Handler: adapter.signArbitraryMsgAsAddr},
+		connect.Method{Spec: truthcoinServiceVerifySignatureSpec(), Handler: adapter.verifySignature},
+	)
 }
 
-// GetBlockCount calls truthcoin.v1.TruthcoinService.GetBlockCount.
-func (c *truthcoinServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// UnimplementedTruthcoinServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedTruthcoinServiceHandler struct{}
+
+func (UnimplementedTruthcoinServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetBalance is not implemented")
 }
 
-// Stop calls truthcoin.v1.TruthcoinService.Stop.
-func (c *truthcoinServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetBlockCount is not implemented")
 }
 
-// GetNewAddress calls truthcoin.v1.TruthcoinService.GetNewAddress.
-func (c *truthcoinServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.Stop is not implemented")
 }
 
-// Withdraw calls truthcoin.v1.TruthcoinService.Withdraw.
-func (c *truthcoinServiceClient) Withdraw(ctx context.Context, req *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return c.withdraw.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetNewAddress is not implemented")
 }
 
-// Transfer calls truthcoin.v1.TruthcoinService.Transfer.
-func (c *truthcoinServiceClient) Transfer(ctx context.Context, req *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return c.transfer.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.Withdraw is not implemented")
 }
 
-// GetSidechainWealth calls truthcoin.v1.TruthcoinService.GetSidechainWealth.
-func (c *truthcoinServiceClient) GetSidechainWealth(ctx context.Context, req *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return c.getSidechainWealth.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.Transfer is not implemented")
 }
 
-// CreateDeposit calls truthcoin.v1.TruthcoinService.CreateDeposit.
-func (c *truthcoinServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetSidechainWealth is not implemented")
 }
 
-// GetPendingWithdrawalBundle calls truthcoin.v1.TruthcoinService.GetPendingWithdrawalBundle.
-func (c *truthcoinServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return c.getPendingWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.CreateDeposit is not implemented")
 }
 
-// ConnectPeer calls truthcoin.v1.TruthcoinService.ConnectPeer.
-func (c *truthcoinServiceClient) ConnectPeer(ctx context.Context, req *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return c.connectPeer.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetPendingWithdrawalBundle is not implemented")
 }
 
-// ListPeers calls truthcoin.v1.TruthcoinService.ListPeers.
-func (c *truthcoinServiceClient) ListPeers(ctx context.Context, req *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return c.listPeers.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.ConnectPeer is not implemented")
 }
 
-// Mine calls truthcoin.v1.TruthcoinService.Mine.
-func (c *truthcoinServiceClient) Mine(ctx context.Context, req *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return c.mine.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.ListPeers is not implemented")
 }
 
-// GetBlock calls truthcoin.v1.TruthcoinService.GetBlock.
-func (c *truthcoinServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.Mine is not implemented")
 }
 
-// GetBestMainchainBlockHash calls truthcoin.v1.TruthcoinService.GetBestMainchainBlockHash.
-func (c *truthcoinServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return c.getBestMainchainBlockHash.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetBlock is not implemented")
 }
 
-// GetBestSidechainBlockHash calls truthcoin.v1.TruthcoinService.GetBestSidechainBlockHash.
-func (c *truthcoinServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return c.getBestSidechainBlockHash.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetBestMainchainBlockHash is not implemented")
 }
 
-// GetBmmInclusions calls truthcoin.v1.TruthcoinService.GetBmmInclusions.
-func (c *truthcoinServiceClient) GetBmmInclusions(ctx context.Context, req *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return c.getBmmInclusions.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetBestSidechainBlockHash is not implemented")
 }
 
-// GetWalletUtxos calls truthcoin.v1.TruthcoinService.GetWalletUtxos.
-func (c *truthcoinServiceClient) GetWalletUtxos(ctx context.Context, req *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return c.getWalletUtxos.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetBmmInclusions is not implemented")
 }
 
-// ListUtxos calls truthcoin.v1.TruthcoinService.ListUtxos.
-func (c *truthcoinServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetWalletUtxos is not implemented")
 }
 
-// RemoveFromMempool calls truthcoin.v1.TruthcoinService.RemoveFromMempool.
-func (c *truthcoinServiceClient) RemoveFromMempool(ctx context.Context, req *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return c.removeFromMempool.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.ListUtxos is not implemented")
 }
 
-// GetLatestFailedWithdrawalBundleHeight calls
-// truthcoin.v1.TruthcoinService.GetLatestFailedWithdrawalBundleHeight.
-func (c *truthcoinServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return c.getLatestFailedWithdrawalBundleHeight.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.RemoveFromMempool is not implemented")
 }
 
-// GenerateMnemonic calls truthcoin.v1.TruthcoinService.GenerateMnemonic.
-func (c *truthcoinServiceClient) GenerateMnemonic(ctx context.Context, req *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return c.generateMnemonic.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetLatestFailedWithdrawalBundleHeight is not implemented")
 }
 
-// SetSeedFromMnemonic calls truthcoin.v1.TruthcoinService.SetSeedFromMnemonic.
-func (c *truthcoinServiceClient) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return c.setSeedFromMnemonic.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GenerateMnemonic is not implemented")
 }
 
-// CallRaw calls truthcoin.v1.TruthcoinService.CallRaw.
-func (c *truthcoinServiceClient) CallRaw(ctx context.Context, req *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return c.callRaw.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SetSeedFromMnemonic is not implemented")
 }
 
-// RefreshWallet calls truthcoin.v1.TruthcoinService.RefreshWallet.
-func (c *truthcoinServiceClient) RefreshWallet(ctx context.Context, req *connect.Request[v1.RefreshWalletRequest]) (*connect.Response[v1.RefreshWalletResponse], error) {
-	return c.refreshWallet.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.CallRaw is not implemented")
 }
 
-// GetTransaction calls truthcoin.v1.TruthcoinService.GetTransaction.
-func (c *truthcoinServiceClient) GetTransaction(ctx context.Context, req *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error) {
-	return c.getTransaction.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) RefreshWallet(context.Context, *v1.RefreshWalletRequest) (*v1.RefreshWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.RefreshWallet is not implemented")
 }
 
-// GetTransactionInfo calls truthcoin.v1.TruthcoinService.GetTransactionInfo.
-func (c *truthcoinServiceClient) GetTransactionInfo(ctx context.Context, req *connect.Request[v1.GetTransactionInfoRequest]) (*connect.Response[v1.GetTransactionInfoResponse], error) {
-	return c.getTransactionInfo.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetTransaction(context.Context, *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetTransaction is not implemented")
 }
 
-// GetWalletAddresses calls truthcoin.v1.TruthcoinService.GetWalletAddresses.
-func (c *truthcoinServiceClient) GetWalletAddresses(ctx context.Context, req *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return c.getWalletAddresses.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetTransactionInfo(context.Context, *v1.GetTransactionInfoRequest) (*v1.GetTransactionInfoResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetTransactionInfo is not implemented")
 }
 
-// MyUtxos calls truthcoin.v1.TruthcoinService.MyUtxos.
-func (c *truthcoinServiceClient) MyUtxos(ctx context.Context, req *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error) {
-	return c.myUtxos.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetWalletAddresses(context.Context, *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetWalletAddresses is not implemented")
 }
 
-// MyUnconfirmedUtxos calls truthcoin.v1.TruthcoinService.MyUnconfirmedUtxos.
-func (c *truthcoinServiceClient) MyUnconfirmedUtxos(ctx context.Context, req *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error) {
-	return c.myUnconfirmedUtxos.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MyUtxos(context.Context, *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MyUtxos is not implemented")
 }
 
-// CalculateInitialLiquidity calls truthcoin.v1.TruthcoinService.CalculateInitialLiquidity.
-func (c *truthcoinServiceClient) CalculateInitialLiquidity(ctx context.Context, req *connect.Request[v1.CalculateInitialLiquidityRequest]) (*connect.Response[v1.CalculateInitialLiquidityResponse], error) {
-	return c.calculateInitialLiquidity.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MyUnconfirmedUtxos(context.Context, *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MyUnconfirmedUtxos is not implemented")
 }
 
-// MarketCreate calls truthcoin.v1.TruthcoinService.MarketCreate.
-func (c *truthcoinServiceClient) MarketCreate(ctx context.Context, req *connect.Request[v1.MarketCreateRequest]) (*connect.Response[v1.MarketCreateResponse], error) {
-	return c.marketCreate.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) CalculateInitialLiquidity(context.Context, *v1.CalculateInitialLiquidityRequest) (*v1.CalculateInitialLiquidityResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.CalculateInitialLiquidity is not implemented")
 }
 
-// MarketList calls truthcoin.v1.TruthcoinService.MarketList.
-func (c *truthcoinServiceClient) MarketList(ctx context.Context, req *connect.Request[v1.MarketListRequest]) (*connect.Response[v1.MarketListResponse], error) {
-	return c.marketList.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MarketCreate(context.Context, *v1.MarketCreateRequest) (*v1.MarketCreateResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MarketCreate is not implemented")
 }
 
-// MarketGet calls truthcoin.v1.TruthcoinService.MarketGet.
-func (c *truthcoinServiceClient) MarketGet(ctx context.Context, req *connect.Request[v1.MarketGetRequest]) (*connect.Response[v1.MarketGetResponse], error) {
-	return c.marketGet.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MarketList(context.Context, *v1.MarketListRequest) (*v1.MarketListResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MarketList is not implemented")
 }
 
-// MarketBuy calls truthcoin.v1.TruthcoinService.MarketBuy.
-func (c *truthcoinServiceClient) MarketBuy(ctx context.Context, req *connect.Request[v1.MarketBuyRequest]) (*connect.Response[v1.MarketBuyResponse], error) {
-	return c.marketBuy.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MarketGet(context.Context, *v1.MarketGetRequest) (*v1.MarketGetResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MarketGet is not implemented")
 }
 
-// MarketSell calls truthcoin.v1.TruthcoinService.MarketSell.
-func (c *truthcoinServiceClient) MarketSell(ctx context.Context, req *connect.Request[v1.MarketSellRequest]) (*connect.Response[v1.MarketSellResponse], error) {
-	return c.marketSell.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MarketBuy(context.Context, *v1.MarketBuyRequest) (*v1.MarketBuyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MarketBuy is not implemented")
 }
 
-// MarketPositions calls truthcoin.v1.TruthcoinService.MarketPositions.
-func (c *truthcoinServiceClient) MarketPositions(ctx context.Context, req *connect.Request[v1.MarketPositionsRequest]) (*connect.Response[v1.MarketPositionsResponse], error) {
-	return c.marketPositions.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MarketSell(context.Context, *v1.MarketSellRequest) (*v1.MarketSellResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MarketSell is not implemented")
 }
 
-// MarketAmplifyBeta calls truthcoin.v1.TruthcoinService.MarketAmplifyBeta.
-func (c *truthcoinServiceClient) MarketAmplifyBeta(ctx context.Context, req *connect.Request[v1.MarketAmplifyBetaRequest]) (*connect.Response[v1.MarketAmplifyBetaResponse], error) {
-	return c.marketAmplifyBeta.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MarketPositions(context.Context, *v1.MarketPositionsRequest) (*v1.MarketPositionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MarketPositions is not implemented")
 }
 
-// SlotStatus calls truthcoin.v1.TruthcoinService.SlotStatus.
-func (c *truthcoinServiceClient) SlotStatus(ctx context.Context, req *connect.Request[v1.SlotStatusRequest]) (*connect.Response[v1.SlotStatusResponse], error) {
-	return c.slotStatus.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) MarketAmplifyBeta(context.Context, *v1.MarketAmplifyBetaRequest) (*v1.MarketAmplifyBetaResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.MarketAmplifyBeta is not implemented")
 }
 
-// SlotList calls truthcoin.v1.TruthcoinService.SlotList.
-func (c *truthcoinServiceClient) SlotList(ctx context.Context, req *connect.Request[v1.SlotListRequest]) (*connect.Response[v1.SlotListResponse], error) {
-	return c.slotList.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SlotStatus(context.Context, *v1.SlotStatusRequest) (*v1.SlotStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SlotStatus is not implemented")
 }
 
-// SlotGet calls truthcoin.v1.TruthcoinService.SlotGet.
-func (c *truthcoinServiceClient) SlotGet(ctx context.Context, req *connect.Request[v1.SlotGetRequest]) (*connect.Response[v1.SlotGetResponse], error) {
-	return c.slotGet.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SlotList(context.Context, *v1.SlotListRequest) (*v1.SlotListResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SlotList is not implemented")
 }
 
-// SlotClaim calls truthcoin.v1.TruthcoinService.SlotClaim.
-func (c *truthcoinServiceClient) SlotClaim(ctx context.Context, req *connect.Request[v1.SlotClaimRequest]) (*connect.Response[v1.SlotClaimResponse], error) {
-	return c.slotClaim.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SlotGet(context.Context, *v1.SlotGetRequest) (*v1.SlotGetResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SlotGet is not implemented")
 }
 
-// SlotClaimCategory calls truthcoin.v1.TruthcoinService.SlotClaimCategory.
-func (c *truthcoinServiceClient) SlotClaimCategory(ctx context.Context, req *connect.Request[v1.SlotClaimCategoryRequest]) (*connect.Response[v1.SlotClaimCategoryResponse], error) {
-	return c.slotClaimCategory.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SlotClaim(context.Context, *v1.SlotClaimRequest) (*v1.SlotClaimResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SlotClaim is not implemented")
 }
 
-// GetVoterAddress calls truthcoin.v1.TruthcoinService.GetVoterAddress.
-func (c *truthcoinServiceClient) GetVoterAddress(ctx context.Context, req *connect.Request[v1.GetVoterAddressRequest]) (*connect.Response[v1.GetVoterAddressResponse], error) {
-	return c.getVoterAddress.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SlotClaimCategory(context.Context, *v1.SlotClaimCategoryRequest) (*v1.SlotClaimCategoryResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SlotClaimCategory is not implemented")
 }
 
-// VoteVoter calls truthcoin.v1.TruthcoinService.VoteVoter.
-func (c *truthcoinServiceClient) VoteVoter(ctx context.Context, req *connect.Request[v1.VoteVoterRequest]) (*connect.Response[v1.VoteVoterResponse], error) {
-	return c.voteVoter.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetVoterAddress(context.Context, *v1.GetVoterAddressRequest) (*v1.GetVoterAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetVoterAddress is not implemented")
 }
 
-// VoteVoters calls truthcoin.v1.TruthcoinService.VoteVoters.
-func (c *truthcoinServiceClient) VoteVoters(ctx context.Context, req *connect.Request[v1.VoteVotersRequest]) (*connect.Response[v1.VoteVotersResponse], error) {
-	return c.voteVoters.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) VoteVoter(context.Context, *v1.VoteVoterRequest) (*v1.VoteVoterResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VoteVoter is not implemented")
 }
 
-// VoteSubmit calls truthcoin.v1.TruthcoinService.VoteSubmit.
-func (c *truthcoinServiceClient) VoteSubmit(ctx context.Context, req *connect.Request[v1.VoteSubmitRequest]) (*connect.Response[v1.VoteSubmitResponse], error) {
-	return c.voteSubmit.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) VoteVoters(context.Context, *v1.VoteVotersRequest) (*v1.VoteVotersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VoteVoters is not implemented")
 }
 
-// VoteList calls truthcoin.v1.TruthcoinService.VoteList.
-func (c *truthcoinServiceClient) VoteList(ctx context.Context, req *connect.Request[v1.VoteListRequest]) (*connect.Response[v1.VoteListResponse], error) {
-	return c.voteList.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) VoteSubmit(context.Context, *v1.VoteSubmitRequest) (*v1.VoteSubmitResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VoteSubmit is not implemented")
 }
 
-// VotePeriod calls truthcoin.v1.TruthcoinService.VotePeriod.
-func (c *truthcoinServiceClient) VotePeriod(ctx context.Context, req *connect.Request[v1.VotePeriodRequest]) (*connect.Response[v1.VotePeriodResponse], error) {
-	return c.votePeriod.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) VoteList(context.Context, *v1.VoteListRequest) (*v1.VoteListResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VoteList is not implemented")
 }
 
-// VotecoinTransfer calls truthcoin.v1.TruthcoinService.VotecoinTransfer.
-func (c *truthcoinServiceClient) VotecoinTransfer(ctx context.Context, req *connect.Request[v1.VotecoinTransferRequest]) (*connect.Response[v1.VotecoinTransferResponse], error) {
-	return c.votecoinTransfer.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) VotePeriod(context.Context, *v1.VotePeriodRequest) (*v1.VotePeriodResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VotePeriod is not implemented")
 }
 
-// VotecoinBalance calls truthcoin.v1.TruthcoinService.VotecoinBalance.
-func (c *truthcoinServiceClient) VotecoinBalance(ctx context.Context, req *connect.Request[v1.VotecoinBalanceRequest]) (*connect.Response[v1.VotecoinBalanceResponse], error) {
-	return c.votecoinBalance.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) VotecoinTransfer(context.Context, *v1.VotecoinTransferRequest) (*v1.VotecoinTransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VotecoinTransfer is not implemented")
 }
 
-// TransferVotecoin calls truthcoin.v1.TruthcoinService.TransferVotecoin.
-func (c *truthcoinServiceClient) TransferVotecoin(ctx context.Context, req *connect.Request[v1.TransferVotecoinRequest]) (*connect.Response[v1.TransferVotecoinResponse], error) {
-	return c.transferVotecoin.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) VotecoinBalance(context.Context, *v1.VotecoinBalanceRequest) (*v1.VotecoinBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VotecoinBalance is not implemented")
 }
 
-// GetNewEncryptionKey calls truthcoin.v1.TruthcoinService.GetNewEncryptionKey.
-func (c *truthcoinServiceClient) GetNewEncryptionKey(ctx context.Context, req *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error) {
-	return c.getNewEncryptionKey.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) TransferVotecoin(context.Context, *v1.TransferVotecoinRequest) (*v1.TransferVotecoinResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.TransferVotecoin is not implemented")
 }
 
-// GetNewVerifyingKey calls truthcoin.v1.TruthcoinService.GetNewVerifyingKey.
-func (c *truthcoinServiceClient) GetNewVerifyingKey(ctx context.Context, req *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error) {
-	return c.getNewVerifyingKey.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetNewEncryptionKey(context.Context, *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetNewEncryptionKey is not implemented")
 }
 
-// EncryptMsg calls truthcoin.v1.TruthcoinService.EncryptMsg.
-func (c *truthcoinServiceClient) EncryptMsg(ctx context.Context, req *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error) {
-	return c.encryptMsg.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) GetNewVerifyingKey(context.Context, *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.GetNewVerifyingKey is not implemented")
 }
 
-// DecryptMsg calls truthcoin.v1.TruthcoinService.DecryptMsg.
-func (c *truthcoinServiceClient) DecryptMsg(ctx context.Context, req *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error) {
-	return c.decryptMsg.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) EncryptMsg(context.Context, *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.EncryptMsg is not implemented")
 }
 
-// SignArbitraryMsg calls truthcoin.v1.TruthcoinService.SignArbitraryMsg.
-func (c *truthcoinServiceClient) SignArbitraryMsg(ctx context.Context, req *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error) {
-	return c.signArbitraryMsg.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) DecryptMsg(context.Context, *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.DecryptMsg is not implemented")
 }
 
-// SignArbitraryMsgAsAddr calls truthcoin.v1.TruthcoinService.SignArbitraryMsgAsAddr.
-func (c *truthcoinServiceClient) SignArbitraryMsgAsAddr(ctx context.Context, req *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error) {
-	return c.signArbitraryMsgAsAddr.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SignArbitraryMsg(context.Context, *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SignArbitraryMsg is not implemented")
 }
 
-// VerifySignature calls truthcoin.v1.TruthcoinService.VerifySignature.
-func (c *truthcoinServiceClient) VerifySignature(ctx context.Context, req *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error) {
-	return c.verifySignature.CallUnary(ctx, req)
+func (UnimplementedTruthcoinServiceHandler) SignArbitraryMsgAsAddr(context.Context, *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.SignArbitraryMsgAsAddr is not implemented")
 }
 
-// TruthcoinServiceHandler is an implementation of the truthcoin.v1.TruthcoinService service.
-type TruthcoinServiceHandler interface {
-	// Get wallet balance (total and available).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the truthcoin node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Get a new address from the wallet.
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain.
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Refresh wallet state.
-	RefreshWallet(context.Context, *connect.Request[v1.RefreshWalletRequest]) (*connect.Response[v1.RefreshWalletResponse], error)
-	// Get transaction by txid.
-	GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error)
-	// Get transaction info.
-	GetTransactionInfo(context.Context, *connect.Request[v1.GetTransactionInfoRequest]) (*connect.Response[v1.GetTransactionInfoResponse], error)
-	// Get wallet addresses.
-	GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error)
-	// Get owned UTXOs (confirmed).
-	MyUtxos(context.Context, *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error)
-	// Get owned UTXOs (unconfirmed).
-	MyUnconfirmedUtxos(context.Context, *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error)
-	// Calculate initial liquidity required for market creation.
-	CalculateInitialLiquidity(context.Context, *connect.Request[v1.CalculateInitialLiquidityRequest]) (*connect.Response[v1.CalculateInitialLiquidityResponse], error)
-	// Create a new prediction market.
-	MarketCreate(context.Context, *connect.Request[v1.MarketCreateRequest]) (*connect.Response[v1.MarketCreateResponse], error)
-	// List all markets.
-	MarketList(context.Context, *connect.Request[v1.MarketListRequest]) (*connect.Response[v1.MarketListResponse], error)
-	// Get a specific market.
-	MarketGet(context.Context, *connect.Request[v1.MarketGetRequest]) (*connect.Response[v1.MarketGetResponse], error)
-	// Buy shares in a market.
-	MarketBuy(context.Context, *connect.Request[v1.MarketBuyRequest]) (*connect.Response[v1.MarketBuyResponse], error)
-	// Sell shares in a market.
-	MarketSell(context.Context, *connect.Request[v1.MarketSellRequest]) (*connect.Response[v1.MarketSellResponse], error)
-	// Get positions in a market.
-	MarketPositions(context.Context, *connect.Request[v1.MarketPositionsRequest]) (*connect.Response[v1.MarketPositionsResponse], error)
-	// Add liquidity to a market that a wallet address created.
-	MarketAmplifyBeta(context.Context, *connect.Request[v1.MarketAmplifyBetaRequest]) (*connect.Response[v1.MarketAmplifyBetaResponse], error)
-	// Get slot system status and configuration.
-	SlotStatus(context.Context, *connect.Request[v1.SlotStatusRequest]) (*connect.Response[v1.SlotStatusResponse], error)
-	// List slots with optional filtering.
-	SlotList(context.Context, *connect.Request[v1.SlotListRequest]) (*connect.Response[v1.SlotListResponse], error)
-	// Get a specific slot by ID.
-	SlotGet(context.Context, *connect.Request[v1.SlotGetRequest]) (*connect.Response[v1.SlotGetResponse], error)
-	// Claim a decision slot.
-	SlotClaim(context.Context, *connect.Request[v1.SlotClaimRequest]) (*connect.Response[v1.SlotClaimResponse], error)
-	// Claim multiple slots as a category.
-	SlotClaimCategory(context.Context, *connect.Request[v1.SlotClaimCategoryRequest]) (*connect.Response[v1.SlotClaimCategoryResponse], error)
-	// Get the voter address of the wallet.
-	GetVoterAddress(context.Context, *connect.Request[v1.GetVoterAddressRequest]) (*connect.Response[v1.GetVoterAddressResponse], error)
-	// Get voter info.
-	VoteVoter(context.Context, *connect.Request[v1.VoteVoterRequest]) (*connect.Response[v1.VoteVoterResponse], error)
-	// List all voters.
-	VoteVoters(context.Context, *connect.Request[v1.VoteVotersRequest]) (*connect.Response[v1.VoteVotersResponse], error)
-	// Submit votes (batch).
-	VoteSubmit(context.Context, *connect.Request[v1.VoteSubmitRequest]) (*connect.Response[v1.VoteSubmitResponse], error)
-	// List votes with optional filters.
-	VoteList(context.Context, *connect.Request[v1.VoteListRequest]) (*connect.Response[v1.VoteListResponse], error)
-	// Get voting period information.
-	VotePeriod(context.Context, *connect.Request[v1.VotePeriodRequest]) (*connect.Response[v1.VotePeriodResponse], error)
-	// Transfer votecoins.
-	VotecoinTransfer(context.Context, *connect.Request[v1.VotecoinTransferRequest]) (*connect.Response[v1.VotecoinTransferResponse], error)
-	// Get votecoin balance for an address.
-	VotecoinBalance(context.Context, *connect.Request[v1.VotecoinBalanceRequest]) (*connect.Response[v1.VotecoinBalanceResponse], error)
-	// Transfer votecoin (alternative method).
-	TransferVotecoin(context.Context, *connect.Request[v1.TransferVotecoinRequest]) (*connect.Response[v1.TransferVotecoinResponse], error)
-	// Get a new encryption key.
-	GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error)
-	// Get a new verifying key.
-	GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error)
-	// Encrypt a message.
-	EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error)
-	// Decrypt a message.
-	DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error)
-	// Sign an arbitrary message with verifying key.
-	SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error)
-	// Sign an arbitrary message as address.
-	SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error)
-	// Verify a signature.
-	VerifySignature(context.Context, *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error)
-}
-
-// NewTruthcoinServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewTruthcoinServiceHandler(svc TruthcoinServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	truthcoinServiceMethods := v1.File_truthcoin_v1_truthcoin_proto.Services().ByName("TruthcoinService").Methods()
-	truthcoinServiceGetBalanceHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceStopHandler := connect.NewUnaryHandler(
-		TruthcoinServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(truthcoinServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceWithdrawHandler := connect.NewUnaryHandler(
-		TruthcoinServiceWithdrawProcedure,
-		svc.Withdraw,
-		connect.WithSchema(truthcoinServiceMethods.ByName("Withdraw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceTransferHandler := connect.NewUnaryHandler(
-		TruthcoinServiceTransferProcedure,
-		svc.Transfer,
-		connect.WithSchema(truthcoinServiceMethods.ByName("Transfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetSidechainWealthHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetSidechainWealthProcedure,
-		svc.GetSidechainWealth,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetSidechainWealth")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceCreateDepositHandler := connect.NewUnaryHandler(
-		TruthcoinServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(truthcoinServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetPendingWithdrawalBundleHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetPendingWithdrawalBundleProcedure,
-		svc.GetPendingWithdrawalBundle,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetPendingWithdrawalBundle")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceConnectPeerHandler := connect.NewUnaryHandler(
-		TruthcoinServiceConnectPeerProcedure,
-		svc.ConnectPeer,
-		connect.WithSchema(truthcoinServiceMethods.ByName("ConnectPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceListPeersHandler := connect.NewUnaryHandler(
-		TruthcoinServiceListPeersProcedure,
-		svc.ListPeers,
-		connect.WithSchema(truthcoinServiceMethods.ByName("ListPeers")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMineHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMineProcedure,
-		svc.Mine,
-		connect.WithSchema(truthcoinServiceMethods.ByName("Mine")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetBlockHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetBestMainchainBlockHashHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetBestMainchainBlockHashProcedure,
-		svc.GetBestMainchainBlockHash,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetBestMainchainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetBestSidechainBlockHashHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetBestSidechainBlockHashProcedure,
-		svc.GetBestSidechainBlockHash,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetBestSidechainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetBmmInclusionsHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetBmmInclusionsProcedure,
-		svc.GetBmmInclusions,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetBmmInclusions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetWalletUtxosHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetWalletUtxosProcedure,
-		svc.GetWalletUtxos,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetWalletUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceListUtxosHandler := connect.NewUnaryHandler(
-		TruthcoinServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(truthcoinServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceRemoveFromMempoolHandler := connect.NewUnaryHandler(
-		TruthcoinServiceRemoveFromMempoolProcedure,
-		svc.RemoveFromMempool,
-		connect.WithSchema(truthcoinServiceMethods.ByName("RemoveFromMempool")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetLatestFailedWithdrawalBundleHeightHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-		svc.GetLatestFailedWithdrawalBundleHeight,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGenerateMnemonicHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGenerateMnemonicProcedure,
-		svc.GenerateMnemonic,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GenerateMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSetSeedFromMnemonicHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSetSeedFromMnemonicProcedure,
-		svc.SetSeedFromMnemonic,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SetSeedFromMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceCallRawHandler := connect.NewUnaryHandler(
-		TruthcoinServiceCallRawProcedure,
-		svc.CallRaw,
-		connect.WithSchema(truthcoinServiceMethods.ByName("CallRaw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceRefreshWalletHandler := connect.NewUnaryHandler(
-		TruthcoinServiceRefreshWalletProcedure,
-		svc.RefreshWallet,
-		connect.WithSchema(truthcoinServiceMethods.ByName("RefreshWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetTransactionHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetTransactionProcedure,
-		svc.GetTransaction,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetTransactionInfoHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetTransactionInfoProcedure,
-		svc.GetTransactionInfo,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetTransactionInfo")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetWalletAddressesHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetWalletAddressesProcedure,
-		svc.GetWalletAddresses,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetWalletAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMyUtxosHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMyUtxosProcedure,
-		svc.MyUtxos,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MyUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMyUnconfirmedUtxosHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMyUnconfirmedUtxosProcedure,
-		svc.MyUnconfirmedUtxos,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MyUnconfirmedUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceCalculateInitialLiquidityHandler := connect.NewUnaryHandler(
-		TruthcoinServiceCalculateInitialLiquidityProcedure,
-		svc.CalculateInitialLiquidity,
-		connect.WithSchema(truthcoinServiceMethods.ByName("CalculateInitialLiquidity")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMarketCreateHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMarketCreateProcedure,
-		svc.MarketCreate,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MarketCreate")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMarketListHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMarketListProcedure,
-		svc.MarketList,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MarketList")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMarketGetHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMarketGetProcedure,
-		svc.MarketGet,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MarketGet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMarketBuyHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMarketBuyProcedure,
-		svc.MarketBuy,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MarketBuy")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMarketSellHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMarketSellProcedure,
-		svc.MarketSell,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MarketSell")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMarketPositionsHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMarketPositionsProcedure,
-		svc.MarketPositions,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MarketPositions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceMarketAmplifyBetaHandler := connect.NewUnaryHandler(
-		TruthcoinServiceMarketAmplifyBetaProcedure,
-		svc.MarketAmplifyBeta,
-		connect.WithSchema(truthcoinServiceMethods.ByName("MarketAmplifyBeta")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSlotStatusHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSlotStatusProcedure,
-		svc.SlotStatus,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SlotStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSlotListHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSlotListProcedure,
-		svc.SlotList,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SlotList")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSlotGetHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSlotGetProcedure,
-		svc.SlotGet,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SlotGet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSlotClaimHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSlotClaimProcedure,
-		svc.SlotClaim,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SlotClaim")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSlotClaimCategoryHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSlotClaimCategoryProcedure,
-		svc.SlotClaimCategory,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SlotClaimCategory")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetVoterAddressHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetVoterAddressProcedure,
-		svc.GetVoterAddress,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetVoterAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVoteVoterHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVoteVoterProcedure,
-		svc.VoteVoter,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VoteVoter")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVoteVotersHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVoteVotersProcedure,
-		svc.VoteVoters,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VoteVoters")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVoteSubmitHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVoteSubmitProcedure,
-		svc.VoteSubmit,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VoteSubmit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVoteListHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVoteListProcedure,
-		svc.VoteList,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VoteList")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVotePeriodHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVotePeriodProcedure,
-		svc.VotePeriod,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VotePeriod")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVotecoinTransferHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVotecoinTransferProcedure,
-		svc.VotecoinTransfer,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VotecoinTransfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVotecoinBalanceHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVotecoinBalanceProcedure,
-		svc.VotecoinBalance,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VotecoinBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceTransferVotecoinHandler := connect.NewUnaryHandler(
-		TruthcoinServiceTransferVotecoinProcedure,
-		svc.TransferVotecoin,
-		connect.WithSchema(truthcoinServiceMethods.ByName("TransferVotecoin")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetNewEncryptionKeyHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetNewEncryptionKeyProcedure,
-		svc.GetNewEncryptionKey,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetNewEncryptionKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceGetNewVerifyingKeyHandler := connect.NewUnaryHandler(
-		TruthcoinServiceGetNewVerifyingKeyProcedure,
-		svc.GetNewVerifyingKey,
-		connect.WithSchema(truthcoinServiceMethods.ByName("GetNewVerifyingKey")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceEncryptMsgHandler := connect.NewUnaryHandler(
-		TruthcoinServiceEncryptMsgProcedure,
-		svc.EncryptMsg,
-		connect.WithSchema(truthcoinServiceMethods.ByName("EncryptMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceDecryptMsgHandler := connect.NewUnaryHandler(
-		TruthcoinServiceDecryptMsgProcedure,
-		svc.DecryptMsg,
-		connect.WithSchema(truthcoinServiceMethods.ByName("DecryptMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSignArbitraryMsgHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSignArbitraryMsgProcedure,
-		svc.SignArbitraryMsg,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SignArbitraryMsg")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceSignArbitraryMsgAsAddrHandler := connect.NewUnaryHandler(
-		TruthcoinServiceSignArbitraryMsgAsAddrProcedure,
-		svc.SignArbitraryMsgAsAddr,
-		connect.WithSchema(truthcoinServiceMethods.ByName("SignArbitraryMsgAsAddr")),
-		connect.WithHandlerOptions(opts...),
-	)
-	truthcoinServiceVerifySignatureHandler := connect.NewUnaryHandler(
-		TruthcoinServiceVerifySignatureProcedure,
-		svc.VerifySignature,
-		connect.WithSchema(truthcoinServiceMethods.ByName("VerifySignature")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/truthcoin.v1.TruthcoinService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case TruthcoinServiceGetBalanceProcedure:
-			truthcoinServiceGetBalanceHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetBlockCountProcedure:
-			truthcoinServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case TruthcoinServiceStopProcedure:
-			truthcoinServiceStopHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetNewAddressProcedure:
-			truthcoinServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case TruthcoinServiceWithdrawProcedure:
-			truthcoinServiceWithdrawHandler.ServeHTTP(w, r)
-		case TruthcoinServiceTransferProcedure:
-			truthcoinServiceTransferHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetSidechainWealthProcedure:
-			truthcoinServiceGetSidechainWealthHandler.ServeHTTP(w, r)
-		case TruthcoinServiceCreateDepositProcedure:
-			truthcoinServiceCreateDepositHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetPendingWithdrawalBundleProcedure:
-			truthcoinServiceGetPendingWithdrawalBundleHandler.ServeHTTP(w, r)
-		case TruthcoinServiceConnectPeerProcedure:
-			truthcoinServiceConnectPeerHandler.ServeHTTP(w, r)
-		case TruthcoinServiceListPeersProcedure:
-			truthcoinServiceListPeersHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMineProcedure:
-			truthcoinServiceMineHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetBlockProcedure:
-			truthcoinServiceGetBlockHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetBestMainchainBlockHashProcedure:
-			truthcoinServiceGetBestMainchainBlockHashHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetBestSidechainBlockHashProcedure:
-			truthcoinServiceGetBestSidechainBlockHashHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetBmmInclusionsProcedure:
-			truthcoinServiceGetBmmInclusionsHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetWalletUtxosProcedure:
-			truthcoinServiceGetWalletUtxosHandler.ServeHTTP(w, r)
-		case TruthcoinServiceListUtxosProcedure:
-			truthcoinServiceListUtxosHandler.ServeHTTP(w, r)
-		case TruthcoinServiceRemoveFromMempoolProcedure:
-			truthcoinServiceRemoveFromMempoolHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetLatestFailedWithdrawalBundleHeightProcedure:
-			truthcoinServiceGetLatestFailedWithdrawalBundleHeightHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGenerateMnemonicProcedure:
-			truthcoinServiceGenerateMnemonicHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSetSeedFromMnemonicProcedure:
-			truthcoinServiceSetSeedFromMnemonicHandler.ServeHTTP(w, r)
-		case TruthcoinServiceCallRawProcedure:
-			truthcoinServiceCallRawHandler.ServeHTTP(w, r)
-		case TruthcoinServiceRefreshWalletProcedure:
-			truthcoinServiceRefreshWalletHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetTransactionProcedure:
-			truthcoinServiceGetTransactionHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetTransactionInfoProcedure:
-			truthcoinServiceGetTransactionInfoHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetWalletAddressesProcedure:
-			truthcoinServiceGetWalletAddressesHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMyUtxosProcedure:
-			truthcoinServiceMyUtxosHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMyUnconfirmedUtxosProcedure:
-			truthcoinServiceMyUnconfirmedUtxosHandler.ServeHTTP(w, r)
-		case TruthcoinServiceCalculateInitialLiquidityProcedure:
-			truthcoinServiceCalculateInitialLiquidityHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMarketCreateProcedure:
-			truthcoinServiceMarketCreateHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMarketListProcedure:
-			truthcoinServiceMarketListHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMarketGetProcedure:
-			truthcoinServiceMarketGetHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMarketBuyProcedure:
-			truthcoinServiceMarketBuyHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMarketSellProcedure:
-			truthcoinServiceMarketSellHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMarketPositionsProcedure:
-			truthcoinServiceMarketPositionsHandler.ServeHTTP(w, r)
-		case TruthcoinServiceMarketAmplifyBetaProcedure:
-			truthcoinServiceMarketAmplifyBetaHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSlotStatusProcedure:
-			truthcoinServiceSlotStatusHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSlotListProcedure:
-			truthcoinServiceSlotListHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSlotGetProcedure:
-			truthcoinServiceSlotGetHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSlotClaimProcedure:
-			truthcoinServiceSlotClaimHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSlotClaimCategoryProcedure:
-			truthcoinServiceSlotClaimCategoryHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetVoterAddressProcedure:
-			truthcoinServiceGetVoterAddressHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVoteVoterProcedure:
-			truthcoinServiceVoteVoterHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVoteVotersProcedure:
-			truthcoinServiceVoteVotersHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVoteSubmitProcedure:
-			truthcoinServiceVoteSubmitHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVoteListProcedure:
-			truthcoinServiceVoteListHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVotePeriodProcedure:
-			truthcoinServiceVotePeriodHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVotecoinTransferProcedure:
-			truthcoinServiceVotecoinTransferHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVotecoinBalanceProcedure:
-			truthcoinServiceVotecoinBalanceHandler.ServeHTTP(w, r)
-		case TruthcoinServiceTransferVotecoinProcedure:
-			truthcoinServiceTransferVotecoinHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetNewEncryptionKeyProcedure:
-			truthcoinServiceGetNewEncryptionKeyHandler.ServeHTTP(w, r)
-		case TruthcoinServiceGetNewVerifyingKeyProcedure:
-			truthcoinServiceGetNewVerifyingKeyHandler.ServeHTTP(w, r)
-		case TruthcoinServiceEncryptMsgProcedure:
-			truthcoinServiceEncryptMsgHandler.ServeHTTP(w, r)
-		case TruthcoinServiceDecryptMsgProcedure:
-			truthcoinServiceDecryptMsgHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSignArbitraryMsgProcedure:
-			truthcoinServiceSignArbitraryMsgHandler.ServeHTTP(w, r)
-		case TruthcoinServiceSignArbitraryMsgAsAddrProcedure:
-			truthcoinServiceSignArbitraryMsgAsAddrHandler.ServeHTTP(w, r)
-		case TruthcoinServiceVerifySignatureProcedure:
-			truthcoinServiceVerifySignatureHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedTruthcoinServiceHandler) VerifySignature(context.Context, *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "truthcoin.v1.TruthcoinService.VerifySignature is not implemented")
 }
 
-// UnimplementedTruthcoinServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedTruthcoinServiceHandler struct{}
+type truthcoinServiceClient struct {
+	client *connect.Client
+}
 
-func (UnimplementedTruthcoinServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetBalance is not implemented"))
+func (c *truthcoinServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetBlockCount is not implemented"))
+func (c *truthcoinServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.Stop is not implemented"))
+func (c *truthcoinServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetNewAddress is not implemented"))
+func (c *truthcoinServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.Withdraw is not implemented"))
+func (c *truthcoinServiceClient) Withdraw(ctx context.Context, req *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	var res v1.WithdrawResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceWithdrawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.Transfer is not implemented"))
+func (c *truthcoinServiceClient) Transfer(ctx context.Context, req *v1.TransferRequest) (*v1.TransferResponse, error) {
+	var res v1.TransferResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetSidechainWealth is not implemented"))
+func (c *truthcoinServiceClient) GetSidechainWealth(ctx context.Context, req *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	var res v1.GetSidechainWealthResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetSidechainWealthSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.CreateDeposit is not implemented"))
+func (c *truthcoinServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetPendingWithdrawalBundle is not implemented"))
+func (c *truthcoinServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	var res v1.GetPendingWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetPendingWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.ConnectPeer is not implemented"))
+func (c *truthcoinServiceClient) ConnectPeer(ctx context.Context, req *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	var res v1.ConnectPeerResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceConnectPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.ListPeers is not implemented"))
+func (c *truthcoinServiceClient) ListPeers(ctx context.Context, req *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	var res v1.ListPeersResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceListPeersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.Mine is not implemented"))
+func (c *truthcoinServiceClient) Mine(ctx context.Context, req *v1.MineRequest) (*v1.MineResponse, error) {
+	var res v1.MineResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMineSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetBlock is not implemented"))
+func (c *truthcoinServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetBestMainchainBlockHash is not implemented"))
+func (c *truthcoinServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	var res v1.GetBestMainchainBlockHashResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetBestMainchainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetBestSidechainBlockHash is not implemented"))
+func (c *truthcoinServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	var res v1.GetBestSidechainBlockHashResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetBestSidechainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetBmmInclusions is not implemented"))
+func (c *truthcoinServiceClient) GetBmmInclusions(ctx context.Context, req *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	var res v1.GetBmmInclusionsResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetBmmInclusionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetWalletUtxos is not implemented"))
+func (c *truthcoinServiceClient) GetWalletUtxos(ctx context.Context, req *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	var res v1.GetWalletUtxosResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetWalletUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.ListUtxos is not implemented"))
+func (c *truthcoinServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.RemoveFromMempool is not implemented"))
+func (c *truthcoinServiceClient) RemoveFromMempool(ctx context.Context, req *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	var res v1.RemoveFromMempoolResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceRemoveFromMempoolSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetLatestFailedWithdrawalBundleHeight is not implemented"))
+func (c *truthcoinServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	var res v1.GetLatestFailedWithdrawalBundleHeightResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetLatestFailedWithdrawalBundleHeightSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GenerateMnemonic is not implemented"))
+func (c *truthcoinServiceClient) GenerateMnemonic(ctx context.Context, req *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	var res v1.GenerateMnemonicResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGenerateMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SetSeedFromMnemonic is not implemented"))
+func (c *truthcoinServiceClient) SetSeedFromMnemonic(ctx context.Context, req *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	var res v1.SetSeedFromMnemonicResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSetSeedFromMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.CallRaw is not implemented"))
+func (c *truthcoinServiceClient) CallRaw(ctx context.Context, req *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	var res v1.CallRawResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceCallRawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) RefreshWallet(context.Context, *connect.Request[v1.RefreshWalletRequest]) (*connect.Response[v1.RefreshWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.RefreshWallet is not implemented"))
+func (c *truthcoinServiceClient) RefreshWallet(ctx context.Context, req *v1.RefreshWalletRequest) (*v1.RefreshWalletResponse, error) {
+	var res v1.RefreshWalletResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceRefreshWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetTransaction(context.Context, *connect.Request[v1.GetTransactionRequest]) (*connect.Response[v1.GetTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetTransaction is not implemented"))
+func (c *truthcoinServiceClient) GetTransaction(ctx context.Context, req *v1.GetTransactionRequest) (*v1.GetTransactionResponse, error) {
+	var res v1.GetTransactionResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetTransactionInfo(context.Context, *connect.Request[v1.GetTransactionInfoRequest]) (*connect.Response[v1.GetTransactionInfoResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetTransactionInfo is not implemented"))
+func (c *truthcoinServiceClient) GetTransactionInfo(ctx context.Context, req *v1.GetTransactionInfoRequest) (*v1.GetTransactionInfoResponse, error) {
+	var res v1.GetTransactionInfoResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetTransactionInfoSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetWalletAddresses(context.Context, *connect.Request[v1.GetWalletAddressesRequest]) (*connect.Response[v1.GetWalletAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetWalletAddresses is not implemented"))
+func (c *truthcoinServiceClient) GetWalletAddresses(ctx context.Context, req *v1.GetWalletAddressesRequest) (*v1.GetWalletAddressesResponse, error) {
+	var res v1.GetWalletAddressesResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetWalletAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MyUtxos(context.Context, *connect.Request[v1.MyUtxosRequest]) (*connect.Response[v1.MyUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MyUtxos is not implemented"))
+func (c *truthcoinServiceClient) MyUtxos(ctx context.Context, req *v1.MyUtxosRequest) (*v1.MyUtxosResponse, error) {
+	var res v1.MyUtxosResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMyUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MyUnconfirmedUtxos(context.Context, *connect.Request[v1.MyUnconfirmedUtxosRequest]) (*connect.Response[v1.MyUnconfirmedUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MyUnconfirmedUtxos is not implemented"))
+func (c *truthcoinServiceClient) MyUnconfirmedUtxos(ctx context.Context, req *v1.MyUnconfirmedUtxosRequest) (*v1.MyUnconfirmedUtxosResponse, error) {
+	var res v1.MyUnconfirmedUtxosResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMyUnconfirmedUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) CalculateInitialLiquidity(context.Context, *connect.Request[v1.CalculateInitialLiquidityRequest]) (*connect.Response[v1.CalculateInitialLiquidityResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.CalculateInitialLiquidity is not implemented"))
+func (c *truthcoinServiceClient) CalculateInitialLiquidity(ctx context.Context, req *v1.CalculateInitialLiquidityRequest) (*v1.CalculateInitialLiquidityResponse, error) {
+	var res v1.CalculateInitialLiquidityResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceCalculateInitialLiquiditySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MarketCreate(context.Context, *connect.Request[v1.MarketCreateRequest]) (*connect.Response[v1.MarketCreateResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MarketCreate is not implemented"))
+func (c *truthcoinServiceClient) MarketCreate(ctx context.Context, req *v1.MarketCreateRequest) (*v1.MarketCreateResponse, error) {
+	var res v1.MarketCreateResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMarketCreateSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MarketList(context.Context, *connect.Request[v1.MarketListRequest]) (*connect.Response[v1.MarketListResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MarketList is not implemented"))
+func (c *truthcoinServiceClient) MarketList(ctx context.Context, req *v1.MarketListRequest) (*v1.MarketListResponse, error) {
+	var res v1.MarketListResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMarketListSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MarketGet(context.Context, *connect.Request[v1.MarketGetRequest]) (*connect.Response[v1.MarketGetResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MarketGet is not implemented"))
+func (c *truthcoinServiceClient) MarketGet(ctx context.Context, req *v1.MarketGetRequest) (*v1.MarketGetResponse, error) {
+	var res v1.MarketGetResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMarketGetSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MarketBuy(context.Context, *connect.Request[v1.MarketBuyRequest]) (*connect.Response[v1.MarketBuyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MarketBuy is not implemented"))
+func (c *truthcoinServiceClient) MarketBuy(ctx context.Context, req *v1.MarketBuyRequest) (*v1.MarketBuyResponse, error) {
+	var res v1.MarketBuyResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMarketBuySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MarketSell(context.Context, *connect.Request[v1.MarketSellRequest]) (*connect.Response[v1.MarketSellResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MarketSell is not implemented"))
+func (c *truthcoinServiceClient) MarketSell(ctx context.Context, req *v1.MarketSellRequest) (*v1.MarketSellResponse, error) {
+	var res v1.MarketSellResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMarketSellSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MarketPositions(context.Context, *connect.Request[v1.MarketPositionsRequest]) (*connect.Response[v1.MarketPositionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MarketPositions is not implemented"))
+func (c *truthcoinServiceClient) MarketPositions(ctx context.Context, req *v1.MarketPositionsRequest) (*v1.MarketPositionsResponse, error) {
+	var res v1.MarketPositionsResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMarketPositionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) MarketAmplifyBeta(context.Context, *connect.Request[v1.MarketAmplifyBetaRequest]) (*connect.Response[v1.MarketAmplifyBetaResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.MarketAmplifyBeta is not implemented"))
+func (c *truthcoinServiceClient) MarketAmplifyBeta(ctx context.Context, req *v1.MarketAmplifyBetaRequest) (*v1.MarketAmplifyBetaResponse, error) {
+	var res v1.MarketAmplifyBetaResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceMarketAmplifyBetaSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) SlotStatus(context.Context, *connect.Request[v1.SlotStatusRequest]) (*connect.Response[v1.SlotStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SlotStatus is not implemented"))
+func (c *truthcoinServiceClient) SlotStatus(ctx context.Context, req *v1.SlotStatusRequest) (*v1.SlotStatusResponse, error) {
+	var res v1.SlotStatusResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSlotStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) SlotList(context.Context, *connect.Request[v1.SlotListRequest]) (*connect.Response[v1.SlotListResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SlotList is not implemented"))
+func (c *truthcoinServiceClient) SlotList(ctx context.Context, req *v1.SlotListRequest) (*v1.SlotListResponse, error) {
+	var res v1.SlotListResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSlotListSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) SlotGet(context.Context, *connect.Request[v1.SlotGetRequest]) (*connect.Response[v1.SlotGetResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SlotGet is not implemented"))
+func (c *truthcoinServiceClient) SlotGet(ctx context.Context, req *v1.SlotGetRequest) (*v1.SlotGetResponse, error) {
+	var res v1.SlotGetResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSlotGetSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedTruthcoinServiceHandler) SlotClaim(context.Context, *connect.Request[v1.SlotClaimRequest]) (*connect.Response[v1.SlotClaimResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SlotClaim is not implemented"))
+func (c *truthcoinServiceClient) SlotClaim(ctx context.Context, req *v1.SlotClaimRequest) (*v1.SlotClaimResponse, error) {
+	var res v1.SlotClaimResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSlotClaimSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) SlotClaimCategory(ctx context.Context, req *v1.SlotClaimCategoryRequest) (*v1.SlotClaimCategoryResponse, error) {
+	var res v1.SlotClaimCategoryResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSlotClaimCategorySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) GetVoterAddress(ctx context.Context, req *v1.GetVoterAddressRequest) (*v1.GetVoterAddressResponse, error) {
+	var res v1.GetVoterAddressResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetVoterAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VoteVoter(ctx context.Context, req *v1.VoteVoterRequest) (*v1.VoteVoterResponse, error) {
+	var res v1.VoteVoterResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVoteVoterSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VoteVoters(ctx context.Context, req *v1.VoteVotersRequest) (*v1.VoteVotersResponse, error) {
+	var res v1.VoteVotersResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVoteVotersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VoteSubmit(ctx context.Context, req *v1.VoteSubmitRequest) (*v1.VoteSubmitResponse, error) {
+	var res v1.VoteSubmitResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVoteSubmitSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VoteList(ctx context.Context, req *v1.VoteListRequest) (*v1.VoteListResponse, error) {
+	var res v1.VoteListResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVoteListSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VotePeriod(ctx context.Context, req *v1.VotePeriodRequest) (*v1.VotePeriodResponse, error) {
+	var res v1.VotePeriodResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVotePeriodSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VotecoinTransfer(ctx context.Context, req *v1.VotecoinTransferRequest) (*v1.VotecoinTransferResponse, error) {
+	var res v1.VotecoinTransferResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVotecoinTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VotecoinBalance(ctx context.Context, req *v1.VotecoinBalanceRequest) (*v1.VotecoinBalanceResponse, error) {
+	var res v1.VotecoinBalanceResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVotecoinBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) TransferVotecoin(ctx context.Context, req *v1.TransferVotecoinRequest) (*v1.TransferVotecoinResponse, error) {
+	var res v1.TransferVotecoinResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceTransferVotecoinSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) GetNewEncryptionKey(ctx context.Context, req *v1.GetNewEncryptionKeyRequest) (*v1.GetNewEncryptionKeyResponse, error) {
+	var res v1.GetNewEncryptionKeyResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetNewEncryptionKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) GetNewVerifyingKey(ctx context.Context, req *v1.GetNewVerifyingKeyRequest) (*v1.GetNewVerifyingKeyResponse, error) {
+	var res v1.GetNewVerifyingKeyResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceGetNewVerifyingKeySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) EncryptMsg(ctx context.Context, req *v1.EncryptMsgRequest) (*v1.EncryptMsgResponse, error) {
+	var res v1.EncryptMsgResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceEncryptMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) DecryptMsg(ctx context.Context, req *v1.DecryptMsgRequest) (*v1.DecryptMsgResponse, error) {
+	var res v1.DecryptMsgResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceDecryptMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) SignArbitraryMsg(ctx context.Context, req *v1.SignArbitraryMsgRequest) (*v1.SignArbitraryMsgResponse, error) {
+	var res v1.SignArbitraryMsgResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSignArbitraryMsgSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) SignArbitraryMsgAsAddr(ctx context.Context, req *v1.SignArbitraryMsgAsAddrRequest) (*v1.SignArbitraryMsgAsAddrResponse, error) {
+	var res v1.SignArbitraryMsgAsAddrResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceSignArbitraryMsgAsAddrSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *truthcoinServiceClient) VerifySignature(ctx context.Context, req *v1.VerifySignatureRequest) (*v1.VerifySignatureResponse, error) {
+	var res v1.VerifySignatureResponse
+	if err := c.client.CallUnary(ctx, truthcoinServiceVerifySignatureSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type truthcoinServiceHandler struct{ svc TruthcoinServiceHandler }
+
+func (h truthcoinServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) SlotClaimCategory(context.Context, *connect.Request[v1.SlotClaimCategoryRequest]) (*connect.Response[v1.SlotClaimCategoryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SlotClaimCategory is not implemented"))
+func (h truthcoinServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetVoterAddress(context.Context, *connect.Request[v1.GetVoterAddressRequest]) (*connect.Response[v1.GetVoterAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetVoterAddress is not implemented"))
+func (h truthcoinServiceHandler) withdraw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WithdrawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Withdraw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VoteVoter(context.Context, *connect.Request[v1.VoteVoterRequest]) (*connect.Response[v1.VoteVoterResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VoteVoter is not implemented"))
+func (h truthcoinServiceHandler) transfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Transfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VoteVoters(context.Context, *connect.Request[v1.VoteVotersRequest]) (*connect.Response[v1.VoteVotersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VoteVoters is not implemented"))
+func (h truthcoinServiceHandler) getSidechainWealth(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainWealthRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainWealth(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VoteSubmit(context.Context, *connect.Request[v1.VoteSubmitRequest]) (*connect.Response[v1.VoteSubmitResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VoteSubmit is not implemented"))
+func (h truthcoinServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VoteList(context.Context, *connect.Request[v1.VoteListRequest]) (*connect.Response[v1.VoteListResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VoteList is not implemented"))
+func (h truthcoinServiceHandler) getPendingWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VotePeriod(context.Context, *connect.Request[v1.VotePeriodRequest]) (*connect.Response[v1.VotePeriodResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VotePeriod is not implemented"))
+func (h truthcoinServiceHandler) connectPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VotecoinTransfer(context.Context, *connect.Request[v1.VotecoinTransferRequest]) (*connect.Response[v1.VotecoinTransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VotecoinTransfer is not implemented"))
+func (h truthcoinServiceHandler) listPeers(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPeersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPeers(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VotecoinBalance(context.Context, *connect.Request[v1.VotecoinBalanceRequest]) (*connect.Response[v1.VotecoinBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VotecoinBalance is not implemented"))
+func (h truthcoinServiceHandler) mine(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MineRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Mine(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) TransferVotecoin(context.Context, *connect.Request[v1.TransferVotecoinRequest]) (*connect.Response[v1.TransferVotecoinResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.TransferVotecoin is not implemented"))
+func (h truthcoinServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetNewEncryptionKey(context.Context, *connect.Request[v1.GetNewEncryptionKeyRequest]) (*connect.Response[v1.GetNewEncryptionKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetNewEncryptionKey is not implemented"))
+func (h truthcoinServiceHandler) getBestMainchainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestMainchainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestMainchainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) GetNewVerifyingKey(context.Context, *connect.Request[v1.GetNewVerifyingKeyRequest]) (*connect.Response[v1.GetNewVerifyingKeyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.GetNewVerifyingKey is not implemented"))
+func (h truthcoinServiceHandler) getBestSidechainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestSidechainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestSidechainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) EncryptMsg(context.Context, *connect.Request[v1.EncryptMsgRequest]) (*connect.Response[v1.EncryptMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.EncryptMsg is not implemented"))
+func (h truthcoinServiceHandler) getBmmInclusions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmInclusionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmInclusions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) DecryptMsg(context.Context, *connect.Request[v1.DecryptMsgRequest]) (*connect.Response[v1.DecryptMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.DecryptMsg is not implemented"))
+func (h truthcoinServiceHandler) getWalletUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) SignArbitraryMsg(context.Context, *connect.Request[v1.SignArbitraryMsgRequest]) (*connect.Response[v1.SignArbitraryMsgResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SignArbitraryMsg is not implemented"))
+func (h truthcoinServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) SignArbitraryMsgAsAddr(context.Context, *connect.Request[v1.SignArbitraryMsgAsAddrRequest]) (*connect.Response[v1.SignArbitraryMsgAsAddrResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.SignArbitraryMsgAsAddr is not implemented"))
+func (h truthcoinServiceHandler) removeFromMempool(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RemoveFromMempoolRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RemoveFromMempool(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getLatestFailedWithdrawalBundleHeight(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetLatestFailedWithdrawalBundleHeightRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetLatestFailedWithdrawalBundleHeight(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) generateMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) setSeedFromMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSeedFromMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSeedFromMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedTruthcoinServiceHandler) VerifySignature(context.Context, *connect.Request[v1.VerifySignatureRequest]) (*connect.Response[v1.VerifySignatureResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("truthcoin.v1.TruthcoinService.VerifySignature is not implemented"))
+func (h truthcoinServiceHandler) callRaw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CallRawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CallRaw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) refreshWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RefreshWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RefreshWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getTransactionInfo(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransactionInfoRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransactionInfo(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getWalletAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) myUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MyUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MyUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) myUnconfirmedUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MyUnconfirmedUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MyUnconfirmedUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) calculateInitialLiquidity(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CalculateInitialLiquidityRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CalculateInitialLiquidity(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) marketCreate(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MarketCreateRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MarketCreate(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) marketList(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MarketListRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MarketList(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) marketGet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MarketGetRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MarketGet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) marketBuy(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MarketBuyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MarketBuy(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) marketSell(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MarketSellRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MarketSell(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) marketPositions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MarketPositionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MarketPositions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) marketAmplifyBeta(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MarketAmplifyBetaRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MarketAmplifyBeta(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) slotStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SlotStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SlotStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) slotList(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SlotListRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SlotList(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) slotGet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SlotGetRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SlotGet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) slotClaim(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SlotClaimRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SlotClaim(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) slotClaimCategory(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SlotClaimCategoryRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SlotClaimCategory(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getVoterAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetVoterAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetVoterAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) voteVoter(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VoteVoterRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VoteVoter(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) voteVoters(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VoteVotersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VoteVoters(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) voteSubmit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VoteSubmitRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VoteSubmit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) voteList(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VoteListRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VoteList(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) votePeriod(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VotePeriodRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VotePeriod(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) votecoinTransfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VotecoinTransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VotecoinTransfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) votecoinBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VotecoinBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VotecoinBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) transferVotecoin(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferVotecoinRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.TransferVotecoin(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getNewEncryptionKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewEncryptionKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewEncryptionKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) getNewVerifyingKey(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewVerifyingKeyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewVerifyingKey(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) encryptMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EncryptMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EncryptMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) decryptMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DecryptMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DecryptMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) signArbitraryMsg(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignArbitraryMsgRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignArbitraryMsg(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) signArbitraryMsgAsAddr(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignArbitraryMsgAsAddrRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignArbitraryMsgAsAddr(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h truthcoinServiceHandler) verifySignature(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.VerifySignatureRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.VerifySignature(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect/walletmanager.connect.go b/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect/walletmanager.connect.go
index bb247083f0..c0ee34d463 100644
--- a/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect/walletmanager.connect.go
+++ b/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect/walletmanager.connect.go
@@ -5,2273 +5,2789 @@
 package walletmanagerv1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// WalletManagerServiceName is the fully-qualified name of the WalletManagerService service.
 	WalletManagerServiceName = "walletmanager.v1.WalletManagerService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// WalletManagerServiceGetWalletStatusProcedure is the fully-qualified name of the
-	// WalletManagerService's GetWalletStatus RPC.
+	// WalletManagerServiceGetWalletStatusProcedure is the procedure name of the WalletManagerService's
+	// GetWalletStatus RPC.
 	WalletManagerServiceGetWalletStatusProcedure = "/walletmanager.v1.WalletManagerService/GetWalletStatus"
-	// WalletManagerServiceListSidechainDepositsProcedure is the fully-qualified name of the
+	// WalletManagerServiceListSidechainDepositsProcedure is the procedure name of the
 	// WalletManagerService's ListSidechainDeposits RPC.
 	WalletManagerServiceListSidechainDepositsProcedure = "/walletmanager.v1.WalletManagerService/ListSidechainDeposits"
-	// WalletManagerServiceGetSidechainDepositTotalsProcedure is the fully-qualified name of the
+	// WalletManagerServiceGetSidechainDepositTotalsProcedure is the procedure name of the
 	// WalletManagerService's GetSidechainDepositTotals RPC.
 	WalletManagerServiceGetSidechainDepositTotalsProcedure = "/walletmanager.v1.WalletManagerService/GetSidechainDepositTotals"
-	// WalletManagerServiceGetNodeModeProcedure is the fully-qualified name of the
-	// WalletManagerService's GetNodeMode RPC.
+	// WalletManagerServiceGetNodeModeProcedure is the procedure name of the WalletManagerService's
+	// GetNodeMode RPC.
 	WalletManagerServiceGetNodeModeProcedure = "/walletmanager.v1.WalletManagerService/GetNodeMode"
-	// WalletManagerServiceSetNodeModeProcedure is the fully-qualified name of the
-	// WalletManagerService's SetNodeMode RPC.
+	// WalletManagerServiceSetNodeModeProcedure is the procedure name of the WalletManagerService's
+	// SetNodeMode RPC.
 	WalletManagerServiceSetNodeModeProcedure = "/walletmanager.v1.WalletManagerService/SetNodeMode"
-	// WalletManagerServiceGenerateWalletProcedure is the fully-qualified name of the
-	// WalletManagerService's GenerateWallet RPC.
+	// WalletManagerServiceGenerateWalletProcedure is the procedure name of the WalletManagerService's
+	// GenerateWallet RPC.
 	WalletManagerServiceGenerateWalletProcedure = "/walletmanager.v1.WalletManagerService/GenerateWallet"
-	// WalletManagerServiceUnlockWalletProcedure is the fully-qualified name of the
-	// WalletManagerService's UnlockWallet RPC.
+	// WalletManagerServiceUnlockWalletProcedure is the procedure name of the WalletManagerService's
+	// UnlockWallet RPC.
 	WalletManagerServiceUnlockWalletProcedure = "/walletmanager.v1.WalletManagerService/UnlockWallet"
-	// WalletManagerServiceLockWalletProcedure is the fully-qualified name of the WalletManagerService's
+	// WalletManagerServiceLockWalletProcedure is the procedure name of the WalletManagerService's
 	// LockWallet RPC.
 	WalletManagerServiceLockWalletProcedure = "/walletmanager.v1.WalletManagerService/LockWallet"
-	// WalletManagerServiceEncryptWalletProcedure is the fully-qualified name of the
-	// WalletManagerService's EncryptWallet RPC.
+	// WalletManagerServiceEncryptWalletProcedure is the procedure name of the WalletManagerService's
+	// EncryptWallet RPC.
 	WalletManagerServiceEncryptWalletProcedure = "/walletmanager.v1.WalletManagerService/EncryptWallet"
-	// WalletManagerServiceChangePasswordProcedure is the fully-qualified name of the
-	// WalletManagerService's ChangePassword RPC.
+	// WalletManagerServiceChangePasswordProcedure is the procedure name of the WalletManagerService's
+	// ChangePassword RPC.
 	WalletManagerServiceChangePasswordProcedure = "/walletmanager.v1.WalletManagerService/ChangePassword"
-	// WalletManagerServiceRemoveEncryptionProcedure is the fully-qualified name of the
-	// WalletManagerService's RemoveEncryption RPC.
+	// WalletManagerServiceRemoveEncryptionProcedure is the procedure name of the WalletManagerService's
+	// RemoveEncryption RPC.
 	WalletManagerServiceRemoveEncryptionProcedure = "/walletmanager.v1.WalletManagerService/RemoveEncryption"
-	// WalletManagerServiceListWalletsProcedure is the fully-qualified name of the
-	// WalletManagerService's ListWallets RPC.
+	// WalletManagerServiceListWalletsProcedure is the procedure name of the WalletManagerService's
+	// ListWallets RPC.
 	WalletManagerServiceListWalletsProcedure = "/walletmanager.v1.WalletManagerService/ListWallets"
-	// WalletManagerServiceSwitchWalletProcedure is the fully-qualified name of the
-	// WalletManagerService's SwitchWallet RPC.
+	// WalletManagerServiceSwitchWalletProcedure is the procedure name of the WalletManagerService's
+	// SwitchWallet RPC.
 	WalletManagerServiceSwitchWalletProcedure = "/walletmanager.v1.WalletManagerService/SwitchWallet"
-	// WalletManagerServiceUpdateWalletMetadataProcedure is the fully-qualified name of the
+	// WalletManagerServiceUpdateWalletMetadataProcedure is the procedure name of the
 	// WalletManagerService's UpdateWalletMetadata RPC.
 	WalletManagerServiceUpdateWalletMetadataProcedure = "/walletmanager.v1.WalletManagerService/UpdateWalletMetadata"
-	// WalletManagerServiceDeleteWalletProcedure is the fully-qualified name of the
-	// WalletManagerService's DeleteWallet RPC.
+	// WalletManagerServiceDeleteWalletProcedure is the procedure name of the WalletManagerService's
+	// DeleteWallet RPC.
 	WalletManagerServiceDeleteWalletProcedure = "/walletmanager.v1.WalletManagerService/DeleteWallet"
-	// WalletManagerServiceDeleteAllWalletsProcedure is the fully-qualified name of the
-	// WalletManagerService's DeleteAllWallets RPC.
+	// WalletManagerServiceDeleteAllWalletsProcedure is the procedure name of the WalletManagerService's
+	// DeleteAllWallets RPC.
 	WalletManagerServiceDeleteAllWalletsProcedure = "/walletmanager.v1.WalletManagerService/DeleteAllWallets"
-	// WalletManagerServiceListWalletBackupsProcedure is the fully-qualified name of the
+	// WalletManagerServiceListWalletBackupsProcedure is the procedure name of the
 	// WalletManagerService's ListWalletBackups RPC.
 	WalletManagerServiceListWalletBackupsProcedure = "/walletmanager.v1.WalletManagerService/ListWalletBackups"
-	// WalletManagerServiceRestoreWalletBackupProcedure is the fully-qualified name of the
+	// WalletManagerServiceRestoreWalletBackupProcedure is the procedure name of the
 	// WalletManagerService's RestoreWalletBackup RPC.
 	WalletManagerServiceRestoreWalletBackupProcedure = "/walletmanager.v1.WalletManagerService/RestoreWalletBackup"
-	// WalletManagerServiceRestoreWalletBackupStreamProcedure is the fully-qualified name of the
+	// WalletManagerServiceRestoreWalletBackupStreamProcedure is the procedure name of the
 	// WalletManagerService's RestoreWalletBackupStream RPC.
 	WalletManagerServiceRestoreWalletBackupStreamProcedure = "/walletmanager.v1.WalletManagerService/RestoreWalletBackupStream"
-	// WalletManagerServiceCreateWatchOnlyWalletProcedure is the fully-qualified name of the
+	// WalletManagerServiceCreateWatchOnlyWalletProcedure is the procedure name of the
 	// WalletManagerService's CreateWatchOnlyWallet RPC.
 	WalletManagerServiceCreateWatchOnlyWalletProcedure = "/walletmanager.v1.WalletManagerService/CreateWatchOnlyWallet"
-	// WalletManagerServiceCreateElectrumWalletProcedure is the fully-qualified name of the
+	// WalletManagerServiceCreateElectrumWalletProcedure is the procedure name of the
 	// WalletManagerService's CreateElectrumWallet RPC.
 	WalletManagerServiceCreateElectrumWalletProcedure = "/walletmanager.v1.WalletManagerService/CreateElectrumWallet"
-	// WalletManagerServiceCreateMultisigWalletProcedure is the fully-qualified name of the
+	// WalletManagerServiceCreateMultisigWalletProcedure is the procedure name of the
 	// WalletManagerService's CreateMultisigWallet RPC.
 	WalletManagerServiceCreateMultisigWalletProcedure = "/walletmanager.v1.WalletManagerService/CreateMultisigWallet"
-	// WalletManagerServiceParseMultisigConfigProcedure is the fully-qualified name of the
+	// WalletManagerServiceParseMultisigConfigProcedure is the procedure name of the
 	// WalletManagerService's ParseMultisigConfig RPC.
 	WalletManagerServiceParseMultisigConfigProcedure = "/walletmanager.v1.WalletManagerService/ParseMultisigConfig"
-	// WalletManagerServiceValidateDescriptorProcedure is the fully-qualified name of the
+	// WalletManagerServiceValidateDescriptorProcedure is the procedure name of the
 	// WalletManagerService's ValidateDescriptor RPC.
 	WalletManagerServiceValidateDescriptorProcedure = "/walletmanager.v1.WalletManagerService/ValidateDescriptor"
-	// WalletManagerServiceValidateDerivationPathProcedure is the fully-qualified name of the
+	// WalletManagerServiceValidateDerivationPathProcedure is the procedure name of the
 	// WalletManagerService's ValidateDerivationPath RPC.
 	WalletManagerServiceValidateDerivationPathProcedure = "/walletmanager.v1.WalletManagerService/ValidateDerivationPath"
-	// WalletManagerServiceListDerivationPathsProcedure is the fully-qualified name of the
+	// WalletManagerServiceListDerivationPathsProcedure is the procedure name of the
 	// WalletManagerService's ListDerivationPaths RPC.
 	WalletManagerServiceListDerivationPathsProcedure = "/walletmanager.v1.WalletManagerService/ListDerivationPaths"
-	// WalletManagerServiceCreateBitcoinCoreWalletProcedure is the fully-qualified name of the
+	// WalletManagerServiceCreateBitcoinCoreWalletProcedure is the procedure name of the
 	// WalletManagerService's CreateBitcoinCoreWallet RPC.
 	WalletManagerServiceCreateBitcoinCoreWalletProcedure = "/walletmanager.v1.WalletManagerService/CreateBitcoinCoreWallet"
-	// WalletManagerServiceEnsureCoreWalletsProcedure is the fully-qualified name of the
+	// WalletManagerServiceEnsureCoreWalletsProcedure is the procedure name of the
 	// WalletManagerService's EnsureCoreWallets RPC.
 	WalletManagerServiceEnsureCoreWalletsProcedure = "/walletmanager.v1.WalletManagerService/EnsureCoreWallets"
-	// WalletManagerServiceGetBalanceProcedure is the fully-qualified name of the WalletManagerService's
+	// WalletManagerServiceGetBalanceProcedure is the procedure name of the WalletManagerService's
 	// GetBalance RPC.
 	WalletManagerServiceGetBalanceProcedure = "/walletmanager.v1.WalletManagerService/GetBalance"
-	// WalletManagerServiceRescanWalletProcedure is the fully-qualified name of the
-	// WalletManagerService's RescanWallet RPC.
+	// WalletManagerServiceRescanWalletProcedure is the procedure name of the WalletManagerService's
+	// RescanWallet RPC.
 	WalletManagerServiceRescanWalletProcedure = "/walletmanager.v1.WalletManagerService/RescanWallet"
-	// WalletManagerServiceEstimateFeeProcedure is the fully-qualified name of the
-	// WalletManagerService's EstimateFee RPC.
+	// WalletManagerServiceEstimateFeeProcedure is the procedure name of the WalletManagerService's
+	// EstimateFee RPC.
 	WalletManagerServiceEstimateFeeProcedure = "/walletmanager.v1.WalletManagerService/EstimateFee"
-	// WalletManagerServiceGetNewAddressProcedure is the fully-qualified name of the
-	// WalletManagerService's GetNewAddress RPC.
+	// WalletManagerServiceGetNewAddressProcedure is the procedure name of the WalletManagerService's
+	// GetNewAddress RPC.
 	WalletManagerServiceGetNewAddressProcedure = "/walletmanager.v1.WalletManagerService/GetNewAddress"
-	// WalletManagerServiceSendTransactionProcedure is the fully-qualified name of the
-	// WalletManagerService's SendTransaction RPC.
+	// WalletManagerServiceSendTransactionProcedure is the procedure name of the WalletManagerService's
+	// SendTransaction RPC.
 	WalletManagerServiceSendTransactionProcedure = "/walletmanager.v1.WalletManagerService/SendTransaction"
-	// WalletManagerServicePreviewSendProcedure is the fully-qualified name of the
-	// WalletManagerService's PreviewSend RPC.
+	// WalletManagerServicePreviewSendProcedure is the procedure name of the WalletManagerService's
+	// PreviewSend RPC.
 	WalletManagerServicePreviewSendProcedure = "/walletmanager.v1.WalletManagerService/PreviewSend"
-	// WalletManagerServiceSetFrozenCoinsProcedure is the fully-qualified name of the
-	// WalletManagerService's SetFrozenCoins RPC.
+	// WalletManagerServiceSetFrozenCoinsProcedure is the procedure name of the WalletManagerService's
+	// SetFrozenCoins RPC.
 	WalletManagerServiceSetFrozenCoinsProcedure = "/walletmanager.v1.WalletManagerService/SetFrozenCoins"
-	// WalletManagerServiceCreateDepositProcedure is the fully-qualified name of the
-	// WalletManagerService's CreateDeposit RPC.
+	// WalletManagerServiceCreateDepositProcedure is the procedure name of the WalletManagerService's
+	// CreateDeposit RPC.
 	WalletManagerServiceCreateDepositProcedure = "/walletmanager.v1.WalletManagerService/CreateDeposit"
-	// WalletManagerServiceListTransactionsProcedure is the fully-qualified name of the
-	// WalletManagerService's ListTransactions RPC.
+	// WalletManagerServiceListTransactionsProcedure is the procedure name of the WalletManagerService's
+	// ListTransactions RPC.
 	WalletManagerServiceListTransactionsProcedure = "/walletmanager.v1.WalletManagerService/ListTransactions"
-	// WalletManagerServiceListUnspentProcedure is the fully-qualified name of the
-	// WalletManagerService's ListUnspent RPC.
+	// WalletManagerServiceListUnspentProcedure is the procedure name of the WalletManagerService's
+	// ListUnspent RPC.
 	WalletManagerServiceListUnspentProcedure = "/walletmanager.v1.WalletManagerService/ListUnspent"
-	// WalletManagerServiceListReceiveAddressesProcedure is the fully-qualified name of the
+	// WalletManagerServiceListReceiveAddressesProcedure is the procedure name of the
 	// WalletManagerService's ListReceiveAddresses RPC.
 	WalletManagerServiceListReceiveAddressesProcedure = "/walletmanager.v1.WalletManagerService/ListReceiveAddresses"
-	// WalletManagerServiceGetTransactionDetailsProcedure is the fully-qualified name of the
+	// WalletManagerServiceGetTransactionDetailsProcedure is the procedure name of the
 	// WalletManagerService's GetTransactionDetails RPC.
 	WalletManagerServiceGetTransactionDetailsProcedure = "/walletmanager.v1.WalletManagerService/GetTransactionDetails"
-	// WalletManagerServiceDecodeTransactionProcedure is the fully-qualified name of the
+	// WalletManagerServiceDecodeTransactionProcedure is the procedure name of the
 	// WalletManagerService's DecodeTransaction RPC.
 	WalletManagerServiceDecodeTransactionProcedure = "/walletmanager.v1.WalletManagerService/DecodeTransaction"
-	// WalletManagerServiceBumpFeeProcedure is the fully-qualified name of the WalletManagerService's
-	// BumpFee RPC.
+	// WalletManagerServiceBumpFeeProcedure is the procedure name of the WalletManagerService's BumpFee
+	// RPC.
 	WalletManagerServiceBumpFeeProcedure = "/walletmanager.v1.WalletManagerService/BumpFee"
-	// WalletManagerServicePreviewBumpFeeProcedure is the fully-qualified name of the
-	// WalletManagerService's PreviewBumpFee RPC.
+	// WalletManagerServicePreviewBumpFeeProcedure is the procedure name of the WalletManagerService's
+	// PreviewBumpFee RPC.
 	WalletManagerServicePreviewBumpFeeProcedure = "/walletmanager.v1.WalletManagerService/PreviewBumpFee"
-	// WalletManagerServiceCreateCpfpProcedure is the fully-qualified name of the WalletManagerService's
+	// WalletManagerServiceCreateCpfpProcedure is the procedure name of the WalletManagerService's
 	// CreateCpfp RPC.
 	WalletManagerServiceCreateCpfpProcedure = "/walletmanager.v1.WalletManagerService/CreateCpfp"
-	// WalletManagerServiceCancelTransactionProcedure is the fully-qualified name of the
+	// WalletManagerServiceCancelTransactionProcedure is the procedure name of the
 	// WalletManagerService's CancelTransaction RPC.
 	WalletManagerServiceCancelTransactionProcedure = "/walletmanager.v1.WalletManagerService/CancelTransaction"
-	// WalletManagerServiceDeriveAddressesProcedure is the fully-qualified name of the
-	// WalletManagerService's DeriveAddresses RPC.
+	// WalletManagerServiceDeriveAddressesProcedure is the procedure name of the WalletManagerService's
+	// DeriveAddresses RPC.
 	WalletManagerServiceDeriveAddressesProcedure = "/walletmanager.v1.WalletManagerService/DeriveAddresses"
-	// WalletManagerServiceCreatePsbtProcedure is the fully-qualified name of the WalletManagerService's
+	// WalletManagerServiceCreatePsbtProcedure is the procedure name of the WalletManagerService's
 	// CreatePsbt RPC.
 	WalletManagerServiceCreatePsbtProcedure = "/walletmanager.v1.WalletManagerService/CreatePsbt"
-	// WalletManagerServiceSignPsbtProcedure is the fully-qualified name of the WalletManagerService's
+	// WalletManagerServiceSignPsbtProcedure is the procedure name of the WalletManagerService's
 	// SignPsbt RPC.
 	WalletManagerServiceSignPsbtProcedure = "/walletmanager.v1.WalletManagerService/SignPsbt"
-	// WalletManagerServiceSignPsbtWithCosignerProcedure is the fully-qualified name of the
+	// WalletManagerServiceSignPsbtWithCosignerProcedure is the procedure name of the
 	// WalletManagerService's SignPsbtWithCosigner RPC.
 	WalletManagerServiceSignPsbtWithCosignerProcedure = "/walletmanager.v1.WalletManagerService/SignPsbtWithCosigner"
-	// WalletManagerServiceCombinePsbtProcedure is the fully-qualified name of the
-	// WalletManagerService's CombinePsbt RPC.
+	// WalletManagerServiceCombinePsbtProcedure is the procedure name of the WalletManagerService's
+	// CombinePsbt RPC.
 	WalletManagerServiceCombinePsbtProcedure = "/walletmanager.v1.WalletManagerService/CombinePsbt"
-	// WalletManagerServiceFinalizePsbtProcedure is the fully-qualified name of the
-	// WalletManagerService's FinalizePsbt RPC.
+	// WalletManagerServiceFinalizePsbtProcedure is the procedure name of the WalletManagerService's
+	// FinalizePsbt RPC.
 	WalletManagerServiceFinalizePsbtProcedure = "/walletmanager.v1.WalletManagerService/FinalizePsbt"
-	// WalletManagerServiceMultisigPsbtStatusProcedure is the fully-qualified name of the
+	// WalletManagerServiceMultisigPsbtStatusProcedure is the procedure name of the
 	// WalletManagerService's MultisigPsbtStatus RPC.
 	WalletManagerServiceMultisigPsbtStatusProcedure = "/walletmanager.v1.WalletManagerService/MultisigPsbtStatus"
-	// WalletManagerServiceBroadcastTransactionProcedure is the fully-qualified name of the
+	// WalletManagerServiceBroadcastTransactionProcedure is the procedure name of the
 	// WalletManagerService's BroadcastTransaction RPC.
 	WalletManagerServiceBroadcastTransactionProcedure = "/walletmanager.v1.WalletManagerService/BroadcastTransaction"
-	// WalletManagerServiceGetAddressUnspentProcedure is the fully-qualified name of the
+	// WalletManagerServiceGetAddressUnspentProcedure is the procedure name of the
 	// WalletManagerService's GetAddressUnspent RPC.
 	WalletManagerServiceGetAddressUnspentProcedure = "/walletmanager.v1.WalletManagerService/GetAddressUnspent"
-	// WalletManagerServiceBroadcastElectrumTransactionProcedure is the fully-qualified name of the
+	// WalletManagerServiceBroadcastElectrumTransactionProcedure is the procedure name of the
 	// WalletManagerService's BroadcastElectrumTransaction RPC.
 	WalletManagerServiceBroadcastElectrumTransactionProcedure = "/walletmanager.v1.WalletManagerService/BroadcastElectrumTransaction"
-	// WalletManagerServiceEnumerateHardwareDevicesProcedure is the fully-qualified name of the
+	// WalletManagerServiceEnumerateHardwareDevicesProcedure is the procedure name of the
 	// WalletManagerService's EnumerateHardwareDevices RPC.
 	WalletManagerServiceEnumerateHardwareDevicesProcedure = "/walletmanager.v1.WalletManagerService/EnumerateHardwareDevices"
-	// WalletManagerServiceGetHardwareXpubProcedure is the fully-qualified name of the
-	// WalletManagerService's GetHardwareXpub RPC.
+	// WalletManagerServiceGetHardwareXpubProcedure is the procedure name of the WalletManagerService's
+	// GetHardwareXpub RPC.
 	WalletManagerServiceGetHardwareXpubProcedure = "/walletmanager.v1.WalletManagerService/GetHardwareXpub"
-	// WalletManagerServiceSignPsbtWithDeviceProcedure is the fully-qualified name of the
+	// WalletManagerServiceSignPsbtWithDeviceProcedure is the procedure name of the
 	// WalletManagerService's SignPsbtWithDevice RPC.
 	WalletManagerServiceSignPsbtWithDeviceProcedure = "/walletmanager.v1.WalletManagerService/SignPsbtWithDevice"
-	// WalletManagerServicePromptDevicePinProcedure is the fully-qualified name of the
-	// WalletManagerService's PromptDevicePin RPC.
+	// WalletManagerServicePromptDevicePinProcedure is the procedure name of the WalletManagerService's
+	// PromptDevicePin RPC.
 	WalletManagerServicePromptDevicePinProcedure = "/walletmanager.v1.WalletManagerService/PromptDevicePin"
-	// WalletManagerServiceSendDevicePinProcedure is the fully-qualified name of the
-	// WalletManagerService's SendDevicePin RPC.
+	// WalletManagerServiceSendDevicePinProcedure is the procedure name of the WalletManagerService's
+	// SendDevicePin RPC.
 	WalletManagerServiceSendDevicePinProcedure = "/walletmanager.v1.WalletManagerService/SendDevicePin"
-	// WalletManagerServiceCloseDeviceProcedure is the fully-qualified name of the
-	// WalletManagerService's CloseDevice RPC.
+	// WalletManagerServiceCloseDeviceProcedure is the procedure name of the WalletManagerService's
+	// CloseDevice RPC.
 	WalletManagerServiceCloseDeviceProcedure = "/walletmanager.v1.WalletManagerService/CloseDevice"
-	// WalletManagerServiceDeriveKeystoreProcedure is the fully-qualified name of the
-	// WalletManagerService's DeriveKeystore RPC.
+	// WalletManagerServiceDeriveKeystoreProcedure is the procedure name of the WalletManagerService's
+	// DeriveKeystore RPC.
 	WalletManagerServiceDeriveKeystoreProcedure = "/walletmanager.v1.WalletManagerService/DeriveKeystore"
-	// WalletManagerServicePreviewWalletFromEntropyProcedure is the fully-qualified name of the
+	// WalletManagerServicePreviewWalletFromEntropyProcedure is the procedure name of the
 	// WalletManagerService's PreviewWalletFromEntropy RPC.
 	WalletManagerServicePreviewWalletFromEntropyProcedure = "/walletmanager.v1.WalletManagerService/PreviewWalletFromEntropy"
-	// WalletManagerServiceGetWalletSeedProcedure is the fully-qualified name of the
-	// WalletManagerService's GetWalletSeed RPC.
+	// WalletManagerServiceGetWalletSeedProcedure is the procedure name of the WalletManagerService's
+	// GetWalletSeed RPC.
 	WalletManagerServiceGetWalletSeedProcedure = "/walletmanager.v1.WalletManagerService/GetWalletSeed"
-	// WalletManagerServiceListCoreVariantsProcedure is the fully-qualified name of the
-	// WalletManagerService's ListCoreVariants RPC.
+	// WalletManagerServiceListCoreVariantsProcedure is the procedure name of the WalletManagerService's
+	// ListCoreVariants RPC.
 	WalletManagerServiceListCoreVariantsProcedure = "/walletmanager.v1.WalletManagerService/ListCoreVariants"
-	// WalletManagerServiceGetCoreVariantProcedure is the fully-qualified name of the
-	// WalletManagerService's GetCoreVariant RPC.
+	// WalletManagerServiceGetCoreVariantProcedure is the procedure name of the WalletManagerService's
+	// GetCoreVariant RPC.
 	WalletManagerServiceGetCoreVariantProcedure = "/walletmanager.v1.WalletManagerService/GetCoreVariant"
-	// WalletManagerServiceSetCoreVariantProcedure is the fully-qualified name of the
-	// WalletManagerService's SetCoreVariant RPC.
+	// WalletManagerServiceSetCoreVariantProcedure is the procedure name of the WalletManagerService's
+	// SetCoreVariant RPC.
 	WalletManagerServiceSetCoreVariantProcedure = "/walletmanager.v1.WalletManagerService/SetCoreVariant"
-	// WalletManagerServiceGetElectrumServerProcedure is the fully-qualified name of the
+	// WalletManagerServiceGetElectrumServerProcedure is the procedure name of the
 	// WalletManagerService's GetElectrumServer RPC.
 	WalletManagerServiceGetElectrumServerProcedure = "/walletmanager.v1.WalletManagerService/GetElectrumServer"
-	// WalletManagerServiceSetElectrumServerProcedure is the fully-qualified name of the
+	// WalletManagerServiceSetElectrumServerProcedure is the procedure name of the
 	// WalletManagerService's SetElectrumServer RPC.
 	WalletManagerServiceSetElectrumServerProcedure = "/walletmanager.v1.WalletManagerService/SetElectrumServer"
-	// WalletManagerServiceGetTorConfigProcedure is the fully-qualified name of the
-	// WalletManagerService's GetTorConfig RPC.
+	// WalletManagerServiceGetTorConfigProcedure is the procedure name of the WalletManagerService's
+	// GetTorConfig RPC.
 	WalletManagerServiceGetTorConfigProcedure = "/walletmanager.v1.WalletManagerService/GetTorConfig"
-	// WalletManagerServiceSetTorConfigProcedure is the fully-qualified name of the
-	// WalletManagerService's SetTorConfig RPC.
+	// WalletManagerServiceSetTorConfigProcedure is the procedure name of the WalletManagerService's
+	// SetTorConfig RPC.
 	WalletManagerServiceSetTorConfigProcedure = "/walletmanager.v1.WalletManagerService/SetTorConfig"
-	// WalletManagerServiceWatchWalletDataProcedure is the fully-qualified name of the
-	// WalletManagerService's WatchWalletData RPC.
+	// WalletManagerServiceWatchWalletDataProcedure is the procedure name of the WalletManagerService's
+	// WatchWalletData RPC.
 	WalletManagerServiceWatchWalletDataProcedure = "/walletmanager.v1.WalletManagerService/WatchWalletData"
 )
 
+var (
+	walletManagerServiceGetWalletStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetWalletStatus"),
+			Procedure:  WalletManagerServiceGetWalletStatusProcedure,
+		}
+	})
+	walletManagerServiceListSidechainDepositsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListSidechainDeposits"),
+			Procedure:  WalletManagerServiceListSidechainDepositsProcedure,
+		}
+	})
+	walletManagerServiceGetSidechainDepositTotalsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetSidechainDepositTotals"),
+			Procedure:  WalletManagerServiceGetSidechainDepositTotalsProcedure,
+		}
+	})
+	walletManagerServiceGetNodeModeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetNodeMode"),
+			Procedure:  WalletManagerServiceGetNodeModeProcedure,
+		}
+	})
+	walletManagerServiceSetNodeModeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SetNodeMode"),
+			Procedure:  WalletManagerServiceSetNodeModeProcedure,
+		}
+	})
+	walletManagerServiceGenerateWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GenerateWallet"),
+			Procedure:  WalletManagerServiceGenerateWalletProcedure,
+		}
+	})
+	walletManagerServiceUnlockWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("UnlockWallet"),
+			Procedure:  WalletManagerServiceUnlockWalletProcedure,
+		}
+	})
+	walletManagerServiceLockWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("LockWallet"),
+			Procedure:  WalletManagerServiceLockWalletProcedure,
+		}
+	})
+	walletManagerServiceEncryptWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("EncryptWallet"),
+			Procedure:  WalletManagerServiceEncryptWalletProcedure,
+		}
+	})
+	walletManagerServiceChangePasswordSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ChangePassword"),
+			Procedure:  WalletManagerServiceChangePasswordProcedure,
+		}
+	})
+	walletManagerServiceRemoveEncryptionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("RemoveEncryption"),
+			Procedure:  WalletManagerServiceRemoveEncryptionProcedure,
+		}
+	})
+	walletManagerServiceListWalletsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListWallets"),
+			Procedure:  WalletManagerServiceListWalletsProcedure,
+		}
+	})
+	walletManagerServiceSwitchWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SwitchWallet"),
+			Procedure:  WalletManagerServiceSwitchWalletProcedure,
+		}
+	})
+	walletManagerServiceUpdateWalletMetadataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("UpdateWalletMetadata"),
+			Procedure:  WalletManagerServiceUpdateWalletMetadataProcedure,
+		}
+	})
+	walletManagerServiceDeleteWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("DeleteWallet"),
+			Procedure:  WalletManagerServiceDeleteWalletProcedure,
+		}
+	})
+	walletManagerServiceDeleteAllWalletsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("DeleteAllWallets"),
+			Procedure:  WalletManagerServiceDeleteAllWalletsProcedure,
+		}
+	})
+	walletManagerServiceListWalletBackupsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListWalletBackups"),
+			Procedure:  WalletManagerServiceListWalletBackupsProcedure,
+		}
+	})
+	walletManagerServiceRestoreWalletBackupSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("RestoreWalletBackup"),
+			Procedure:  WalletManagerServiceRestoreWalletBackupProcedure,
+		}
+	})
+	walletManagerServiceRestoreWalletBackupStreamSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("RestoreWalletBackupStream"),
+			Procedure:  WalletManagerServiceRestoreWalletBackupStreamProcedure,
+		}
+	})
+	walletManagerServiceCreateWatchOnlyWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CreateWatchOnlyWallet"),
+			Procedure:  WalletManagerServiceCreateWatchOnlyWalletProcedure,
+		}
+	})
+	walletManagerServiceCreateElectrumWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CreateElectrumWallet"),
+			Procedure:  WalletManagerServiceCreateElectrumWalletProcedure,
+		}
+	})
+	walletManagerServiceCreateMultisigWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CreateMultisigWallet"),
+			Procedure:  WalletManagerServiceCreateMultisigWalletProcedure,
+		}
+	})
+	walletManagerServiceParseMultisigConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ParseMultisigConfig"),
+			Procedure:  WalletManagerServiceParseMultisigConfigProcedure,
+		}
+	})
+	walletManagerServiceValidateDescriptorSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ValidateDescriptor"),
+			Procedure:  WalletManagerServiceValidateDescriptorProcedure,
+		}
+	})
+	walletManagerServiceValidateDerivationPathSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ValidateDerivationPath"),
+			Procedure:  WalletManagerServiceValidateDerivationPathProcedure,
+		}
+	})
+	walletManagerServiceListDerivationPathsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListDerivationPaths"),
+			Procedure:  WalletManagerServiceListDerivationPathsProcedure,
+		}
+	})
+	walletManagerServiceCreateBitcoinCoreWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CreateBitcoinCoreWallet"),
+			Procedure:  WalletManagerServiceCreateBitcoinCoreWalletProcedure,
+		}
+	})
+	walletManagerServiceEnsureCoreWalletsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("EnsureCoreWallets"),
+			Procedure:  WalletManagerServiceEnsureCoreWalletsProcedure,
+		}
+	})
+	walletManagerServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetBalance"),
+			Procedure:  WalletManagerServiceGetBalanceProcedure,
+		}
+	})
+	walletManagerServiceRescanWalletSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("RescanWallet"),
+			Procedure:  WalletManagerServiceRescanWalletProcedure,
+		}
+	})
+	walletManagerServiceEstimateFeeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("EstimateFee"),
+			Procedure:  WalletManagerServiceEstimateFeeProcedure,
+		}
+	})
+	walletManagerServiceGetNewAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetNewAddress"),
+			Procedure:  WalletManagerServiceGetNewAddressProcedure,
+		}
+	})
+	walletManagerServiceSendTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SendTransaction"),
+			Procedure:  WalletManagerServiceSendTransactionProcedure,
+		}
+	})
+	walletManagerServicePreviewSendSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("PreviewSend"),
+			Procedure:  WalletManagerServicePreviewSendProcedure,
+		}
+	})
+	walletManagerServiceSetFrozenCoinsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SetFrozenCoins"),
+			Procedure:  WalletManagerServiceSetFrozenCoinsProcedure,
+		}
+	})
+	walletManagerServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CreateDeposit"),
+			Procedure:  WalletManagerServiceCreateDepositProcedure,
+		}
+	})
+	walletManagerServiceListTransactionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListTransactions"),
+			Procedure:  WalletManagerServiceListTransactionsProcedure,
+		}
+	})
+	walletManagerServiceListUnspentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListUnspent"),
+			Procedure:  WalletManagerServiceListUnspentProcedure,
+		}
+	})
+	walletManagerServiceListReceiveAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListReceiveAddresses"),
+			Procedure:  WalletManagerServiceListReceiveAddressesProcedure,
+		}
+	})
+	walletManagerServiceGetTransactionDetailsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetTransactionDetails"),
+			Procedure:  WalletManagerServiceGetTransactionDetailsProcedure,
+		}
+	})
+	walletManagerServiceDecodeTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("DecodeTransaction"),
+			Procedure:  WalletManagerServiceDecodeTransactionProcedure,
+		}
+	})
+	walletManagerServiceBumpFeeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("BumpFee"),
+			Procedure:  WalletManagerServiceBumpFeeProcedure,
+		}
+	})
+	walletManagerServicePreviewBumpFeeSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("PreviewBumpFee"),
+			Procedure:  WalletManagerServicePreviewBumpFeeProcedure,
+		}
+	})
+	walletManagerServiceCreateCpfpSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CreateCpfp"),
+			Procedure:  WalletManagerServiceCreateCpfpProcedure,
+		}
+	})
+	walletManagerServiceCancelTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CancelTransaction"),
+			Procedure:  WalletManagerServiceCancelTransactionProcedure,
+		}
+	})
+	walletManagerServiceDeriveAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("DeriveAddresses"),
+			Procedure:  WalletManagerServiceDeriveAddressesProcedure,
+		}
+	})
+	walletManagerServiceCreatePsbtSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CreatePsbt"),
+			Procedure:  WalletManagerServiceCreatePsbtProcedure,
+		}
+	})
+	walletManagerServiceSignPsbtSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SignPsbt"),
+			Procedure:  WalletManagerServiceSignPsbtProcedure,
+		}
+	})
+	walletManagerServiceSignPsbtWithCosignerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SignPsbtWithCosigner"),
+			Procedure:  WalletManagerServiceSignPsbtWithCosignerProcedure,
+		}
+	})
+	walletManagerServiceCombinePsbtSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CombinePsbt"),
+			Procedure:  WalletManagerServiceCombinePsbtProcedure,
+		}
+	})
+	walletManagerServiceFinalizePsbtSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("FinalizePsbt"),
+			Procedure:  WalletManagerServiceFinalizePsbtProcedure,
+		}
+	})
+	walletManagerServiceMultisigPsbtStatusSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("MultisigPsbtStatus"),
+			Procedure:  WalletManagerServiceMultisigPsbtStatusProcedure,
+		}
+	})
+	walletManagerServiceBroadcastTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("BroadcastTransaction"),
+			Procedure:  WalletManagerServiceBroadcastTransactionProcedure,
+		}
+	})
+	walletManagerServiceGetAddressUnspentSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetAddressUnspent"),
+			Procedure:  WalletManagerServiceGetAddressUnspentProcedure,
+		}
+	})
+	walletManagerServiceBroadcastElectrumTransactionSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("BroadcastElectrumTransaction"),
+			Procedure:  WalletManagerServiceBroadcastElectrumTransactionProcedure,
+		}
+	})
+	walletManagerServiceEnumerateHardwareDevicesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("EnumerateHardwareDevices"),
+			Procedure:  WalletManagerServiceEnumerateHardwareDevicesProcedure,
+		}
+	})
+	walletManagerServiceGetHardwareXpubSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetHardwareXpub"),
+			Procedure:  WalletManagerServiceGetHardwareXpubProcedure,
+		}
+	})
+	walletManagerServiceSignPsbtWithDeviceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SignPsbtWithDevice"),
+			Procedure:  WalletManagerServiceSignPsbtWithDeviceProcedure,
+		}
+	})
+	walletManagerServicePromptDevicePinSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("PromptDevicePin"),
+			Procedure:  WalletManagerServicePromptDevicePinProcedure,
+		}
+	})
+	walletManagerServiceSendDevicePinSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SendDevicePin"),
+			Procedure:  WalletManagerServiceSendDevicePinProcedure,
+		}
+	})
+	walletManagerServiceCloseDeviceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("CloseDevice"),
+			Procedure:  WalletManagerServiceCloseDeviceProcedure,
+		}
+	})
+	walletManagerServiceDeriveKeystoreSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("DeriveKeystore"),
+			Procedure:  WalletManagerServiceDeriveKeystoreProcedure,
+		}
+	})
+	walletManagerServicePreviewWalletFromEntropySpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("PreviewWalletFromEntropy"),
+			Procedure:  WalletManagerServicePreviewWalletFromEntropyProcedure,
+		}
+	})
+	walletManagerServiceGetWalletSeedSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetWalletSeed"),
+			Procedure:  WalletManagerServiceGetWalletSeedProcedure,
+		}
+	})
+	walletManagerServiceListCoreVariantsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("ListCoreVariants"),
+			Procedure:  WalletManagerServiceListCoreVariantsProcedure,
+		}
+	})
+	walletManagerServiceGetCoreVariantSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetCoreVariant"),
+			Procedure:  WalletManagerServiceGetCoreVariantProcedure,
+		}
+	})
+	walletManagerServiceSetCoreVariantSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SetCoreVariant"),
+			Procedure:  WalletManagerServiceSetCoreVariantProcedure,
+		}
+	})
+	walletManagerServiceGetElectrumServerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetElectrumServer"),
+			Procedure:  WalletManagerServiceGetElectrumServerProcedure,
+		}
+	})
+	walletManagerServiceSetElectrumServerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SetElectrumServer"),
+			Procedure:  WalletManagerServiceSetElectrumServerProcedure,
+		}
+	})
+	walletManagerServiceGetTorConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("GetTorConfig"),
+			Procedure:  WalletManagerServiceGetTorConfigProcedure,
+		}
+	})
+	walletManagerServiceSetTorConfigSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("SetTorConfig"),
+			Procedure:  WalletManagerServiceSetTorConfigProcedure,
+		}
+	})
+	walletManagerServiceWatchWalletDataSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeServer,
+			Schema:     v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods().ByName("WatchWalletData"),
+			Procedure:  WalletManagerServiceWatchWalletDataProcedure,
+		}
+	})
+)
+
 // WalletManagerServiceClient is a client for the walletmanager.v1.WalletManagerService service.
 type WalletManagerServiceClient interface {
-	// Wallet lifecycle
-	GetWalletStatus(context.Context, *connect.Request[v1.GetWalletStatusRequest]) (*connect.Response[v1.GetWalletStatusResponse], error)
-	// How much of Bitcoin this install runs. The frontend asks the user before
-	// it boots anything, and blocks until GetNodeMode reports a mode.
-	// Deposits this install made to a sidechain treasury. An M5 is an ordinary
-	// transaction on the wire, so the record comes from when we broadcast it.
-	ListSidechainDeposits(context.Context, *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error)
-	GetSidechainDepositTotals(context.Context, *connect.Request[v1.GetSidechainDepositTotalsRequest]) (*connect.Response[v1.GetSidechainDepositTotalsResponse], error)
-	GetNodeMode(context.Context, *connect.Request[v1.GetNodeModeRequest]) (*connect.Response[v1.GetNodeModeResponse], error)
-	SetNodeMode(context.Context, *connect.Request[v1.SetNodeModeRequest]) (*connect.Response[v1.SetNodeModeResponse], error)
-	GenerateWallet(context.Context, *connect.Request[v1.GenerateWalletRequest]) (*connect.Response[v1.GenerateWalletResponse], error)
-	UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error)
-	LockWallet(context.Context, *connect.Request[v1.LockWalletRequest]) (*connect.Response[v1.LockWalletResponse], error)
-	EncryptWallet(context.Context, *connect.Request[v1.EncryptWalletRequest]) (*connect.Response[v1.EncryptWalletResponse], error)
-	ChangePassword(context.Context, *connect.Request[v1.ChangePasswordRequest]) (*connect.Response[v1.ChangePasswordResponse], error)
-	RemoveEncryption(context.Context, *connect.Request[v1.RemoveEncryptionRequest]) (*connect.Response[v1.RemoveEncryptionResponse], error)
-	ListWallets(context.Context, *connect.Request[v1.ListWalletsRequest]) (*connect.Response[v1.ListWalletsResponse], error)
-	SwitchWallet(context.Context, *connect.Request[v1.SwitchWalletRequest]) (*connect.Response[v1.SwitchWalletResponse], error)
-	UpdateWalletMetadata(context.Context, *connect.Request[v1.UpdateWalletMetadataRequest]) (*connect.Response[v1.UpdateWalletMetadataResponse], error)
-	DeleteWallet(context.Context, *connect.Request[v1.DeleteWalletRequest]) (*connect.Response[v1.DeleteWalletResponse], error)
-	DeleteAllWallets(context.Context, *connect.Request[v1.DeleteAllWalletsRequest]) (*connect.Response[v1.DeleteAllWalletsResponse], error)
-	ListWalletBackups(context.Context, *connect.Request[v1.ListWalletBackupsRequest]) (*connect.Response[v1.ListWalletBackupsResponse], error)
-	RestoreWalletBackup(context.Context, *connect.Request[v1.RestoreWalletBackupRequest]) (*connect.Response[v1.RestoreWalletBackupResponse], error)
-	RestoreWalletBackupStream(context.Context, *connect.Request[v1.RestoreWalletBackupRequest]) (*connect.ServerStreamForClient[v1.RestoreWalletBackupProgressResponse], error)
-	CreateWatchOnlyWallet(context.Context, *connect.Request[v1.CreateWatchOnlyWalletRequest]) (*connect.Response[v1.CreateWatchOnlyWalletResponse], error)
-	// Create an electrum wallet: keys are generated locally, but no local Bitcoin
-	// Core or enforcer runs. The wallet reads its chain from Esplora.
-	CreateElectrumWallet(context.Context, *connect.Request[v1.CreateElectrumWalletRequest]) (*connect.Response[v1.CreateElectrumWalletResponse], error)
-	CreateMultisigWallet(context.Context, *connect.Request[v1.CreateMultisigWalletRequest]) (*connect.Response[v1.CreateMultisigWalletResponse], error)
-	// ParseMultisigConfig parses a descriptor or a wallet-config file (Coldcard
-	// text / Sparrow / Specter / Caravan JSON) into an m-of-n policy + cosigners.
-	ParseMultisigConfig(context.Context, *connect.Request[v1.ParseMultisigConfigRequest]) (*connect.Response[v1.ParseMultisigConfigResponse], error)
-	// ValidateDescriptor reads an output descriptor — single-sig or sortedmulti —
-	// into the script policy it encodes.
-	ValidateDescriptor(context.Context, *connect.Request[v1.ValidateDescriptorRequest]) (*connect.Response[v1.ValidateDescriptorResponse], error)
-	// ValidateDerivationPath canonicalises a BIP32 derivation path, or fails with
-	// the reason it is unusable.
-	ValidateDerivationPath(context.Context, *connect.Request[v1.ValidateDerivationPathRequest]) (*connect.Response[v1.ValidateDerivationPathResponse], error)
-	// ListDerivationPaths returns the standard account paths for a policy on the
-	// network this backend runs.
-	ListDerivationPaths(context.Context, *connect.Request[v1.ListDerivationPathsRequest]) (*connect.Response[v1.ListDerivationPathsResponse], error)
-	// Core wallet management
-	CreateBitcoinCoreWallet(context.Context, *connect.Request[v1.CreateBitcoinCoreWalletRequest]) (*connect.Response[v1.CreateBitcoinCoreWalletResponse], error)
-	EnsureCoreWallets(context.Context, *connect.Request[v1.EnsureCoreWalletsRequest]) (*connect.Response[v1.EnsureCoreWalletsResponse], error)
-	// Bitcoin operations (proxied through Core RPC)
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	RescanWallet(context.Context, *connect.Request[v1.RescanWalletRequest]) (*connect.Response[v1.RescanWalletResponse], error)
-	EstimateFee(context.Context, *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error)
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error)
-	// PreviewSend builds a send at a fee rate, with the same coin selection as
-	// SendTransaction, and reports its fee and size. It broadcasts nothing.
-	PreviewSend(context.Context, *connect.Request[v1.PreviewSendRequest]) (*connect.Response[v1.PreviewSendResponse], error)
-	// SetFrozenCoins records the coins the frontend froze. Every send after it
-	// leaves those coins alone, and Bitcoin Core holds them locked for the
-	// length of a send so its own coin selection skips them too.
-	SetFrozenCoins(context.Context, *connect.Request[v1.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error)
-	// CreateDeposit funds a BIP300 M5 deposit to a sidechain from any wallet.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	ListUnspent(context.Context, *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error)
-	ListReceiveAddresses(context.Context, *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error)
-	GetTransactionDetails(context.Context, *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error)
-	DecodeTransaction(context.Context, *connect.Request[v1.DecodeTransactionRequest]) (*connect.Response[v1.DecodeTransactionResponse], error)
-	BumpFee(context.Context, *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error)
-	// PreviewBumpFee reports what a fee bump costs, and which output pays it,
-	// without broadcasting anything.
-	PreviewBumpFee(context.Context, *connect.Request[v1.PreviewBumpFeeRequest]) (*connect.Response[v1.PreviewBumpFeeResponse], error)
-	// CreateCpfp spends an unconfirmed wallet UTXO with a child transaction whose
-	// fee lifts the parent+child package to the target fee rate (CPFP).
-	CreateCpfp(context.Context, *connect.Request[v1.CreateCpfpRequest]) (*connect.Response[v1.CreateCpfpResponse], error)
-	// CancelTransaction replaces an unconfirmed transaction with one that pays
-	// the wallet's own inputs of it back to the wallet.
-	CancelTransaction(context.Context, *connect.Request[v1.CancelTransactionRequest]) (*connect.Response[v1.CancelTransactionResponse], error)
-	DeriveAddresses(context.Context, *connect.Request[v1.DeriveAddressesRequest]) (*connect.Response[v1.DeriveAddressesResponse], error)
-	// PSBT (BIP174). CreatePsbt builds an unsigned PSBT for a send (works for
-	// watch-only wallets); SignPsbt adds this wallet's signatures; CombinePsbt
-	// merges cosigner PSBTs; FinalizePsbt extracts the raw transaction. Electrum
-	// wallets only.
-	CreatePsbt(context.Context, *connect.Request[v1.CreatePsbtRequest]) (*connect.Response[v1.CreatePsbtResponse], error)
-	SignPsbt(context.Context, *connect.Request[v1.SignPsbtRequest]) (*connect.Response[v1.SignPsbtResponse], error)
-	// SignPsbtWithCosigner signs a multisig PSBT with a single held cosigner's key
-	// (per-keystore signing), leaving the other legs for their own signers.
-	SignPsbtWithCosigner(context.Context, *connect.Request[v1.SignPsbtWithCosignerRequest]) (*connect.Response[v1.SignPsbtWithCosignerResponse], error)
-	CombinePsbt(context.Context, *connect.Request[v1.CombinePsbtRequest]) (*connect.Response[v1.CombinePsbtResponse], error)
-	FinalizePsbt(context.Context, *connect.Request[v1.FinalizePsbtRequest]) (*connect.Response[v1.FinalizePsbtResponse], error)
-	// MultisigPsbtStatus reports signing progress for a multisig wallet's PSBT:
-	// signature count, whether it can be finalized, and which cosigners signed.
-	MultisigPsbtStatus(context.Context, *connect.Request[v1.MultisigPsbtStatusRequest]) (*connect.Response[v1.MultisigPsbtStatusResponse], error)
-	// BroadcastTransaction broadcasts a finalized raw transaction over the
-	// wallet's chain source and returns its txid.
-	BroadcastTransaction(context.Context, *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error)
-	// Address reads that belong to no wallet — cheque addresses, whose funds are
-	// not the user's to spend. Always electrum-backed, whatever wallet is active.
-	GetAddressUnspent(context.Context, *connect.Request[v1.GetAddressUnspentRequest]) (*connect.Response[v1.GetAddressUnspentResponse], error)
-	BroadcastElectrumTransaction(context.Context, *connect.Request[v1.BroadcastElectrumTransactionRequest]) (*connect.Response[v1.BroadcastElectrumTransactionResponse], error)
-	// USB hardware wallets.
-	EnumerateHardwareDevices(context.Context, *connect.Request[v1.EnumerateHardwareDevicesRequest]) (*connect.Response[v1.EnumerateHardwareDevicesResponse], error)
-	GetHardwareXpub(context.Context, *connect.Request[v1.GetHardwareXpubRequest]) (*connect.Response[v1.GetHardwareXpubResponse], error)
-	SignPsbtWithDevice(context.Context, *connect.Request[v1.SignPsbtWithDeviceRequest]) (*connect.Response[v1.SignPsbtWithDeviceResponse], error)
-	// PromptDevicePin shows the PIN matrix; SendDevicePin unlocks with it.
-	PromptDevicePin(context.Context, *connect.Request[v1.PromptDevicePinRequest]) (*connect.Response[v1.PromptDevicePinResponse], error)
-	SendDevicePin(context.Context, *connect.Request[v1.SendDevicePinRequest]) (*connect.Response[v1.SendDevicePinResponse], error)
-	// CloseDevice releases the device so the next enumerate isn't blocked.
-	CloseDevice(context.Context, *connect.Request[v1.CloseDeviceRequest]) (*connect.Response[v1.CloseDeviceResponse], error)
-	// DeriveKeystore turns a keystore's intent into derived account key material.
-	DeriveKeystore(context.Context, *connect.Request[v1.DeriveKeystoreRequest]) (*connect.Response[v1.DeriveKeystoreResponse], error)
-	// PreviewWalletFromEntropy derives a wallet without saving it, so a caller can
-	// show the words while the user is still choosing their entropy.
-	PreviewWalletFromEntropy(context.Context, *connect.Request[v1.PreviewWalletFromEntropyRequest]) (*connect.Response[v1.PreviewWalletFromEntropyResponse], error)
-	// Seed access for cheque engine
-	GetWalletSeed(context.Context, *connect.Request[v1.GetWalletSeedRequest]) (*connect.Response[v1.GetWalletSeedResponse], error)
-	// Bitcoin Core variant selection (untouched / touched / knots).
-	ListCoreVariants(context.Context, *connect.Request[v1.ListCoreVariantsRequest]) (*connect.Response[v1.ListCoreVariantsResponse], error)
-	GetCoreVariant(context.Context, *connect.Request[v1.GetCoreVariantRequest]) (*connect.Response[v1.GetCoreVariantResponse], error)
-	SetCoreVariant(context.Context, *connect.Request[v1.SetCoreVariantRequest]) (*connect.Response[v1.SetCoreVariantResponse], error)
-	// Electrum server (Esplora endpoint) selection for electrum wallets.
-	GetElectrumServer(context.Context, *connect.Request[v1.GetElectrumServerRequest]) (*connect.Response[v1.GetElectrumServerResponse], error)
-	SetElectrumServer(context.Context, *connect.Request[v1.SetElectrumServerRequest]) (*connect.Response[v1.SetElectrumServerResponse], error)
-	// Tor SOCKS5 proxy routing for the electrum wallet's chain connections.
-	GetTorConfig(context.Context, *connect.Request[v1.GetTorConfigRequest]) (*connect.Response[v1.GetTorConfigResponse], error)
-	SetTorConfig(context.Context, *connect.Request[v1.SetTorConfigRequest]) (*connect.Response[v1.SetTorConfigResponse], error)
-	// Stream wallet state changes. Sends the full wallet state immediately,
-	// then again whenever wallets or balance change.
-	WatchWalletData(context.Context, *connect.Request[emptypb.Empty]) (*connect.ServerStreamForClient[v1.WatchWalletDataResponse], error)
+	GetWalletStatus(context.Context, *v1.GetWalletStatusRequest) (*v1.GetWalletStatusResponse, error)
+	ListSidechainDeposits(context.Context, *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error)
+	GetSidechainDepositTotals(context.Context, *v1.GetSidechainDepositTotalsRequest) (*v1.GetSidechainDepositTotalsResponse, error)
+	GetNodeMode(context.Context, *v1.GetNodeModeRequest) (*v1.GetNodeModeResponse, error)
+	SetNodeMode(context.Context, *v1.SetNodeModeRequest) (*v1.SetNodeModeResponse, error)
+	GenerateWallet(context.Context, *v1.GenerateWalletRequest) (*v1.GenerateWalletResponse, error)
+	UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error)
+	LockWallet(context.Context, *v1.LockWalletRequest) (*v1.LockWalletResponse, error)
+	EncryptWallet(context.Context, *v1.EncryptWalletRequest) (*v1.EncryptWalletResponse, error)
+	ChangePassword(context.Context, *v1.ChangePasswordRequest) (*v1.ChangePasswordResponse, error)
+	RemoveEncryption(context.Context, *v1.RemoveEncryptionRequest) (*v1.RemoveEncryptionResponse, error)
+	ListWallets(context.Context, *v1.ListWalletsRequest) (*v1.ListWalletsResponse, error)
+	SwitchWallet(context.Context, *v1.SwitchWalletRequest) (*v1.SwitchWalletResponse, error)
+	UpdateWalletMetadata(context.Context, *v1.UpdateWalletMetadataRequest) (*v1.UpdateWalletMetadataResponse, error)
+	DeleteWallet(context.Context, *v1.DeleteWalletRequest) (*v1.DeleteWalletResponse, error)
+	DeleteAllWallets(context.Context, *v1.DeleteAllWalletsRequest) (*v1.DeleteAllWalletsResponse, error)
+	ListWalletBackups(context.Context, *v1.ListWalletBackupsRequest) (*v1.ListWalletBackupsResponse, error)
+	RestoreWalletBackup(context.Context, *v1.RestoreWalletBackupRequest) (*v1.RestoreWalletBackupResponse, error)
+	RestoreWalletBackupStream(context.Context, *v1.RestoreWalletBackupRequest) (WalletManagerServiceRestoreWalletBackupStreamClientStream, error)
+	CreateWatchOnlyWallet(context.Context, *v1.CreateWatchOnlyWalletRequest) (*v1.CreateWatchOnlyWalletResponse, error)
+	CreateElectrumWallet(context.Context, *v1.CreateElectrumWalletRequest) (*v1.CreateElectrumWalletResponse, error)
+	CreateMultisigWallet(context.Context, *v1.CreateMultisigWalletRequest) (*v1.CreateMultisigWalletResponse, error)
+	ParseMultisigConfig(context.Context, *v1.ParseMultisigConfigRequest) (*v1.ParseMultisigConfigResponse, error)
+	ValidateDescriptor(context.Context, *v1.ValidateDescriptorRequest) (*v1.ValidateDescriptorResponse, error)
+	ValidateDerivationPath(context.Context, *v1.ValidateDerivationPathRequest) (*v1.ValidateDerivationPathResponse, error)
+	ListDerivationPaths(context.Context, *v1.ListDerivationPathsRequest) (*v1.ListDerivationPathsResponse, error)
+	CreateBitcoinCoreWallet(context.Context, *v1.CreateBitcoinCoreWalletRequest) (*v1.CreateBitcoinCoreWalletResponse, error)
+	EnsureCoreWallets(context.Context, *v1.EnsureCoreWalletsRequest) (*v1.EnsureCoreWalletsResponse, error)
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	RescanWallet(context.Context, *v1.RescanWalletRequest) (*v1.RescanWalletResponse, error)
+	EstimateFee(context.Context, *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error)
+	PreviewSend(context.Context, *v1.PreviewSendRequest) (*v1.PreviewSendResponse, error)
+	SetFrozenCoins(context.Context, *v1.SetFrozenCoinsRequest) (*emptypb.Empty, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	ListUnspent(context.Context, *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error)
+	ListReceiveAddresses(context.Context, *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error)
+	GetTransactionDetails(context.Context, *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error)
+	DecodeTransaction(context.Context, *v1.DecodeTransactionRequest) (*v1.DecodeTransactionResponse, error)
+	BumpFee(context.Context, *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error)
+	PreviewBumpFee(context.Context, *v1.PreviewBumpFeeRequest) (*v1.PreviewBumpFeeResponse, error)
+	CreateCpfp(context.Context, *v1.CreateCpfpRequest) (*v1.CreateCpfpResponse, error)
+	CancelTransaction(context.Context, *v1.CancelTransactionRequest) (*v1.CancelTransactionResponse, error)
+	DeriveAddresses(context.Context, *v1.DeriveAddressesRequest) (*v1.DeriveAddressesResponse, error)
+	CreatePsbt(context.Context, *v1.CreatePsbtRequest) (*v1.CreatePsbtResponse, error)
+	SignPsbt(context.Context, *v1.SignPsbtRequest) (*v1.SignPsbtResponse, error)
+	SignPsbtWithCosigner(context.Context, *v1.SignPsbtWithCosignerRequest) (*v1.SignPsbtWithCosignerResponse, error)
+	CombinePsbt(context.Context, *v1.CombinePsbtRequest) (*v1.CombinePsbtResponse, error)
+	FinalizePsbt(context.Context, *v1.FinalizePsbtRequest) (*v1.FinalizePsbtResponse, error)
+	MultisigPsbtStatus(context.Context, *v1.MultisigPsbtStatusRequest) (*v1.MultisigPsbtStatusResponse, error)
+	BroadcastTransaction(context.Context, *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error)
+	GetAddressUnspent(context.Context, *v1.GetAddressUnspentRequest) (*v1.GetAddressUnspentResponse, error)
+	BroadcastElectrumTransaction(context.Context, *v1.BroadcastElectrumTransactionRequest) (*v1.BroadcastElectrumTransactionResponse, error)
+	EnumerateHardwareDevices(context.Context, *v1.EnumerateHardwareDevicesRequest) (*v1.EnumerateHardwareDevicesResponse, error)
+	GetHardwareXpub(context.Context, *v1.GetHardwareXpubRequest) (*v1.GetHardwareXpubResponse, error)
+	SignPsbtWithDevice(context.Context, *v1.SignPsbtWithDeviceRequest) (*v1.SignPsbtWithDeviceResponse, error)
+	PromptDevicePin(context.Context, *v1.PromptDevicePinRequest) (*v1.PromptDevicePinResponse, error)
+	SendDevicePin(context.Context, *v1.SendDevicePinRequest) (*v1.SendDevicePinResponse, error)
+	CloseDevice(context.Context, *v1.CloseDeviceRequest) (*v1.CloseDeviceResponse, error)
+	DeriveKeystore(context.Context, *v1.DeriveKeystoreRequest) (*v1.DeriveKeystoreResponse, error)
+	PreviewWalletFromEntropy(context.Context, *v1.PreviewWalletFromEntropyRequest) (*v1.PreviewWalletFromEntropyResponse, error)
+	GetWalletSeed(context.Context, *v1.GetWalletSeedRequest) (*v1.GetWalletSeedResponse, error)
+	ListCoreVariants(context.Context, *v1.ListCoreVariantsRequest) (*v1.ListCoreVariantsResponse, error)
+	GetCoreVariant(context.Context, *v1.GetCoreVariantRequest) (*v1.GetCoreVariantResponse, error)
+	SetCoreVariant(context.Context, *v1.SetCoreVariantRequest) (*v1.SetCoreVariantResponse, error)
+	GetElectrumServer(context.Context, *v1.GetElectrumServerRequest) (*v1.GetElectrumServerResponse, error)
+	SetElectrumServer(context.Context, *v1.SetElectrumServerRequest) (*v1.SetElectrumServerResponse, error)
+	GetTorConfig(context.Context, *v1.GetTorConfigRequest) (*v1.GetTorConfigResponse, error)
+	SetTorConfig(context.Context, *v1.SetTorConfigRequest) (*v1.SetTorConfigResponse, error)
+	WatchWalletData(context.Context, *emptypb.Empty) (WalletManagerServiceWatchWalletDataClientStream, error)
 }
 
 // NewWalletManagerServiceClient constructs a client for the walletmanager.v1.WalletManagerService
-// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for
-// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply
-// the connect.WithGRPC() or connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewWalletManagerServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) WalletManagerServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	walletManagerServiceMethods := v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods()
-	return &walletManagerServiceClient{
-		getWalletStatus: connect.NewClient[v1.GetWalletStatusRequest, v1.GetWalletStatusResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetWalletStatusProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetWalletStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		listSidechainDeposits: connect.NewClient[v1.ListSidechainDepositsRequest, v1.ListSidechainDepositsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListSidechainDepositsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListSidechainDeposits")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainDepositTotals: connect.NewClient[v1.GetSidechainDepositTotalsRequest, v1.GetSidechainDepositTotalsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetSidechainDepositTotalsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetSidechainDepositTotals")),
-			connect.WithClientOptions(opts...),
-		),
-		getNodeMode: connect.NewClient[v1.GetNodeModeRequest, v1.GetNodeModeResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetNodeModeProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetNodeMode")),
-			connect.WithClientOptions(opts...),
-		),
-		setNodeMode: connect.NewClient[v1.SetNodeModeRequest, v1.SetNodeModeResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSetNodeModeProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SetNodeMode")),
-			connect.WithClientOptions(opts...),
-		),
-		generateWallet: connect.NewClient[v1.GenerateWalletRequest, v1.GenerateWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGenerateWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GenerateWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		unlockWallet: connect.NewClient[v1.UnlockWalletRequest, v1.UnlockWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceUnlockWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("UnlockWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		lockWallet: connect.NewClient[v1.LockWalletRequest, v1.LockWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceLockWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("LockWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		encryptWallet: connect.NewClient[v1.EncryptWalletRequest, v1.EncryptWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceEncryptWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("EncryptWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		changePassword: connect.NewClient[v1.ChangePasswordRequest, v1.ChangePasswordResponse](
-			httpClient,
-			baseURL+WalletManagerServiceChangePasswordProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ChangePassword")),
-			connect.WithClientOptions(opts...),
-		),
-		removeEncryption: connect.NewClient[v1.RemoveEncryptionRequest, v1.RemoveEncryptionResponse](
-			httpClient,
-			baseURL+WalletManagerServiceRemoveEncryptionProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("RemoveEncryption")),
-			connect.WithClientOptions(opts...),
-		),
-		listWallets: connect.NewClient[v1.ListWalletsRequest, v1.ListWalletsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListWalletsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListWallets")),
-			connect.WithClientOptions(opts...),
-		),
-		switchWallet: connect.NewClient[v1.SwitchWalletRequest, v1.SwitchWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSwitchWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SwitchWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		updateWalletMetadata: connect.NewClient[v1.UpdateWalletMetadataRequest, v1.UpdateWalletMetadataResponse](
-			httpClient,
-			baseURL+WalletManagerServiceUpdateWalletMetadataProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("UpdateWalletMetadata")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteWallet: connect.NewClient[v1.DeleteWalletRequest, v1.DeleteWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceDeleteWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("DeleteWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		deleteAllWallets: connect.NewClient[v1.DeleteAllWalletsRequest, v1.DeleteAllWalletsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceDeleteAllWalletsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("DeleteAllWallets")),
-			connect.WithClientOptions(opts...),
-		),
-		listWalletBackups: connect.NewClient[v1.ListWalletBackupsRequest, v1.ListWalletBackupsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListWalletBackupsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListWalletBackups")),
-			connect.WithClientOptions(opts...),
-		),
-		restoreWalletBackup: connect.NewClient[v1.RestoreWalletBackupRequest, v1.RestoreWalletBackupResponse](
-			httpClient,
-			baseURL+WalletManagerServiceRestoreWalletBackupProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("RestoreWalletBackup")),
-			connect.WithClientOptions(opts...),
-		),
-		restoreWalletBackupStream: connect.NewClient[v1.RestoreWalletBackupRequest, v1.RestoreWalletBackupProgressResponse](
-			httpClient,
-			baseURL+WalletManagerServiceRestoreWalletBackupStreamProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("RestoreWalletBackupStream")),
-			connect.WithClientOptions(opts...),
-		),
-		createWatchOnlyWallet: connect.NewClient[v1.CreateWatchOnlyWalletRequest, v1.CreateWatchOnlyWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCreateWatchOnlyWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CreateWatchOnlyWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		createElectrumWallet: connect.NewClient[v1.CreateElectrumWalletRequest, v1.CreateElectrumWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCreateElectrumWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CreateElectrumWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		createMultisigWallet: connect.NewClient[v1.CreateMultisigWalletRequest, v1.CreateMultisigWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCreateMultisigWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CreateMultisigWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		parseMultisigConfig: connect.NewClient[v1.ParseMultisigConfigRequest, v1.ParseMultisigConfigResponse](
-			httpClient,
-			baseURL+WalletManagerServiceParseMultisigConfigProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ParseMultisigConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		validateDescriptor: connect.NewClient[v1.ValidateDescriptorRequest, v1.ValidateDescriptorResponse](
-			httpClient,
-			baseURL+WalletManagerServiceValidateDescriptorProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ValidateDescriptor")),
-			connect.WithClientOptions(opts...),
-		),
-		validateDerivationPath: connect.NewClient[v1.ValidateDerivationPathRequest, v1.ValidateDerivationPathResponse](
-			httpClient,
-			baseURL+WalletManagerServiceValidateDerivationPathProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ValidateDerivationPath")),
-			connect.WithClientOptions(opts...),
-		),
-		listDerivationPaths: connect.NewClient[v1.ListDerivationPathsRequest, v1.ListDerivationPathsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListDerivationPathsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListDerivationPaths")),
-			connect.WithClientOptions(opts...),
-		),
-		createBitcoinCoreWallet: connect.NewClient[v1.CreateBitcoinCoreWalletRequest, v1.CreateBitcoinCoreWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCreateBitcoinCoreWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CreateBitcoinCoreWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		ensureCoreWallets: connect.NewClient[v1.EnsureCoreWalletsRequest, v1.EnsureCoreWalletsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceEnsureCoreWalletsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("EnsureCoreWallets")),
-			connect.WithClientOptions(opts...),
-		),
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetBalanceProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		rescanWallet: connect.NewClient[v1.RescanWalletRequest, v1.RescanWalletResponse](
-			httpClient,
-			baseURL+WalletManagerServiceRescanWalletProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("RescanWallet")),
-			connect.WithClientOptions(opts...),
-		),
-		estimateFee: connect.NewClient[v1.EstimateFeeRequest, v1.EstimateFeeResponse](
-			httpClient,
-			baseURL+WalletManagerServiceEstimateFeeProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("EstimateFee")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewAddress: connect.NewClient[v1.GetNewAddressRequest, v1.GetNewAddressResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetNewAddressProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetNewAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		sendTransaction: connect.NewClient[v1.SendTransactionRequest, v1.SendTransactionResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSendTransactionProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SendTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		previewSend: connect.NewClient[v1.PreviewSendRequest, v1.PreviewSendResponse](
-			httpClient,
-			baseURL+WalletManagerServicePreviewSendProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("PreviewSend")),
-			connect.WithClientOptions(opts...),
-		),
-		setFrozenCoins: connect.NewClient[v1.SetFrozenCoinsRequest, emptypb.Empty](
-			httpClient,
-			baseURL+WalletManagerServiceSetFrozenCoinsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SetFrozenCoins")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCreateDepositProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		listTransactions: connect.NewClient[v1.ListTransactionsRequest, v1.ListTransactionsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListTransactionsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListTransactions")),
-			connect.WithClientOptions(opts...),
-		),
-		listUnspent: connect.NewClient[v1.ListUnspentRequest, v1.ListUnspentResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListUnspentProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListUnspent")),
-			connect.WithClientOptions(opts...),
-		),
-		listReceiveAddresses: connect.NewClient[v1.ListReceiveAddressesRequest, v1.ListReceiveAddressesResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListReceiveAddressesProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListReceiveAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransactionDetails: connect.NewClient[v1.GetTransactionDetailsRequest, v1.GetTransactionDetailsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetTransactionDetailsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetTransactionDetails")),
-			connect.WithClientOptions(opts...),
-		),
-		decodeTransaction: connect.NewClient[v1.DecodeTransactionRequest, v1.DecodeTransactionResponse](
-			httpClient,
-			baseURL+WalletManagerServiceDecodeTransactionProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("DecodeTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		bumpFee: connect.NewClient[v1.BumpFeeRequest, v1.BumpFeeResponse](
-			httpClient,
-			baseURL+WalletManagerServiceBumpFeeProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("BumpFee")),
-			connect.WithClientOptions(opts...),
-		),
-		previewBumpFee: connect.NewClient[v1.PreviewBumpFeeRequest, v1.PreviewBumpFeeResponse](
-			httpClient,
-			baseURL+WalletManagerServicePreviewBumpFeeProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("PreviewBumpFee")),
-			connect.WithClientOptions(opts...),
-		),
-		createCpfp: connect.NewClient[v1.CreateCpfpRequest, v1.CreateCpfpResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCreateCpfpProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CreateCpfp")),
-			connect.WithClientOptions(opts...),
-		),
-		cancelTransaction: connect.NewClient[v1.CancelTransactionRequest, v1.CancelTransactionResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCancelTransactionProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CancelTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		deriveAddresses: connect.NewClient[v1.DeriveAddressesRequest, v1.DeriveAddressesResponse](
-			httpClient,
-			baseURL+WalletManagerServiceDeriveAddressesProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("DeriveAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		createPsbt: connect.NewClient[v1.CreatePsbtRequest, v1.CreatePsbtResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCreatePsbtProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CreatePsbt")),
-			connect.WithClientOptions(opts...),
-		),
-		signPsbt: connect.NewClient[v1.SignPsbtRequest, v1.SignPsbtResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSignPsbtProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SignPsbt")),
-			connect.WithClientOptions(opts...),
-		),
-		signPsbtWithCosigner: connect.NewClient[v1.SignPsbtWithCosignerRequest, v1.SignPsbtWithCosignerResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSignPsbtWithCosignerProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SignPsbtWithCosigner")),
-			connect.WithClientOptions(opts...),
-		),
-		combinePsbt: connect.NewClient[v1.CombinePsbtRequest, v1.CombinePsbtResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCombinePsbtProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CombinePsbt")),
-			connect.WithClientOptions(opts...),
-		),
-		finalizePsbt: connect.NewClient[v1.FinalizePsbtRequest, v1.FinalizePsbtResponse](
-			httpClient,
-			baseURL+WalletManagerServiceFinalizePsbtProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("FinalizePsbt")),
-			connect.WithClientOptions(opts...),
-		),
-		multisigPsbtStatus: connect.NewClient[v1.MultisigPsbtStatusRequest, v1.MultisigPsbtStatusResponse](
-			httpClient,
-			baseURL+WalletManagerServiceMultisigPsbtStatusProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("MultisigPsbtStatus")),
-			connect.WithClientOptions(opts...),
-		),
-		broadcastTransaction: connect.NewClient[v1.BroadcastTransactionRequest, v1.BroadcastTransactionResponse](
-			httpClient,
-			baseURL+WalletManagerServiceBroadcastTransactionProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("BroadcastTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		getAddressUnspent: connect.NewClient[v1.GetAddressUnspentRequest, v1.GetAddressUnspentResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetAddressUnspentProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetAddressUnspent")),
-			connect.WithClientOptions(opts...),
-		),
-		broadcastElectrumTransaction: connect.NewClient[v1.BroadcastElectrumTransactionRequest, v1.BroadcastElectrumTransactionResponse](
-			httpClient,
-			baseURL+WalletManagerServiceBroadcastElectrumTransactionProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("BroadcastElectrumTransaction")),
-			connect.WithClientOptions(opts...),
-		),
-		enumerateHardwareDevices: connect.NewClient[v1.EnumerateHardwareDevicesRequest, v1.EnumerateHardwareDevicesResponse](
-			httpClient,
-			baseURL+WalletManagerServiceEnumerateHardwareDevicesProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("EnumerateHardwareDevices")),
-			connect.WithClientOptions(opts...),
-		),
-		getHardwareXpub: connect.NewClient[v1.GetHardwareXpubRequest, v1.GetHardwareXpubResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetHardwareXpubProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetHardwareXpub")),
-			connect.WithClientOptions(opts...),
-		),
-		signPsbtWithDevice: connect.NewClient[v1.SignPsbtWithDeviceRequest, v1.SignPsbtWithDeviceResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSignPsbtWithDeviceProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SignPsbtWithDevice")),
-			connect.WithClientOptions(opts...),
-		),
-		promptDevicePin: connect.NewClient[v1.PromptDevicePinRequest, v1.PromptDevicePinResponse](
-			httpClient,
-			baseURL+WalletManagerServicePromptDevicePinProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("PromptDevicePin")),
-			connect.WithClientOptions(opts...),
-		),
-		sendDevicePin: connect.NewClient[v1.SendDevicePinRequest, v1.SendDevicePinResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSendDevicePinProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SendDevicePin")),
-			connect.WithClientOptions(opts...),
-		),
-		closeDevice: connect.NewClient[v1.CloseDeviceRequest, v1.CloseDeviceResponse](
-			httpClient,
-			baseURL+WalletManagerServiceCloseDeviceProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("CloseDevice")),
-			connect.WithClientOptions(opts...),
-		),
-		deriveKeystore: connect.NewClient[v1.DeriveKeystoreRequest, v1.DeriveKeystoreResponse](
-			httpClient,
-			baseURL+WalletManagerServiceDeriveKeystoreProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("DeriveKeystore")),
-			connect.WithClientOptions(opts...),
-		),
-		previewWalletFromEntropy: connect.NewClient[v1.PreviewWalletFromEntropyRequest, v1.PreviewWalletFromEntropyResponse](
-			httpClient,
-			baseURL+WalletManagerServicePreviewWalletFromEntropyProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("PreviewWalletFromEntropy")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletSeed: connect.NewClient[v1.GetWalletSeedRequest, v1.GetWalletSeedResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetWalletSeedProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetWalletSeed")),
-			connect.WithClientOptions(opts...),
-		),
-		listCoreVariants: connect.NewClient[v1.ListCoreVariantsRequest, v1.ListCoreVariantsResponse](
-			httpClient,
-			baseURL+WalletManagerServiceListCoreVariantsProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("ListCoreVariants")),
-			connect.WithClientOptions(opts...),
-		),
-		getCoreVariant: connect.NewClient[v1.GetCoreVariantRequest, v1.GetCoreVariantResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetCoreVariantProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetCoreVariant")),
-			connect.WithClientOptions(opts...),
-		),
-		setCoreVariant: connect.NewClient[v1.SetCoreVariantRequest, v1.SetCoreVariantResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSetCoreVariantProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SetCoreVariant")),
-			connect.WithClientOptions(opts...),
-		),
-		getElectrumServer: connect.NewClient[v1.GetElectrumServerRequest, v1.GetElectrumServerResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetElectrumServerProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetElectrumServer")),
-			connect.WithClientOptions(opts...),
-		),
-		setElectrumServer: connect.NewClient[v1.SetElectrumServerRequest, v1.SetElectrumServerResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSetElectrumServerProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SetElectrumServer")),
-			connect.WithClientOptions(opts...),
-		),
-		getTorConfig: connect.NewClient[v1.GetTorConfigRequest, v1.GetTorConfigResponse](
-			httpClient,
-			baseURL+WalletManagerServiceGetTorConfigProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("GetTorConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		setTorConfig: connect.NewClient[v1.SetTorConfigRequest, v1.SetTorConfigResponse](
-			httpClient,
-			baseURL+WalletManagerServiceSetTorConfigProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("SetTorConfig")),
-			connect.WithClientOptions(opts...),
-		),
-		watchWalletData: connect.NewClient[emptypb.Empty, v1.WatchWalletDataResponse](
-			httpClient,
-			baseURL+WalletManagerServiceWatchWalletDataProcedure,
-			connect.WithSchema(walletManagerServiceMethods.ByName("WatchWalletData")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// walletManagerServiceClient implements WalletManagerServiceClient.
-type walletManagerServiceClient struct {
-	getWalletStatus              *connect.Client[v1.GetWalletStatusRequest, v1.GetWalletStatusResponse]
-	listSidechainDeposits        *connect.Client[v1.ListSidechainDepositsRequest, v1.ListSidechainDepositsResponse]
-	getSidechainDepositTotals    *connect.Client[v1.GetSidechainDepositTotalsRequest, v1.GetSidechainDepositTotalsResponse]
-	getNodeMode                  *connect.Client[v1.GetNodeModeRequest, v1.GetNodeModeResponse]
-	setNodeMode                  *connect.Client[v1.SetNodeModeRequest, v1.SetNodeModeResponse]
-	generateWallet               *connect.Client[v1.GenerateWalletRequest, v1.GenerateWalletResponse]
-	unlockWallet                 *connect.Client[v1.UnlockWalletRequest, v1.UnlockWalletResponse]
-	lockWallet                   *connect.Client[v1.LockWalletRequest, v1.LockWalletResponse]
-	encryptWallet                *connect.Client[v1.EncryptWalletRequest, v1.EncryptWalletResponse]
-	changePassword               *connect.Client[v1.ChangePasswordRequest, v1.ChangePasswordResponse]
-	removeEncryption             *connect.Client[v1.RemoveEncryptionRequest, v1.RemoveEncryptionResponse]
-	listWallets                  *connect.Client[v1.ListWalletsRequest, v1.ListWalletsResponse]
-	switchWallet                 *connect.Client[v1.SwitchWalletRequest, v1.SwitchWalletResponse]
-	updateWalletMetadata         *connect.Client[v1.UpdateWalletMetadataRequest, v1.UpdateWalletMetadataResponse]
-	deleteWallet                 *connect.Client[v1.DeleteWalletRequest, v1.DeleteWalletResponse]
-	deleteAllWallets             *connect.Client[v1.DeleteAllWalletsRequest, v1.DeleteAllWalletsResponse]
-	listWalletBackups            *connect.Client[v1.ListWalletBackupsRequest, v1.ListWalletBackupsResponse]
-	restoreWalletBackup          *connect.Client[v1.RestoreWalletBackupRequest, v1.RestoreWalletBackupResponse]
-	restoreWalletBackupStream    *connect.Client[v1.RestoreWalletBackupRequest, v1.RestoreWalletBackupProgressResponse]
-	createWatchOnlyWallet        *connect.Client[v1.CreateWatchOnlyWalletRequest, v1.CreateWatchOnlyWalletResponse]
-	createElectrumWallet         *connect.Client[v1.CreateElectrumWalletRequest, v1.CreateElectrumWalletResponse]
-	createMultisigWallet         *connect.Client[v1.CreateMultisigWalletRequest, v1.CreateMultisigWalletResponse]
-	parseMultisigConfig          *connect.Client[v1.ParseMultisigConfigRequest, v1.ParseMultisigConfigResponse]
-	validateDescriptor           *connect.Client[v1.ValidateDescriptorRequest, v1.ValidateDescriptorResponse]
-	validateDerivationPath       *connect.Client[v1.ValidateDerivationPathRequest, v1.ValidateDerivationPathResponse]
-	listDerivationPaths          *connect.Client[v1.ListDerivationPathsRequest, v1.ListDerivationPathsResponse]
-	createBitcoinCoreWallet      *connect.Client[v1.CreateBitcoinCoreWalletRequest, v1.CreateBitcoinCoreWalletResponse]
-	ensureCoreWallets            *connect.Client[v1.EnsureCoreWalletsRequest, v1.EnsureCoreWalletsResponse]
-	getBalance                   *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	rescanWallet                 *connect.Client[v1.RescanWalletRequest, v1.RescanWalletResponse]
-	estimateFee                  *connect.Client[v1.EstimateFeeRequest, v1.EstimateFeeResponse]
-	getNewAddress                *connect.Client[v1.GetNewAddressRequest, v1.GetNewAddressResponse]
-	sendTransaction              *connect.Client[v1.SendTransactionRequest, v1.SendTransactionResponse]
-	previewSend                  *connect.Client[v1.PreviewSendRequest, v1.PreviewSendResponse]
-	setFrozenCoins               *connect.Client[v1.SetFrozenCoinsRequest, emptypb.Empty]
-	createDeposit                *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	listTransactions             *connect.Client[v1.ListTransactionsRequest, v1.ListTransactionsResponse]
-	listUnspent                  *connect.Client[v1.ListUnspentRequest, v1.ListUnspentResponse]
-	listReceiveAddresses         *connect.Client[v1.ListReceiveAddressesRequest, v1.ListReceiveAddressesResponse]
-	getTransactionDetails        *connect.Client[v1.GetTransactionDetailsRequest, v1.GetTransactionDetailsResponse]
-	decodeTransaction            *connect.Client[v1.DecodeTransactionRequest, v1.DecodeTransactionResponse]
-	bumpFee                      *connect.Client[v1.BumpFeeRequest, v1.BumpFeeResponse]
-	previewBumpFee               *connect.Client[v1.PreviewBumpFeeRequest, v1.PreviewBumpFeeResponse]
-	createCpfp                   *connect.Client[v1.CreateCpfpRequest, v1.CreateCpfpResponse]
-	cancelTransaction            *connect.Client[v1.CancelTransactionRequest, v1.CancelTransactionResponse]
-	deriveAddresses              *connect.Client[v1.DeriveAddressesRequest, v1.DeriveAddressesResponse]
-	createPsbt                   *connect.Client[v1.CreatePsbtRequest, v1.CreatePsbtResponse]
-	signPsbt                     *connect.Client[v1.SignPsbtRequest, v1.SignPsbtResponse]
-	signPsbtWithCosigner         *connect.Client[v1.SignPsbtWithCosignerRequest, v1.SignPsbtWithCosignerResponse]
-	combinePsbt                  *connect.Client[v1.CombinePsbtRequest, v1.CombinePsbtResponse]
-	finalizePsbt                 *connect.Client[v1.FinalizePsbtRequest, v1.FinalizePsbtResponse]
-	multisigPsbtStatus           *connect.Client[v1.MultisigPsbtStatusRequest, v1.MultisigPsbtStatusResponse]
-	broadcastTransaction         *connect.Client[v1.BroadcastTransactionRequest, v1.BroadcastTransactionResponse]
-	getAddressUnspent            *connect.Client[v1.GetAddressUnspentRequest, v1.GetAddressUnspentResponse]
-	broadcastElectrumTransaction *connect.Client[v1.BroadcastElectrumTransactionRequest, v1.BroadcastElectrumTransactionResponse]
-	enumerateHardwareDevices     *connect.Client[v1.EnumerateHardwareDevicesRequest, v1.EnumerateHardwareDevicesResponse]
-	getHardwareXpub              *connect.Client[v1.GetHardwareXpubRequest, v1.GetHardwareXpubResponse]
-	signPsbtWithDevice           *connect.Client[v1.SignPsbtWithDeviceRequest, v1.SignPsbtWithDeviceResponse]
-	promptDevicePin              *connect.Client[v1.PromptDevicePinRequest, v1.PromptDevicePinResponse]
-	sendDevicePin                *connect.Client[v1.SendDevicePinRequest, v1.SendDevicePinResponse]
-	closeDevice                  *connect.Client[v1.CloseDeviceRequest, v1.CloseDeviceResponse]
-	deriveKeystore               *connect.Client[v1.DeriveKeystoreRequest, v1.DeriveKeystoreResponse]
-	previewWalletFromEntropy     *connect.Client[v1.PreviewWalletFromEntropyRequest, v1.PreviewWalletFromEntropyResponse]
-	getWalletSeed                *connect.Client[v1.GetWalletSeedRequest, v1.GetWalletSeedResponse]
-	listCoreVariants             *connect.Client[v1.ListCoreVariantsRequest, v1.ListCoreVariantsResponse]
-	getCoreVariant               *connect.Client[v1.GetCoreVariantRequest, v1.GetCoreVariantResponse]
-	setCoreVariant               *connect.Client[v1.SetCoreVariantRequest, v1.SetCoreVariantResponse]
-	getElectrumServer            *connect.Client[v1.GetElectrumServerRequest, v1.GetElectrumServerResponse]
-	setElectrumServer            *connect.Client[v1.SetElectrumServerRequest, v1.SetElectrumServerResponse]
-	getTorConfig                 *connect.Client[v1.GetTorConfigRequest, v1.GetTorConfigResponse]
-	setTorConfig                 *connect.Client[v1.SetTorConfigRequest, v1.SetTorConfigResponse]
-	watchWalletData              *connect.Client[emptypb.Empty, v1.WatchWalletDataResponse]
-}
-
-// GetWalletStatus calls walletmanager.v1.WalletManagerService.GetWalletStatus.
-func (c *walletManagerServiceClient) GetWalletStatus(ctx context.Context, req *connect.Request[v1.GetWalletStatusRequest]) (*connect.Response[v1.GetWalletStatusResponse], error) {
-	return c.getWalletStatus.CallUnary(ctx, req)
-}
-
-// ListSidechainDeposits calls walletmanager.v1.WalletManagerService.ListSidechainDeposits.
-func (c *walletManagerServiceClient) ListSidechainDeposits(ctx context.Context, req *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error) {
-	return c.listSidechainDeposits.CallUnary(ctx, req)
+// service. Multiple service clients may share a single connect.Client.
+func NewWalletManagerServiceClient(client *connect.Client) WalletManagerServiceClient {
+	return &walletManagerServiceClient{client: client}
 }
 
-// GetSidechainDepositTotals calls walletmanager.v1.WalletManagerService.GetSidechainDepositTotals.
-func (c *walletManagerServiceClient) GetSidechainDepositTotals(ctx context.Context, req *connect.Request[v1.GetSidechainDepositTotalsRequest]) (*connect.Response[v1.GetSidechainDepositTotalsResponse], error) {
-	return c.getSidechainDepositTotals.CallUnary(ctx, req)
+// WalletManagerServiceRestoreWalletBackupStreamClientStream is the client stream for the
+// WalletManagerService's RestoreWalletBackupStream RPC.
+type WalletManagerServiceRestoreWalletBackupStreamClientStream struct {
+	stream connect.ClientStream
 }
 
-// GetNodeMode calls walletmanager.v1.WalletManagerService.GetNodeMode.
-func (c *walletManagerServiceClient) GetNodeMode(ctx context.Context, req *connect.Request[v1.GetNodeModeRequest]) (*connect.Response[v1.GetNodeModeResponse], error) {
-	return c.getNodeMode.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s WalletManagerServiceRestoreWalletBackupStreamClientStream) Receive() (*v1.RestoreWalletBackupProgressResponse, error) {
+	var res v1.RestoreWalletBackupProgressResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// SetNodeMode calls walletmanager.v1.WalletManagerService.SetNodeMode.
-func (c *walletManagerServiceClient) SetNodeMode(ctx context.Context, req *connect.Request[v1.SetNodeModeRequest]) (*connect.Response[v1.SetNodeModeResponse], error) {
-	return c.setNodeMode.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s WalletManagerServiceRestoreWalletBackupStreamClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// GenerateWallet calls walletmanager.v1.WalletManagerService.GenerateWallet.
-func (c *walletManagerServiceClient) GenerateWallet(ctx context.Context, req *connect.Request[v1.GenerateWalletRequest]) (*connect.Response[v1.GenerateWalletResponse], error) {
-	return c.generateWallet.CallUnary(ctx, req)
+// WalletManagerServiceWatchWalletDataClientStream is the client stream for the
+// WalletManagerService's WatchWalletData RPC.
+type WalletManagerServiceWatchWalletDataClientStream struct {
+	stream connect.ClientStream
 }
 
-// UnlockWallet calls walletmanager.v1.WalletManagerService.UnlockWallet.
-func (c *walletManagerServiceClient) UnlockWallet(ctx context.Context, req *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error) {
-	return c.unlockWallet.CallUnary(ctx, req)
+// Receive returns the next response message from the server.
+func (s WalletManagerServiceWatchWalletDataClientStream) Receive() (*v1.WatchWalletDataResponse, error) {
+	var res v1.WatchWalletDataResponse
+	if err := s.stream.Receive(&res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-// LockWallet calls walletmanager.v1.WalletManagerService.LockWallet.
-func (c *walletManagerServiceClient) LockWallet(ctx context.Context, req *connect.Request[v1.LockWalletRequest]) (*connect.Response[v1.LockWalletResponse], error) {
-	return c.lockWallet.CallUnary(ctx, req)
+// Close releases the stream's resources. It is idempotent and is typically deferred to clean up a
+// stream abandoned before io.EOF.
+func (s WalletManagerServiceWatchWalletDataClientStream) Close() error {
+	return s.stream.Close()
 }
 
-// EncryptWallet calls walletmanager.v1.WalletManagerService.EncryptWallet.
-func (c *walletManagerServiceClient) EncryptWallet(ctx context.Context, req *connect.Request[v1.EncryptWalletRequest]) (*connect.Response[v1.EncryptWalletResponse], error) {
-	return c.encryptWallet.CallUnary(ctx, req)
+// WalletManagerServiceHandler is an implementation of the walletmanager.v1.WalletManagerService
+// service.
+type WalletManagerServiceHandler interface {
+	GetWalletStatus(context.Context, *v1.GetWalletStatusRequest) (*v1.GetWalletStatusResponse, error)
+	ListSidechainDeposits(context.Context, *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error)
+	GetSidechainDepositTotals(context.Context, *v1.GetSidechainDepositTotalsRequest) (*v1.GetSidechainDepositTotalsResponse, error)
+	GetNodeMode(context.Context, *v1.GetNodeModeRequest) (*v1.GetNodeModeResponse, error)
+	SetNodeMode(context.Context, *v1.SetNodeModeRequest) (*v1.SetNodeModeResponse, error)
+	GenerateWallet(context.Context, *v1.GenerateWalletRequest) (*v1.GenerateWalletResponse, error)
+	UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error)
+	LockWallet(context.Context, *v1.LockWalletRequest) (*v1.LockWalletResponse, error)
+	EncryptWallet(context.Context, *v1.EncryptWalletRequest) (*v1.EncryptWalletResponse, error)
+	ChangePassword(context.Context, *v1.ChangePasswordRequest) (*v1.ChangePasswordResponse, error)
+	RemoveEncryption(context.Context, *v1.RemoveEncryptionRequest) (*v1.RemoveEncryptionResponse, error)
+	ListWallets(context.Context, *v1.ListWalletsRequest) (*v1.ListWalletsResponse, error)
+	SwitchWallet(context.Context, *v1.SwitchWalletRequest) (*v1.SwitchWalletResponse, error)
+	UpdateWalletMetadata(context.Context, *v1.UpdateWalletMetadataRequest) (*v1.UpdateWalletMetadataResponse, error)
+	DeleteWallet(context.Context, *v1.DeleteWalletRequest) (*v1.DeleteWalletResponse, error)
+	DeleteAllWallets(context.Context, *v1.DeleteAllWalletsRequest) (*v1.DeleteAllWalletsResponse, error)
+	ListWalletBackups(context.Context, *v1.ListWalletBackupsRequest) (*v1.ListWalletBackupsResponse, error)
+	RestoreWalletBackup(context.Context, *v1.RestoreWalletBackupRequest) (*v1.RestoreWalletBackupResponse, error)
+	RestoreWalletBackupStream(context.Context, *v1.RestoreWalletBackupRequest, WalletManagerServiceRestoreWalletBackupStreamServerStream) error
+	CreateWatchOnlyWallet(context.Context, *v1.CreateWatchOnlyWalletRequest) (*v1.CreateWatchOnlyWalletResponse, error)
+	CreateElectrumWallet(context.Context, *v1.CreateElectrumWalletRequest) (*v1.CreateElectrumWalletResponse, error)
+	CreateMultisigWallet(context.Context, *v1.CreateMultisigWalletRequest) (*v1.CreateMultisigWalletResponse, error)
+	ParseMultisigConfig(context.Context, *v1.ParseMultisigConfigRequest) (*v1.ParseMultisigConfigResponse, error)
+	ValidateDescriptor(context.Context, *v1.ValidateDescriptorRequest) (*v1.ValidateDescriptorResponse, error)
+	ValidateDerivationPath(context.Context, *v1.ValidateDerivationPathRequest) (*v1.ValidateDerivationPathResponse, error)
+	ListDerivationPaths(context.Context, *v1.ListDerivationPathsRequest) (*v1.ListDerivationPathsResponse, error)
+	CreateBitcoinCoreWallet(context.Context, *v1.CreateBitcoinCoreWalletRequest) (*v1.CreateBitcoinCoreWalletResponse, error)
+	EnsureCoreWallets(context.Context, *v1.EnsureCoreWalletsRequest) (*v1.EnsureCoreWalletsResponse, error)
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	RescanWallet(context.Context, *v1.RescanWalletRequest) (*v1.RescanWalletResponse, error)
+	EstimateFee(context.Context, *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error)
+	GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error)
+	SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error)
+	PreviewSend(context.Context, *v1.PreviewSendRequest) (*v1.PreviewSendResponse, error)
+	SetFrozenCoins(context.Context, *v1.SetFrozenCoinsRequest) (*emptypb.Empty, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error)
+	ListUnspent(context.Context, *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error)
+	ListReceiveAddresses(context.Context, *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error)
+	GetTransactionDetails(context.Context, *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error)
+	DecodeTransaction(context.Context, *v1.DecodeTransactionRequest) (*v1.DecodeTransactionResponse, error)
+	BumpFee(context.Context, *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error)
+	PreviewBumpFee(context.Context, *v1.PreviewBumpFeeRequest) (*v1.PreviewBumpFeeResponse, error)
+	CreateCpfp(context.Context, *v1.CreateCpfpRequest) (*v1.CreateCpfpResponse, error)
+	CancelTransaction(context.Context, *v1.CancelTransactionRequest) (*v1.CancelTransactionResponse, error)
+	DeriveAddresses(context.Context, *v1.DeriveAddressesRequest) (*v1.DeriveAddressesResponse, error)
+	CreatePsbt(context.Context, *v1.CreatePsbtRequest) (*v1.CreatePsbtResponse, error)
+	SignPsbt(context.Context, *v1.SignPsbtRequest) (*v1.SignPsbtResponse, error)
+	SignPsbtWithCosigner(context.Context, *v1.SignPsbtWithCosignerRequest) (*v1.SignPsbtWithCosignerResponse, error)
+	CombinePsbt(context.Context, *v1.CombinePsbtRequest) (*v1.CombinePsbtResponse, error)
+	FinalizePsbt(context.Context, *v1.FinalizePsbtRequest) (*v1.FinalizePsbtResponse, error)
+	MultisigPsbtStatus(context.Context, *v1.MultisigPsbtStatusRequest) (*v1.MultisigPsbtStatusResponse, error)
+	BroadcastTransaction(context.Context, *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error)
+	GetAddressUnspent(context.Context, *v1.GetAddressUnspentRequest) (*v1.GetAddressUnspentResponse, error)
+	BroadcastElectrumTransaction(context.Context, *v1.BroadcastElectrumTransactionRequest) (*v1.BroadcastElectrumTransactionResponse, error)
+	EnumerateHardwareDevices(context.Context, *v1.EnumerateHardwareDevicesRequest) (*v1.EnumerateHardwareDevicesResponse, error)
+	GetHardwareXpub(context.Context, *v1.GetHardwareXpubRequest) (*v1.GetHardwareXpubResponse, error)
+	SignPsbtWithDevice(context.Context, *v1.SignPsbtWithDeviceRequest) (*v1.SignPsbtWithDeviceResponse, error)
+	PromptDevicePin(context.Context, *v1.PromptDevicePinRequest) (*v1.PromptDevicePinResponse, error)
+	SendDevicePin(context.Context, *v1.SendDevicePinRequest) (*v1.SendDevicePinResponse, error)
+	CloseDevice(context.Context, *v1.CloseDeviceRequest) (*v1.CloseDeviceResponse, error)
+	DeriveKeystore(context.Context, *v1.DeriveKeystoreRequest) (*v1.DeriveKeystoreResponse, error)
+	PreviewWalletFromEntropy(context.Context, *v1.PreviewWalletFromEntropyRequest) (*v1.PreviewWalletFromEntropyResponse, error)
+	GetWalletSeed(context.Context, *v1.GetWalletSeedRequest) (*v1.GetWalletSeedResponse, error)
+	ListCoreVariants(context.Context, *v1.ListCoreVariantsRequest) (*v1.ListCoreVariantsResponse, error)
+	GetCoreVariant(context.Context, *v1.GetCoreVariantRequest) (*v1.GetCoreVariantResponse, error)
+	SetCoreVariant(context.Context, *v1.SetCoreVariantRequest) (*v1.SetCoreVariantResponse, error)
+	GetElectrumServer(context.Context, *v1.GetElectrumServerRequest) (*v1.GetElectrumServerResponse, error)
+	SetElectrumServer(context.Context, *v1.SetElectrumServerRequest) (*v1.SetElectrumServerResponse, error)
+	GetTorConfig(context.Context, *v1.GetTorConfigRequest) (*v1.GetTorConfigResponse, error)
+	SetTorConfig(context.Context, *v1.SetTorConfigRequest) (*v1.SetTorConfigResponse, error)
+	WatchWalletData(context.Context, *emptypb.Empty, WalletManagerServiceWatchWalletDataServerStream) error
+}
+
+// RegisterWalletManagerServiceHandler registers svc as the walletmanager.v1.WalletManagerService
+// implementation on server.
+func RegisterWalletManagerServiceHandler(server *connect.Server, svc WalletManagerServiceHandler) {
+	adapter := walletManagerServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: walletManagerServiceGetWalletStatusSpec(), Handler: adapter.getWalletStatus},
+		connect.Method{Spec: walletManagerServiceListSidechainDepositsSpec(), Handler: adapter.listSidechainDeposits},
+		connect.Method{Spec: walletManagerServiceGetSidechainDepositTotalsSpec(), Handler: adapter.getSidechainDepositTotals},
+		connect.Method{Spec: walletManagerServiceGetNodeModeSpec(), Handler: adapter.getNodeMode},
+		connect.Method{Spec: walletManagerServiceSetNodeModeSpec(), Handler: adapter.setNodeMode},
+		connect.Method{Spec: walletManagerServiceGenerateWalletSpec(), Handler: adapter.generateWallet},
+		connect.Method{Spec: walletManagerServiceUnlockWalletSpec(), Handler: adapter.unlockWallet},
+		connect.Method{Spec: walletManagerServiceLockWalletSpec(), Handler: adapter.lockWallet},
+		connect.Method{Spec: walletManagerServiceEncryptWalletSpec(), Handler: adapter.encryptWallet},
+		connect.Method{Spec: walletManagerServiceChangePasswordSpec(), Handler: adapter.changePassword},
+		connect.Method{Spec: walletManagerServiceRemoveEncryptionSpec(), Handler: adapter.removeEncryption},
+		connect.Method{Spec: walletManagerServiceListWalletsSpec(), Handler: adapter.listWallets},
+		connect.Method{Spec: walletManagerServiceSwitchWalletSpec(), Handler: adapter.switchWallet},
+		connect.Method{Spec: walletManagerServiceUpdateWalletMetadataSpec(), Handler: adapter.updateWalletMetadata},
+		connect.Method{Spec: walletManagerServiceDeleteWalletSpec(), Handler: adapter.deleteWallet},
+		connect.Method{Spec: walletManagerServiceDeleteAllWalletsSpec(), Handler: adapter.deleteAllWallets},
+		connect.Method{Spec: walletManagerServiceListWalletBackupsSpec(), Handler: adapter.listWalletBackups},
+		connect.Method{Spec: walletManagerServiceRestoreWalletBackupSpec(), Handler: adapter.restoreWalletBackup},
+		connect.Method{Spec: walletManagerServiceRestoreWalletBackupStreamSpec(), Handler: adapter.restoreWalletBackupStream},
+		connect.Method{Spec: walletManagerServiceCreateWatchOnlyWalletSpec(), Handler: adapter.createWatchOnlyWallet},
+		connect.Method{Spec: walletManagerServiceCreateElectrumWalletSpec(), Handler: adapter.createElectrumWallet},
+		connect.Method{Spec: walletManagerServiceCreateMultisigWalletSpec(), Handler: adapter.createMultisigWallet},
+		connect.Method{Spec: walletManagerServiceParseMultisigConfigSpec(), Handler: adapter.parseMultisigConfig},
+		connect.Method{Spec: walletManagerServiceValidateDescriptorSpec(), Handler: adapter.validateDescriptor},
+		connect.Method{Spec: walletManagerServiceValidateDerivationPathSpec(), Handler: adapter.validateDerivationPath},
+		connect.Method{Spec: walletManagerServiceListDerivationPathsSpec(), Handler: adapter.listDerivationPaths},
+		connect.Method{Spec: walletManagerServiceCreateBitcoinCoreWalletSpec(), Handler: adapter.createBitcoinCoreWallet},
+		connect.Method{Spec: walletManagerServiceEnsureCoreWalletsSpec(), Handler: adapter.ensureCoreWallets},
+		connect.Method{Spec: walletManagerServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: walletManagerServiceRescanWalletSpec(), Handler: adapter.rescanWallet},
+		connect.Method{Spec: walletManagerServiceEstimateFeeSpec(), Handler: adapter.estimateFee},
+		connect.Method{Spec: walletManagerServiceGetNewAddressSpec(), Handler: adapter.getNewAddress},
+		connect.Method{Spec: walletManagerServiceSendTransactionSpec(), Handler: adapter.sendTransaction},
+		connect.Method{Spec: walletManagerServicePreviewSendSpec(), Handler: adapter.previewSend},
+		connect.Method{Spec: walletManagerServiceSetFrozenCoinsSpec(), Handler: adapter.setFrozenCoins},
+		connect.Method{Spec: walletManagerServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: walletManagerServiceListTransactionsSpec(), Handler: adapter.listTransactions},
+		connect.Method{Spec: walletManagerServiceListUnspentSpec(), Handler: adapter.listUnspent},
+		connect.Method{Spec: walletManagerServiceListReceiveAddressesSpec(), Handler: adapter.listReceiveAddresses},
+		connect.Method{Spec: walletManagerServiceGetTransactionDetailsSpec(), Handler: adapter.getTransactionDetails},
+		connect.Method{Spec: walletManagerServiceDecodeTransactionSpec(), Handler: adapter.decodeTransaction},
+		connect.Method{Spec: walletManagerServiceBumpFeeSpec(), Handler: adapter.bumpFee},
+		connect.Method{Spec: walletManagerServicePreviewBumpFeeSpec(), Handler: adapter.previewBumpFee},
+		connect.Method{Spec: walletManagerServiceCreateCpfpSpec(), Handler: adapter.createCpfp},
+		connect.Method{Spec: walletManagerServiceCancelTransactionSpec(), Handler: adapter.cancelTransaction},
+		connect.Method{Spec: walletManagerServiceDeriveAddressesSpec(), Handler: adapter.deriveAddresses},
+		connect.Method{Spec: walletManagerServiceCreatePsbtSpec(), Handler: adapter.createPsbt},
+		connect.Method{Spec: walletManagerServiceSignPsbtSpec(), Handler: adapter.signPsbt},
+		connect.Method{Spec: walletManagerServiceSignPsbtWithCosignerSpec(), Handler: adapter.signPsbtWithCosigner},
+		connect.Method{Spec: walletManagerServiceCombinePsbtSpec(), Handler: adapter.combinePsbt},
+		connect.Method{Spec: walletManagerServiceFinalizePsbtSpec(), Handler: adapter.finalizePsbt},
+		connect.Method{Spec: walletManagerServiceMultisigPsbtStatusSpec(), Handler: adapter.multisigPsbtStatus},
+		connect.Method{Spec: walletManagerServiceBroadcastTransactionSpec(), Handler: adapter.broadcastTransaction},
+		connect.Method{Spec: walletManagerServiceGetAddressUnspentSpec(), Handler: adapter.getAddressUnspent},
+		connect.Method{Spec: walletManagerServiceBroadcastElectrumTransactionSpec(), Handler: adapter.broadcastElectrumTransaction},
+		connect.Method{Spec: walletManagerServiceEnumerateHardwareDevicesSpec(), Handler: adapter.enumerateHardwareDevices},
+		connect.Method{Spec: walletManagerServiceGetHardwareXpubSpec(), Handler: adapter.getHardwareXpub},
+		connect.Method{Spec: walletManagerServiceSignPsbtWithDeviceSpec(), Handler: adapter.signPsbtWithDevice},
+		connect.Method{Spec: walletManagerServicePromptDevicePinSpec(), Handler: adapter.promptDevicePin},
+		connect.Method{Spec: walletManagerServiceSendDevicePinSpec(), Handler: adapter.sendDevicePin},
+		connect.Method{Spec: walletManagerServiceCloseDeviceSpec(), Handler: adapter.closeDevice},
+		connect.Method{Spec: walletManagerServiceDeriveKeystoreSpec(), Handler: adapter.deriveKeystore},
+		connect.Method{Spec: walletManagerServicePreviewWalletFromEntropySpec(), Handler: adapter.previewWalletFromEntropy},
+		connect.Method{Spec: walletManagerServiceGetWalletSeedSpec(), Handler: adapter.getWalletSeed},
+		connect.Method{Spec: walletManagerServiceListCoreVariantsSpec(), Handler: adapter.listCoreVariants},
+		connect.Method{Spec: walletManagerServiceGetCoreVariantSpec(), Handler: adapter.getCoreVariant},
+		connect.Method{Spec: walletManagerServiceSetCoreVariantSpec(), Handler: adapter.setCoreVariant},
+		connect.Method{Spec: walletManagerServiceGetElectrumServerSpec(), Handler: adapter.getElectrumServer},
+		connect.Method{Spec: walletManagerServiceSetElectrumServerSpec(), Handler: adapter.setElectrumServer},
+		connect.Method{Spec: walletManagerServiceGetTorConfigSpec(), Handler: adapter.getTorConfig},
+		connect.Method{Spec: walletManagerServiceSetTorConfigSpec(), Handler: adapter.setTorConfig},
+		connect.Method{Spec: walletManagerServiceWatchWalletDataSpec(), Handler: adapter.watchWalletData},
+	)
+}
+
+// WalletManagerServiceRestoreWalletBackupStreamServerStream is the server stream for the
+// WalletManagerService's RestoreWalletBackupStream RPC.
+type WalletManagerServiceRestoreWalletBackupStreamServerStream struct {
+	stream connect.ServerStream
+}
+
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s WalletManagerServiceRestoreWalletBackupStreamServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
+}
+
+// Send sends a response message to the client.
+func (s WalletManagerServiceRestoreWalletBackupStreamServerStream) Send(res *v1.RestoreWalletBackupProgressResponse) error {
+	return s.stream.Send(res)
+}
+
+// WalletManagerServiceWatchWalletDataServerStream is the server stream for the
+// WalletManagerService's WatchWalletData RPC.
+type WalletManagerServiceWatchWalletDataServerStream struct {
+	stream connect.ServerStream
+}
+
+// SendHeaders flushes the response headers without a message. The first Send does this implicitly.
+func (s WalletManagerServiceWatchWalletDataServerStream) SendHeaders() error {
+	return s.stream.SendHeaders()
+}
+
+// Send sends a response message to the client.
+func (s WalletManagerServiceWatchWalletDataServerStream) Send(res *v1.WatchWalletDataResponse) error {
+	return s.stream.Send(res)
 }
 
-// ChangePassword calls walletmanager.v1.WalletManagerService.ChangePassword.
-func (c *walletManagerServiceClient) ChangePassword(ctx context.Context, req *connect.Request[v1.ChangePasswordRequest]) (*connect.Response[v1.ChangePasswordResponse], error) {
-	return c.changePassword.CallUnary(ctx, req)
-}
+// UnimplementedWalletManagerServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedWalletManagerServiceHandler struct{}
 
-// RemoveEncryption calls walletmanager.v1.WalletManagerService.RemoveEncryption.
-func (c *walletManagerServiceClient) RemoveEncryption(ctx context.Context, req *connect.Request[v1.RemoveEncryptionRequest]) (*connect.Response[v1.RemoveEncryptionResponse], error) {
-	return c.removeEncryption.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetWalletStatus(context.Context, *v1.GetWalletStatusRequest) (*v1.GetWalletStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetWalletStatus is not implemented")
 }
 
-// ListWallets calls walletmanager.v1.WalletManagerService.ListWallets.
-func (c *walletManagerServiceClient) ListWallets(ctx context.Context, req *connect.Request[v1.ListWalletsRequest]) (*connect.Response[v1.ListWalletsResponse], error) {
-	return c.listWallets.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ListSidechainDeposits(context.Context, *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListSidechainDeposits is not implemented")
 }
 
-// SwitchWallet calls walletmanager.v1.WalletManagerService.SwitchWallet.
-func (c *walletManagerServiceClient) SwitchWallet(ctx context.Context, req *connect.Request[v1.SwitchWalletRequest]) (*connect.Response[v1.SwitchWalletResponse], error) {
-	return c.switchWallet.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetSidechainDepositTotals(context.Context, *v1.GetSidechainDepositTotalsRequest) (*v1.GetSidechainDepositTotalsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetSidechainDepositTotals is not implemented")
 }
 
-// UpdateWalletMetadata calls walletmanager.v1.WalletManagerService.UpdateWalletMetadata.
-func (c *walletManagerServiceClient) UpdateWalletMetadata(ctx context.Context, req *connect.Request[v1.UpdateWalletMetadataRequest]) (*connect.Response[v1.UpdateWalletMetadataResponse], error) {
-	return c.updateWalletMetadata.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetNodeMode(context.Context, *v1.GetNodeModeRequest) (*v1.GetNodeModeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetNodeMode is not implemented")
 }
 
-// DeleteWallet calls walletmanager.v1.WalletManagerService.DeleteWallet.
-func (c *walletManagerServiceClient) DeleteWallet(ctx context.Context, req *connect.Request[v1.DeleteWalletRequest]) (*connect.Response[v1.DeleteWalletResponse], error) {
-	return c.deleteWallet.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SetNodeMode(context.Context, *v1.SetNodeModeRequest) (*v1.SetNodeModeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SetNodeMode is not implemented")
 }
 
-// DeleteAllWallets calls walletmanager.v1.WalletManagerService.DeleteAllWallets.
-func (c *walletManagerServiceClient) DeleteAllWallets(ctx context.Context, req *connect.Request[v1.DeleteAllWalletsRequest]) (*connect.Response[v1.DeleteAllWalletsResponse], error) {
-	return c.deleteAllWallets.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GenerateWallet(context.Context, *v1.GenerateWalletRequest) (*v1.GenerateWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GenerateWallet is not implemented")
 }
 
-// ListWalletBackups calls walletmanager.v1.WalletManagerService.ListWalletBackups.
-func (c *walletManagerServiceClient) ListWalletBackups(ctx context.Context, req *connect.Request[v1.ListWalletBackupsRequest]) (*connect.Response[v1.ListWalletBackupsResponse], error) {
-	return c.listWalletBackups.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) UnlockWallet(context.Context, *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.UnlockWallet is not implemented")
 }
 
-// RestoreWalletBackup calls walletmanager.v1.WalletManagerService.RestoreWalletBackup.
-func (c *walletManagerServiceClient) RestoreWalletBackup(ctx context.Context, req *connect.Request[v1.RestoreWalletBackupRequest]) (*connect.Response[v1.RestoreWalletBackupResponse], error) {
-	return c.restoreWalletBackup.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) LockWallet(context.Context, *v1.LockWalletRequest) (*v1.LockWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.LockWallet is not implemented")
 }
 
-// RestoreWalletBackupStream calls walletmanager.v1.WalletManagerService.RestoreWalletBackupStream.
-func (c *walletManagerServiceClient) RestoreWalletBackupStream(ctx context.Context, req *connect.Request[v1.RestoreWalletBackupRequest]) (*connect.ServerStreamForClient[v1.RestoreWalletBackupProgressResponse], error) {
-	return c.restoreWalletBackupStream.CallServerStream(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) EncryptWallet(context.Context, *v1.EncryptWalletRequest) (*v1.EncryptWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.EncryptWallet is not implemented")
 }
 
-// CreateWatchOnlyWallet calls walletmanager.v1.WalletManagerService.CreateWatchOnlyWallet.
-func (c *walletManagerServiceClient) CreateWatchOnlyWallet(ctx context.Context, req *connect.Request[v1.CreateWatchOnlyWalletRequest]) (*connect.Response[v1.CreateWatchOnlyWalletResponse], error) {
-	return c.createWatchOnlyWallet.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ChangePassword(context.Context, *v1.ChangePasswordRequest) (*v1.ChangePasswordResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ChangePassword is not implemented")
 }
 
-// CreateElectrumWallet calls walletmanager.v1.WalletManagerService.CreateElectrumWallet.
-func (c *walletManagerServiceClient) CreateElectrumWallet(ctx context.Context, req *connect.Request[v1.CreateElectrumWalletRequest]) (*connect.Response[v1.CreateElectrumWalletResponse], error) {
-	return c.createElectrumWallet.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) RemoveEncryption(context.Context, *v1.RemoveEncryptionRequest) (*v1.RemoveEncryptionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.RemoveEncryption is not implemented")
 }
 
-// CreateMultisigWallet calls walletmanager.v1.WalletManagerService.CreateMultisigWallet.
-func (c *walletManagerServiceClient) CreateMultisigWallet(ctx context.Context, req *connect.Request[v1.CreateMultisigWalletRequest]) (*connect.Response[v1.CreateMultisigWalletResponse], error) {
-	return c.createMultisigWallet.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ListWallets(context.Context, *v1.ListWalletsRequest) (*v1.ListWalletsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListWallets is not implemented")
 }
 
-// ParseMultisigConfig calls walletmanager.v1.WalletManagerService.ParseMultisigConfig.
-func (c *walletManagerServiceClient) ParseMultisigConfig(ctx context.Context, req *connect.Request[v1.ParseMultisigConfigRequest]) (*connect.Response[v1.ParseMultisigConfigResponse], error) {
-	return c.parseMultisigConfig.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SwitchWallet(context.Context, *v1.SwitchWalletRequest) (*v1.SwitchWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SwitchWallet is not implemented")
 }
 
-// ValidateDescriptor calls walletmanager.v1.WalletManagerService.ValidateDescriptor.
-func (c *walletManagerServiceClient) ValidateDescriptor(ctx context.Context, req *connect.Request[v1.ValidateDescriptorRequest]) (*connect.Response[v1.ValidateDescriptorResponse], error) {
-	return c.validateDescriptor.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) UpdateWalletMetadata(context.Context, *v1.UpdateWalletMetadataRequest) (*v1.UpdateWalletMetadataResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.UpdateWalletMetadata is not implemented")
 }
 
-// ValidateDerivationPath calls walletmanager.v1.WalletManagerService.ValidateDerivationPath.
-func (c *walletManagerServiceClient) ValidateDerivationPath(ctx context.Context, req *connect.Request[v1.ValidateDerivationPathRequest]) (*connect.Response[v1.ValidateDerivationPathResponse], error) {
-	return c.validateDerivationPath.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) DeleteWallet(context.Context, *v1.DeleteWalletRequest) (*v1.DeleteWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.DeleteWallet is not implemented")
 }
 
-// ListDerivationPaths calls walletmanager.v1.WalletManagerService.ListDerivationPaths.
-func (c *walletManagerServiceClient) ListDerivationPaths(ctx context.Context, req *connect.Request[v1.ListDerivationPathsRequest]) (*connect.Response[v1.ListDerivationPathsResponse], error) {
-	return c.listDerivationPaths.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) DeleteAllWallets(context.Context, *v1.DeleteAllWalletsRequest) (*v1.DeleteAllWalletsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.DeleteAllWallets is not implemented")
 }
 
-// CreateBitcoinCoreWallet calls walletmanager.v1.WalletManagerService.CreateBitcoinCoreWallet.
-func (c *walletManagerServiceClient) CreateBitcoinCoreWallet(ctx context.Context, req *connect.Request[v1.CreateBitcoinCoreWalletRequest]) (*connect.Response[v1.CreateBitcoinCoreWalletResponse], error) {
-	return c.createBitcoinCoreWallet.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ListWalletBackups(context.Context, *v1.ListWalletBackupsRequest) (*v1.ListWalletBackupsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListWalletBackups is not implemented")
 }
 
-// EnsureCoreWallets calls walletmanager.v1.WalletManagerService.EnsureCoreWallets.
-func (c *walletManagerServiceClient) EnsureCoreWallets(ctx context.Context, req *connect.Request[v1.EnsureCoreWalletsRequest]) (*connect.Response[v1.EnsureCoreWalletsResponse], error) {
-	return c.ensureCoreWallets.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) RestoreWalletBackup(context.Context, *v1.RestoreWalletBackupRequest) (*v1.RestoreWalletBackupResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.RestoreWalletBackup is not implemented")
 }
 
-// GetBalance calls walletmanager.v1.WalletManagerService.GetBalance.
-func (c *walletManagerServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) RestoreWalletBackupStream(context.Context, *v1.RestoreWalletBackupRequest, WalletManagerServiceRestoreWalletBackupStreamServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.RestoreWalletBackupStream is not implemented")
 }
 
-// RescanWallet calls walletmanager.v1.WalletManagerService.RescanWallet.
-func (c *walletManagerServiceClient) RescanWallet(ctx context.Context, req *connect.Request[v1.RescanWalletRequest]) (*connect.Response[v1.RescanWalletResponse], error) {
-	return c.rescanWallet.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CreateWatchOnlyWallet(context.Context, *v1.CreateWatchOnlyWalletRequest) (*v1.CreateWatchOnlyWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CreateWatchOnlyWallet is not implemented")
 }
 
-// EstimateFee calls walletmanager.v1.WalletManagerService.EstimateFee.
-func (c *walletManagerServiceClient) EstimateFee(ctx context.Context, req *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error) {
-	return c.estimateFee.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CreateElectrumWallet(context.Context, *v1.CreateElectrumWalletRequest) (*v1.CreateElectrumWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CreateElectrumWallet is not implemented")
 }
 
-// GetNewAddress calls walletmanager.v1.WalletManagerService.GetNewAddress.
-func (c *walletManagerServiceClient) GetNewAddress(ctx context.Context, req *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return c.getNewAddress.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CreateMultisigWallet(context.Context, *v1.CreateMultisigWalletRequest) (*v1.CreateMultisigWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CreateMultisigWallet is not implemented")
 }
 
-// SendTransaction calls walletmanager.v1.WalletManagerService.SendTransaction.
-func (c *walletManagerServiceClient) SendTransaction(ctx context.Context, req *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error) {
-	return c.sendTransaction.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ParseMultisigConfig(context.Context, *v1.ParseMultisigConfigRequest) (*v1.ParseMultisigConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ParseMultisigConfig is not implemented")
 }
 
-// PreviewSend calls walletmanager.v1.WalletManagerService.PreviewSend.
-func (c *walletManagerServiceClient) PreviewSend(ctx context.Context, req *connect.Request[v1.PreviewSendRequest]) (*connect.Response[v1.PreviewSendResponse], error) {
-	return c.previewSend.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ValidateDescriptor(context.Context, *v1.ValidateDescriptorRequest) (*v1.ValidateDescriptorResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ValidateDescriptor is not implemented")
 }
 
-// SetFrozenCoins calls walletmanager.v1.WalletManagerService.SetFrozenCoins.
-func (c *walletManagerServiceClient) SetFrozenCoins(ctx context.Context, req *connect.Request[v1.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error) {
-	return c.setFrozenCoins.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ValidateDerivationPath(context.Context, *v1.ValidateDerivationPathRequest) (*v1.ValidateDerivationPathResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ValidateDerivationPath is not implemented")
 }
 
-// CreateDeposit calls walletmanager.v1.WalletManagerService.CreateDeposit.
-func (c *walletManagerServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ListDerivationPaths(context.Context, *v1.ListDerivationPathsRequest) (*v1.ListDerivationPathsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListDerivationPaths is not implemented")
 }
 
-// ListTransactions calls walletmanager.v1.WalletManagerService.ListTransactions.
-func (c *walletManagerServiceClient) ListTransactions(ctx context.Context, req *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return c.listTransactions.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CreateBitcoinCoreWallet(context.Context, *v1.CreateBitcoinCoreWalletRequest) (*v1.CreateBitcoinCoreWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CreateBitcoinCoreWallet is not implemented")
 }
 
-// ListUnspent calls walletmanager.v1.WalletManagerService.ListUnspent.
-func (c *walletManagerServiceClient) ListUnspent(ctx context.Context, req *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error) {
-	return c.listUnspent.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) EnsureCoreWallets(context.Context, *v1.EnsureCoreWalletsRequest) (*v1.EnsureCoreWalletsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.EnsureCoreWallets is not implemented")
 }
 
-// ListReceiveAddresses calls walletmanager.v1.WalletManagerService.ListReceiveAddresses.
-func (c *walletManagerServiceClient) ListReceiveAddresses(ctx context.Context, req *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error) {
-	return c.listReceiveAddresses.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetBalance is not implemented")
 }
 
-// GetTransactionDetails calls walletmanager.v1.WalletManagerService.GetTransactionDetails.
-func (c *walletManagerServiceClient) GetTransactionDetails(ctx context.Context, req *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error) {
-	return c.getTransactionDetails.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) RescanWallet(context.Context, *v1.RescanWalletRequest) (*v1.RescanWalletResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.RescanWallet is not implemented")
 }
 
-// DecodeTransaction calls walletmanager.v1.WalletManagerService.DecodeTransaction.
-func (c *walletManagerServiceClient) DecodeTransaction(ctx context.Context, req *connect.Request[v1.DecodeTransactionRequest]) (*connect.Response[v1.DecodeTransactionResponse], error) {
-	return c.decodeTransaction.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) EstimateFee(context.Context, *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.EstimateFee is not implemented")
 }
 
-// BumpFee calls walletmanager.v1.WalletManagerService.BumpFee.
-func (c *walletManagerServiceClient) BumpFee(ctx context.Context, req *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error) {
-	return c.bumpFee.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetNewAddress(context.Context, *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetNewAddress is not implemented")
 }
 
-// PreviewBumpFee calls walletmanager.v1.WalletManagerService.PreviewBumpFee.
-func (c *walletManagerServiceClient) PreviewBumpFee(ctx context.Context, req *connect.Request[v1.PreviewBumpFeeRequest]) (*connect.Response[v1.PreviewBumpFeeResponse], error) {
-	return c.previewBumpFee.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SendTransaction(context.Context, *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SendTransaction is not implemented")
 }
 
-// CreateCpfp calls walletmanager.v1.WalletManagerService.CreateCpfp.
-func (c *walletManagerServiceClient) CreateCpfp(ctx context.Context, req *connect.Request[v1.CreateCpfpRequest]) (*connect.Response[v1.CreateCpfpResponse], error) {
-	return c.createCpfp.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) PreviewSend(context.Context, *v1.PreviewSendRequest) (*v1.PreviewSendResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.PreviewSend is not implemented")
 }
 
-// CancelTransaction calls walletmanager.v1.WalletManagerService.CancelTransaction.
-func (c *walletManagerServiceClient) CancelTransaction(ctx context.Context, req *connect.Request[v1.CancelTransactionRequest]) (*connect.Response[v1.CancelTransactionResponse], error) {
-	return c.cancelTransaction.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SetFrozenCoins(context.Context, *v1.SetFrozenCoinsRequest) (*emptypb.Empty, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SetFrozenCoins is not implemented")
 }
 
-// DeriveAddresses calls walletmanager.v1.WalletManagerService.DeriveAddresses.
-func (c *walletManagerServiceClient) DeriveAddresses(ctx context.Context, req *connect.Request[v1.DeriveAddressesRequest]) (*connect.Response[v1.DeriveAddressesResponse], error) {
-	return c.deriveAddresses.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CreateDeposit is not implemented")
 }
 
-// CreatePsbt calls walletmanager.v1.WalletManagerService.CreatePsbt.
-func (c *walletManagerServiceClient) CreatePsbt(ctx context.Context, req *connect.Request[v1.CreatePsbtRequest]) (*connect.Response[v1.CreatePsbtResponse], error) {
-	return c.createPsbt.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ListTransactions(context.Context, *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListTransactions is not implemented")
 }
 
-// SignPsbt calls walletmanager.v1.WalletManagerService.SignPsbt.
-func (c *walletManagerServiceClient) SignPsbt(ctx context.Context, req *connect.Request[v1.SignPsbtRequest]) (*connect.Response[v1.SignPsbtResponse], error) {
-	return c.signPsbt.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ListUnspent(context.Context, *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListUnspent is not implemented")
 }
 
-// SignPsbtWithCosigner calls walletmanager.v1.WalletManagerService.SignPsbtWithCosigner.
-func (c *walletManagerServiceClient) SignPsbtWithCosigner(ctx context.Context, req *connect.Request[v1.SignPsbtWithCosignerRequest]) (*connect.Response[v1.SignPsbtWithCosignerResponse], error) {
-	return c.signPsbtWithCosigner.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) ListReceiveAddresses(context.Context, *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListReceiveAddresses is not implemented")
 }
 
-// CombinePsbt calls walletmanager.v1.WalletManagerService.CombinePsbt.
-func (c *walletManagerServiceClient) CombinePsbt(ctx context.Context, req *connect.Request[v1.CombinePsbtRequest]) (*connect.Response[v1.CombinePsbtResponse], error) {
-	return c.combinePsbt.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetTransactionDetails(context.Context, *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetTransactionDetails is not implemented")
 }
 
-// FinalizePsbt calls walletmanager.v1.WalletManagerService.FinalizePsbt.
-func (c *walletManagerServiceClient) FinalizePsbt(ctx context.Context, req *connect.Request[v1.FinalizePsbtRequest]) (*connect.Response[v1.FinalizePsbtResponse], error) {
-	return c.finalizePsbt.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) DecodeTransaction(context.Context, *v1.DecodeTransactionRequest) (*v1.DecodeTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.DecodeTransaction is not implemented")
 }
 
-// MultisigPsbtStatus calls walletmanager.v1.WalletManagerService.MultisigPsbtStatus.
-func (c *walletManagerServiceClient) MultisigPsbtStatus(ctx context.Context, req *connect.Request[v1.MultisigPsbtStatusRequest]) (*connect.Response[v1.MultisigPsbtStatusResponse], error) {
-	return c.multisigPsbtStatus.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) BumpFee(context.Context, *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.BumpFee is not implemented")
 }
 
-// BroadcastTransaction calls walletmanager.v1.WalletManagerService.BroadcastTransaction.
-func (c *walletManagerServiceClient) BroadcastTransaction(ctx context.Context, req *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error) {
-	return c.broadcastTransaction.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) PreviewBumpFee(context.Context, *v1.PreviewBumpFeeRequest) (*v1.PreviewBumpFeeResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.PreviewBumpFee is not implemented")
 }
 
-// GetAddressUnspent calls walletmanager.v1.WalletManagerService.GetAddressUnspent.
-func (c *walletManagerServiceClient) GetAddressUnspent(ctx context.Context, req *connect.Request[v1.GetAddressUnspentRequest]) (*connect.Response[v1.GetAddressUnspentResponse], error) {
-	return c.getAddressUnspent.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CreateCpfp(context.Context, *v1.CreateCpfpRequest) (*v1.CreateCpfpResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CreateCpfp is not implemented")
 }
 
-// BroadcastElectrumTransaction calls
-// walletmanager.v1.WalletManagerService.BroadcastElectrumTransaction.
-func (c *walletManagerServiceClient) BroadcastElectrumTransaction(ctx context.Context, req *connect.Request[v1.BroadcastElectrumTransactionRequest]) (*connect.Response[v1.BroadcastElectrumTransactionResponse], error) {
-	return c.broadcastElectrumTransaction.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CancelTransaction(context.Context, *v1.CancelTransactionRequest) (*v1.CancelTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CancelTransaction is not implemented")
 }
 
-// EnumerateHardwareDevices calls walletmanager.v1.WalletManagerService.EnumerateHardwareDevices.
-func (c *walletManagerServiceClient) EnumerateHardwareDevices(ctx context.Context, req *connect.Request[v1.EnumerateHardwareDevicesRequest]) (*connect.Response[v1.EnumerateHardwareDevicesResponse], error) {
-	return c.enumerateHardwareDevices.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) DeriveAddresses(context.Context, *v1.DeriveAddressesRequest) (*v1.DeriveAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.DeriveAddresses is not implemented")
 }
 
-// GetHardwareXpub calls walletmanager.v1.WalletManagerService.GetHardwareXpub.
-func (c *walletManagerServiceClient) GetHardwareXpub(ctx context.Context, req *connect.Request[v1.GetHardwareXpubRequest]) (*connect.Response[v1.GetHardwareXpubResponse], error) {
-	return c.getHardwareXpub.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CreatePsbt(context.Context, *v1.CreatePsbtRequest) (*v1.CreatePsbtResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CreatePsbt is not implemented")
 }
 
-// SignPsbtWithDevice calls walletmanager.v1.WalletManagerService.SignPsbtWithDevice.
-func (c *walletManagerServiceClient) SignPsbtWithDevice(ctx context.Context, req *connect.Request[v1.SignPsbtWithDeviceRequest]) (*connect.Response[v1.SignPsbtWithDeviceResponse], error) {
-	return c.signPsbtWithDevice.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SignPsbt(context.Context, *v1.SignPsbtRequest) (*v1.SignPsbtResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SignPsbt is not implemented")
 }
 
-// PromptDevicePin calls walletmanager.v1.WalletManagerService.PromptDevicePin.
-func (c *walletManagerServiceClient) PromptDevicePin(ctx context.Context, req *connect.Request[v1.PromptDevicePinRequest]) (*connect.Response[v1.PromptDevicePinResponse], error) {
-	return c.promptDevicePin.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SignPsbtWithCosigner(context.Context, *v1.SignPsbtWithCosignerRequest) (*v1.SignPsbtWithCosignerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SignPsbtWithCosigner is not implemented")
 }
 
-// SendDevicePin calls walletmanager.v1.WalletManagerService.SendDevicePin.
-func (c *walletManagerServiceClient) SendDevicePin(ctx context.Context, req *connect.Request[v1.SendDevicePinRequest]) (*connect.Response[v1.SendDevicePinResponse], error) {
-	return c.sendDevicePin.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CombinePsbt(context.Context, *v1.CombinePsbtRequest) (*v1.CombinePsbtResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CombinePsbt is not implemented")
 }
 
-// CloseDevice calls walletmanager.v1.WalletManagerService.CloseDevice.
-func (c *walletManagerServiceClient) CloseDevice(ctx context.Context, req *connect.Request[v1.CloseDeviceRequest]) (*connect.Response[v1.CloseDeviceResponse], error) {
-	return c.closeDevice.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) FinalizePsbt(context.Context, *v1.FinalizePsbtRequest) (*v1.FinalizePsbtResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.FinalizePsbt is not implemented")
 }
 
-// DeriveKeystore calls walletmanager.v1.WalletManagerService.DeriveKeystore.
-func (c *walletManagerServiceClient) DeriveKeystore(ctx context.Context, req *connect.Request[v1.DeriveKeystoreRequest]) (*connect.Response[v1.DeriveKeystoreResponse], error) {
-	return c.deriveKeystore.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) MultisigPsbtStatus(context.Context, *v1.MultisigPsbtStatusRequest) (*v1.MultisigPsbtStatusResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.MultisigPsbtStatus is not implemented")
 }
 
-// PreviewWalletFromEntropy calls walletmanager.v1.WalletManagerService.PreviewWalletFromEntropy.
-func (c *walletManagerServiceClient) PreviewWalletFromEntropy(ctx context.Context, req *connect.Request[v1.PreviewWalletFromEntropyRequest]) (*connect.Response[v1.PreviewWalletFromEntropyResponse], error) {
-	return c.previewWalletFromEntropy.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) BroadcastTransaction(context.Context, *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.BroadcastTransaction is not implemented")
 }
 
-// GetWalletSeed calls walletmanager.v1.WalletManagerService.GetWalletSeed.
-func (c *walletManagerServiceClient) GetWalletSeed(ctx context.Context, req *connect.Request[v1.GetWalletSeedRequest]) (*connect.Response[v1.GetWalletSeedResponse], error) {
-	return c.getWalletSeed.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetAddressUnspent(context.Context, *v1.GetAddressUnspentRequest) (*v1.GetAddressUnspentResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetAddressUnspent is not implemented")
 }
 
-// ListCoreVariants calls walletmanager.v1.WalletManagerService.ListCoreVariants.
-func (c *walletManagerServiceClient) ListCoreVariants(ctx context.Context, req *connect.Request[v1.ListCoreVariantsRequest]) (*connect.Response[v1.ListCoreVariantsResponse], error) {
-	return c.listCoreVariants.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) BroadcastElectrumTransaction(context.Context, *v1.BroadcastElectrumTransactionRequest) (*v1.BroadcastElectrumTransactionResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.BroadcastElectrumTransaction is not implemented")
 }
 
-// GetCoreVariant calls walletmanager.v1.WalletManagerService.GetCoreVariant.
-func (c *walletManagerServiceClient) GetCoreVariant(ctx context.Context, req *connect.Request[v1.GetCoreVariantRequest]) (*connect.Response[v1.GetCoreVariantResponse], error) {
-	return c.getCoreVariant.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) EnumerateHardwareDevices(context.Context, *v1.EnumerateHardwareDevicesRequest) (*v1.EnumerateHardwareDevicesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.EnumerateHardwareDevices is not implemented")
 }
 
-// SetCoreVariant calls walletmanager.v1.WalletManagerService.SetCoreVariant.
-func (c *walletManagerServiceClient) SetCoreVariant(ctx context.Context, req *connect.Request[v1.SetCoreVariantRequest]) (*connect.Response[v1.SetCoreVariantResponse], error) {
-	return c.setCoreVariant.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) GetHardwareXpub(context.Context, *v1.GetHardwareXpubRequest) (*v1.GetHardwareXpubResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetHardwareXpub is not implemented")
 }
 
-// GetElectrumServer calls walletmanager.v1.WalletManagerService.GetElectrumServer.
-func (c *walletManagerServiceClient) GetElectrumServer(ctx context.Context, req *connect.Request[v1.GetElectrumServerRequest]) (*connect.Response[v1.GetElectrumServerResponse], error) {
-	return c.getElectrumServer.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SignPsbtWithDevice(context.Context, *v1.SignPsbtWithDeviceRequest) (*v1.SignPsbtWithDeviceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SignPsbtWithDevice is not implemented")
 }
 
-// SetElectrumServer calls walletmanager.v1.WalletManagerService.SetElectrumServer.
-func (c *walletManagerServiceClient) SetElectrumServer(ctx context.Context, req *connect.Request[v1.SetElectrumServerRequest]) (*connect.Response[v1.SetElectrumServerResponse], error) {
-	return c.setElectrumServer.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) PromptDevicePin(context.Context, *v1.PromptDevicePinRequest) (*v1.PromptDevicePinResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.PromptDevicePin is not implemented")
 }
 
-// GetTorConfig calls walletmanager.v1.WalletManagerService.GetTorConfig.
-func (c *walletManagerServiceClient) GetTorConfig(ctx context.Context, req *connect.Request[v1.GetTorConfigRequest]) (*connect.Response[v1.GetTorConfigResponse], error) {
-	return c.getTorConfig.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) SendDevicePin(context.Context, *v1.SendDevicePinRequest) (*v1.SendDevicePinResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SendDevicePin is not implemented")
 }
 
-// SetTorConfig calls walletmanager.v1.WalletManagerService.SetTorConfig.
-func (c *walletManagerServiceClient) SetTorConfig(ctx context.Context, req *connect.Request[v1.SetTorConfigRequest]) (*connect.Response[v1.SetTorConfigResponse], error) {
-	return c.setTorConfig.CallUnary(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) CloseDevice(context.Context, *v1.CloseDeviceRequest) (*v1.CloseDeviceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.CloseDevice is not implemented")
 }
 
-// WatchWalletData calls walletmanager.v1.WalletManagerService.WatchWalletData.
-func (c *walletManagerServiceClient) WatchWalletData(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.ServerStreamForClient[v1.WatchWalletDataResponse], error) {
-	return c.watchWalletData.CallServerStream(ctx, req)
+func (UnimplementedWalletManagerServiceHandler) DeriveKeystore(context.Context, *v1.DeriveKeystoreRequest) (*v1.DeriveKeystoreResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.DeriveKeystore is not implemented")
 }
 
-// WalletManagerServiceHandler is an implementation of the walletmanager.v1.WalletManagerService
-// service.
-type WalletManagerServiceHandler interface {
-	// Wallet lifecycle
-	GetWalletStatus(context.Context, *connect.Request[v1.GetWalletStatusRequest]) (*connect.Response[v1.GetWalletStatusResponse], error)
-	// How much of Bitcoin this install runs. The frontend asks the user before
-	// it boots anything, and blocks until GetNodeMode reports a mode.
-	// Deposits this install made to a sidechain treasury. An M5 is an ordinary
-	// transaction on the wire, so the record comes from when we broadcast it.
-	ListSidechainDeposits(context.Context, *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error)
-	GetSidechainDepositTotals(context.Context, *connect.Request[v1.GetSidechainDepositTotalsRequest]) (*connect.Response[v1.GetSidechainDepositTotalsResponse], error)
-	GetNodeMode(context.Context, *connect.Request[v1.GetNodeModeRequest]) (*connect.Response[v1.GetNodeModeResponse], error)
-	SetNodeMode(context.Context, *connect.Request[v1.SetNodeModeRequest]) (*connect.Response[v1.SetNodeModeResponse], error)
-	GenerateWallet(context.Context, *connect.Request[v1.GenerateWalletRequest]) (*connect.Response[v1.GenerateWalletResponse], error)
-	UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error)
-	LockWallet(context.Context, *connect.Request[v1.LockWalletRequest]) (*connect.Response[v1.LockWalletResponse], error)
-	EncryptWallet(context.Context, *connect.Request[v1.EncryptWalletRequest]) (*connect.Response[v1.EncryptWalletResponse], error)
-	ChangePassword(context.Context, *connect.Request[v1.ChangePasswordRequest]) (*connect.Response[v1.ChangePasswordResponse], error)
-	RemoveEncryption(context.Context, *connect.Request[v1.RemoveEncryptionRequest]) (*connect.Response[v1.RemoveEncryptionResponse], error)
-	ListWallets(context.Context, *connect.Request[v1.ListWalletsRequest]) (*connect.Response[v1.ListWalletsResponse], error)
-	SwitchWallet(context.Context, *connect.Request[v1.SwitchWalletRequest]) (*connect.Response[v1.SwitchWalletResponse], error)
-	UpdateWalletMetadata(context.Context, *connect.Request[v1.UpdateWalletMetadataRequest]) (*connect.Response[v1.UpdateWalletMetadataResponse], error)
-	DeleteWallet(context.Context, *connect.Request[v1.DeleteWalletRequest]) (*connect.Response[v1.DeleteWalletResponse], error)
-	DeleteAllWallets(context.Context, *connect.Request[v1.DeleteAllWalletsRequest]) (*connect.Response[v1.DeleteAllWalletsResponse], error)
-	ListWalletBackups(context.Context, *connect.Request[v1.ListWalletBackupsRequest]) (*connect.Response[v1.ListWalletBackupsResponse], error)
-	RestoreWalletBackup(context.Context, *connect.Request[v1.RestoreWalletBackupRequest]) (*connect.Response[v1.RestoreWalletBackupResponse], error)
-	RestoreWalletBackupStream(context.Context, *connect.Request[v1.RestoreWalletBackupRequest], *connect.ServerStream[v1.RestoreWalletBackupProgressResponse]) error
-	CreateWatchOnlyWallet(context.Context, *connect.Request[v1.CreateWatchOnlyWalletRequest]) (*connect.Response[v1.CreateWatchOnlyWalletResponse], error)
-	// Create an electrum wallet: keys are generated locally, but no local Bitcoin
-	// Core or enforcer runs. The wallet reads its chain from Esplora.
-	CreateElectrumWallet(context.Context, *connect.Request[v1.CreateElectrumWalletRequest]) (*connect.Response[v1.CreateElectrumWalletResponse], error)
-	CreateMultisigWallet(context.Context, *connect.Request[v1.CreateMultisigWalletRequest]) (*connect.Response[v1.CreateMultisigWalletResponse], error)
-	// ParseMultisigConfig parses a descriptor or a wallet-config file (Coldcard
-	// text / Sparrow / Specter / Caravan JSON) into an m-of-n policy + cosigners.
-	ParseMultisigConfig(context.Context, *connect.Request[v1.ParseMultisigConfigRequest]) (*connect.Response[v1.ParseMultisigConfigResponse], error)
-	// ValidateDescriptor reads an output descriptor — single-sig or sortedmulti —
-	// into the script policy it encodes.
-	ValidateDescriptor(context.Context, *connect.Request[v1.ValidateDescriptorRequest]) (*connect.Response[v1.ValidateDescriptorResponse], error)
-	// ValidateDerivationPath canonicalises a BIP32 derivation path, or fails with
-	// the reason it is unusable.
-	ValidateDerivationPath(context.Context, *connect.Request[v1.ValidateDerivationPathRequest]) (*connect.Response[v1.ValidateDerivationPathResponse], error)
-	// ListDerivationPaths returns the standard account paths for a policy on the
-	// network this backend runs.
-	ListDerivationPaths(context.Context, *connect.Request[v1.ListDerivationPathsRequest]) (*connect.Response[v1.ListDerivationPathsResponse], error)
-	// Core wallet management
-	CreateBitcoinCoreWallet(context.Context, *connect.Request[v1.CreateBitcoinCoreWalletRequest]) (*connect.Response[v1.CreateBitcoinCoreWalletResponse], error)
-	EnsureCoreWallets(context.Context, *connect.Request[v1.EnsureCoreWalletsRequest]) (*connect.Response[v1.EnsureCoreWalletsResponse], error)
-	// Bitcoin operations (proxied through Core RPC)
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	RescanWallet(context.Context, *connect.Request[v1.RescanWalletRequest]) (*connect.Response[v1.RescanWalletResponse], error)
-	EstimateFee(context.Context, *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error)
-	GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error)
-	SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error)
-	// PreviewSend builds a send at a fee rate, with the same coin selection as
-	// SendTransaction, and reports its fee and size. It broadcasts nothing.
-	PreviewSend(context.Context, *connect.Request[v1.PreviewSendRequest]) (*connect.Response[v1.PreviewSendResponse], error)
-	// SetFrozenCoins records the coins the frontend froze. Every send after it
-	// leaves those coins alone, and Bitcoin Core holds them locked for the
-	// length of a send so its own coin selection skips them too.
-	SetFrozenCoins(context.Context, *connect.Request[v1.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error)
-	// CreateDeposit funds a BIP300 M5 deposit to a sidechain from any wallet.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error)
-	ListUnspent(context.Context, *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error)
-	ListReceiveAddresses(context.Context, *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error)
-	GetTransactionDetails(context.Context, *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error)
-	DecodeTransaction(context.Context, *connect.Request[v1.DecodeTransactionRequest]) (*connect.Response[v1.DecodeTransactionResponse], error)
-	BumpFee(context.Context, *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error)
-	// PreviewBumpFee reports what a fee bump costs, and which output pays it,
-	// without broadcasting anything.
-	PreviewBumpFee(context.Context, *connect.Request[v1.PreviewBumpFeeRequest]) (*connect.Response[v1.PreviewBumpFeeResponse], error)
-	// CreateCpfp spends an unconfirmed wallet UTXO with a child transaction whose
-	// fee lifts the parent+child package to the target fee rate (CPFP).
-	CreateCpfp(context.Context, *connect.Request[v1.CreateCpfpRequest]) (*connect.Response[v1.CreateCpfpResponse], error)
-	// CancelTransaction replaces an unconfirmed transaction with one that pays
-	// the wallet's own inputs of it back to the wallet.
-	CancelTransaction(context.Context, *connect.Request[v1.CancelTransactionRequest]) (*connect.Response[v1.CancelTransactionResponse], error)
-	DeriveAddresses(context.Context, *connect.Request[v1.DeriveAddressesRequest]) (*connect.Response[v1.DeriveAddressesResponse], error)
-	// PSBT (BIP174). CreatePsbt builds an unsigned PSBT for a send (works for
-	// watch-only wallets); SignPsbt adds this wallet's signatures; CombinePsbt
-	// merges cosigner PSBTs; FinalizePsbt extracts the raw transaction. Electrum
-	// wallets only.
-	CreatePsbt(context.Context, *connect.Request[v1.CreatePsbtRequest]) (*connect.Response[v1.CreatePsbtResponse], error)
-	SignPsbt(context.Context, *connect.Request[v1.SignPsbtRequest]) (*connect.Response[v1.SignPsbtResponse], error)
-	// SignPsbtWithCosigner signs a multisig PSBT with a single held cosigner's key
-	// (per-keystore signing), leaving the other legs for their own signers.
-	SignPsbtWithCosigner(context.Context, *connect.Request[v1.SignPsbtWithCosignerRequest]) (*connect.Response[v1.SignPsbtWithCosignerResponse], error)
-	CombinePsbt(context.Context, *connect.Request[v1.CombinePsbtRequest]) (*connect.Response[v1.CombinePsbtResponse], error)
-	FinalizePsbt(context.Context, *connect.Request[v1.FinalizePsbtRequest]) (*connect.Response[v1.FinalizePsbtResponse], error)
-	// MultisigPsbtStatus reports signing progress for a multisig wallet's PSBT:
-	// signature count, whether it can be finalized, and which cosigners signed.
-	MultisigPsbtStatus(context.Context, *connect.Request[v1.MultisigPsbtStatusRequest]) (*connect.Response[v1.MultisigPsbtStatusResponse], error)
-	// BroadcastTransaction broadcasts a finalized raw transaction over the
-	// wallet's chain source and returns its txid.
-	BroadcastTransaction(context.Context, *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error)
-	// Address reads that belong to no wallet — cheque addresses, whose funds are
-	// not the user's to spend. Always electrum-backed, whatever wallet is active.
-	GetAddressUnspent(context.Context, *connect.Request[v1.GetAddressUnspentRequest]) (*connect.Response[v1.GetAddressUnspentResponse], error)
-	BroadcastElectrumTransaction(context.Context, *connect.Request[v1.BroadcastElectrumTransactionRequest]) (*connect.Response[v1.BroadcastElectrumTransactionResponse], error)
-	// USB hardware wallets.
-	EnumerateHardwareDevices(context.Context, *connect.Request[v1.EnumerateHardwareDevicesRequest]) (*connect.Response[v1.EnumerateHardwareDevicesResponse], error)
-	GetHardwareXpub(context.Context, *connect.Request[v1.GetHardwareXpubRequest]) (*connect.Response[v1.GetHardwareXpubResponse], error)
-	SignPsbtWithDevice(context.Context, *connect.Request[v1.SignPsbtWithDeviceRequest]) (*connect.Response[v1.SignPsbtWithDeviceResponse], error)
-	// PromptDevicePin shows the PIN matrix; SendDevicePin unlocks with it.
-	PromptDevicePin(context.Context, *connect.Request[v1.PromptDevicePinRequest]) (*connect.Response[v1.PromptDevicePinResponse], error)
-	SendDevicePin(context.Context, *connect.Request[v1.SendDevicePinRequest]) (*connect.Response[v1.SendDevicePinResponse], error)
-	// CloseDevice releases the device so the next enumerate isn't blocked.
-	CloseDevice(context.Context, *connect.Request[v1.CloseDeviceRequest]) (*connect.Response[v1.CloseDeviceResponse], error)
-	// DeriveKeystore turns a keystore's intent into derived account key material.
-	DeriveKeystore(context.Context, *connect.Request[v1.DeriveKeystoreRequest]) (*connect.Response[v1.DeriveKeystoreResponse], error)
-	// PreviewWalletFromEntropy derives a wallet without saving it, so a caller can
-	// show the words while the user is still choosing their entropy.
-	PreviewWalletFromEntropy(context.Context, *connect.Request[v1.PreviewWalletFromEntropyRequest]) (*connect.Response[v1.PreviewWalletFromEntropyResponse], error)
-	// Seed access for cheque engine
-	GetWalletSeed(context.Context, *connect.Request[v1.GetWalletSeedRequest]) (*connect.Response[v1.GetWalletSeedResponse], error)
-	// Bitcoin Core variant selection (untouched / touched / knots).
-	ListCoreVariants(context.Context, *connect.Request[v1.ListCoreVariantsRequest]) (*connect.Response[v1.ListCoreVariantsResponse], error)
-	GetCoreVariant(context.Context, *connect.Request[v1.GetCoreVariantRequest]) (*connect.Response[v1.GetCoreVariantResponse], error)
-	SetCoreVariant(context.Context, *connect.Request[v1.SetCoreVariantRequest]) (*connect.Response[v1.SetCoreVariantResponse], error)
-	// Electrum server (Esplora endpoint) selection for electrum wallets.
-	GetElectrumServer(context.Context, *connect.Request[v1.GetElectrumServerRequest]) (*connect.Response[v1.GetElectrumServerResponse], error)
-	SetElectrumServer(context.Context, *connect.Request[v1.SetElectrumServerRequest]) (*connect.Response[v1.SetElectrumServerResponse], error)
-	// Tor SOCKS5 proxy routing for the electrum wallet's chain connections.
-	GetTorConfig(context.Context, *connect.Request[v1.GetTorConfigRequest]) (*connect.Response[v1.GetTorConfigResponse], error)
-	SetTorConfig(context.Context, *connect.Request[v1.SetTorConfigRequest]) (*connect.Response[v1.SetTorConfigResponse], error)
-	// Stream wallet state changes. Sends the full wallet state immediately,
-	// then again whenever wallets or balance change.
-	WatchWalletData(context.Context, *connect.Request[emptypb.Empty], *connect.ServerStream[v1.WatchWalletDataResponse]) error
-}
-
-// NewWalletManagerServiceHandler builds an HTTP handler from the service implementation. It returns
-// the path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewWalletManagerServiceHandler(svc WalletManagerServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	walletManagerServiceMethods := v1.File_walletmanager_v1_walletmanager_proto.Services().ByName("WalletManagerService").Methods()
-	walletManagerServiceGetWalletStatusHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetWalletStatusProcedure,
-		svc.GetWalletStatus,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetWalletStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListSidechainDepositsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListSidechainDepositsProcedure,
-		svc.ListSidechainDeposits,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListSidechainDeposits")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetSidechainDepositTotalsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetSidechainDepositTotalsProcedure,
-		svc.GetSidechainDepositTotals,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetSidechainDepositTotals")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetNodeModeHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetNodeModeProcedure,
-		svc.GetNodeMode,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetNodeMode")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSetNodeModeHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSetNodeModeProcedure,
-		svc.SetNodeMode,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SetNodeMode")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGenerateWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGenerateWalletProcedure,
-		svc.GenerateWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GenerateWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceUnlockWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceUnlockWalletProcedure,
-		svc.UnlockWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("UnlockWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceLockWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceLockWalletProcedure,
-		svc.LockWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("LockWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceEncryptWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceEncryptWalletProcedure,
-		svc.EncryptWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("EncryptWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceChangePasswordHandler := connect.NewUnaryHandler(
-		WalletManagerServiceChangePasswordProcedure,
-		svc.ChangePassword,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ChangePassword")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceRemoveEncryptionHandler := connect.NewUnaryHandler(
-		WalletManagerServiceRemoveEncryptionProcedure,
-		svc.RemoveEncryption,
-		connect.WithSchema(walletManagerServiceMethods.ByName("RemoveEncryption")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListWalletsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListWalletsProcedure,
-		svc.ListWallets,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListWallets")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSwitchWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSwitchWalletProcedure,
-		svc.SwitchWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SwitchWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceUpdateWalletMetadataHandler := connect.NewUnaryHandler(
-		WalletManagerServiceUpdateWalletMetadataProcedure,
-		svc.UpdateWalletMetadata,
-		connect.WithSchema(walletManagerServiceMethods.ByName("UpdateWalletMetadata")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceDeleteWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceDeleteWalletProcedure,
-		svc.DeleteWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("DeleteWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceDeleteAllWalletsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceDeleteAllWalletsProcedure,
-		svc.DeleteAllWallets,
-		connect.WithSchema(walletManagerServiceMethods.ByName("DeleteAllWallets")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListWalletBackupsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListWalletBackupsProcedure,
-		svc.ListWalletBackups,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListWalletBackups")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceRestoreWalletBackupHandler := connect.NewUnaryHandler(
-		WalletManagerServiceRestoreWalletBackupProcedure,
-		svc.RestoreWalletBackup,
-		connect.WithSchema(walletManagerServiceMethods.ByName("RestoreWalletBackup")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceRestoreWalletBackupStreamHandler := connect.NewServerStreamHandler(
-		WalletManagerServiceRestoreWalletBackupStreamProcedure,
-		svc.RestoreWalletBackupStream,
-		connect.WithSchema(walletManagerServiceMethods.ByName("RestoreWalletBackupStream")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCreateWatchOnlyWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCreateWatchOnlyWalletProcedure,
-		svc.CreateWatchOnlyWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CreateWatchOnlyWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCreateElectrumWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCreateElectrumWalletProcedure,
-		svc.CreateElectrumWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CreateElectrumWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCreateMultisigWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCreateMultisigWalletProcedure,
-		svc.CreateMultisigWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CreateMultisigWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceParseMultisigConfigHandler := connect.NewUnaryHandler(
-		WalletManagerServiceParseMultisigConfigProcedure,
-		svc.ParseMultisigConfig,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ParseMultisigConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceValidateDescriptorHandler := connect.NewUnaryHandler(
-		WalletManagerServiceValidateDescriptorProcedure,
-		svc.ValidateDescriptor,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ValidateDescriptor")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceValidateDerivationPathHandler := connect.NewUnaryHandler(
-		WalletManagerServiceValidateDerivationPathProcedure,
-		svc.ValidateDerivationPath,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ValidateDerivationPath")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListDerivationPathsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListDerivationPathsProcedure,
-		svc.ListDerivationPaths,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListDerivationPaths")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCreateBitcoinCoreWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCreateBitcoinCoreWalletProcedure,
-		svc.CreateBitcoinCoreWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CreateBitcoinCoreWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceEnsureCoreWalletsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceEnsureCoreWalletsProcedure,
-		svc.EnsureCoreWallets,
-		connect.WithSchema(walletManagerServiceMethods.ByName("EnsureCoreWallets")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetBalanceHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceRescanWalletHandler := connect.NewUnaryHandler(
-		WalletManagerServiceRescanWalletProcedure,
-		svc.RescanWallet,
-		connect.WithSchema(walletManagerServiceMethods.ByName("RescanWallet")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceEstimateFeeHandler := connect.NewUnaryHandler(
-		WalletManagerServiceEstimateFeeProcedure,
-		svc.EstimateFee,
-		connect.WithSchema(walletManagerServiceMethods.ByName("EstimateFee")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetNewAddressHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetNewAddressProcedure,
-		svc.GetNewAddress,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetNewAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSendTransactionHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSendTransactionProcedure,
-		svc.SendTransaction,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SendTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServicePreviewSendHandler := connect.NewUnaryHandler(
-		WalletManagerServicePreviewSendProcedure,
-		svc.PreviewSend,
-		connect.WithSchema(walletManagerServiceMethods.ByName("PreviewSend")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSetFrozenCoinsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSetFrozenCoinsProcedure,
-		svc.SetFrozenCoins,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SetFrozenCoins")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCreateDepositHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListTransactionsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListTransactionsProcedure,
-		svc.ListTransactions,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListTransactions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListUnspentHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListUnspentProcedure,
-		svc.ListUnspent,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListUnspent")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListReceiveAddressesHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListReceiveAddressesProcedure,
-		svc.ListReceiveAddresses,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListReceiveAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetTransactionDetailsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetTransactionDetailsProcedure,
-		svc.GetTransactionDetails,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetTransactionDetails")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceDecodeTransactionHandler := connect.NewUnaryHandler(
-		WalletManagerServiceDecodeTransactionProcedure,
-		svc.DecodeTransaction,
-		connect.WithSchema(walletManagerServiceMethods.ByName("DecodeTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceBumpFeeHandler := connect.NewUnaryHandler(
-		WalletManagerServiceBumpFeeProcedure,
-		svc.BumpFee,
-		connect.WithSchema(walletManagerServiceMethods.ByName("BumpFee")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServicePreviewBumpFeeHandler := connect.NewUnaryHandler(
-		WalletManagerServicePreviewBumpFeeProcedure,
-		svc.PreviewBumpFee,
-		connect.WithSchema(walletManagerServiceMethods.ByName("PreviewBumpFee")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCreateCpfpHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCreateCpfpProcedure,
-		svc.CreateCpfp,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CreateCpfp")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCancelTransactionHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCancelTransactionProcedure,
-		svc.CancelTransaction,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CancelTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceDeriveAddressesHandler := connect.NewUnaryHandler(
-		WalletManagerServiceDeriveAddressesProcedure,
-		svc.DeriveAddresses,
-		connect.WithSchema(walletManagerServiceMethods.ByName("DeriveAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCreatePsbtHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCreatePsbtProcedure,
-		svc.CreatePsbt,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CreatePsbt")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSignPsbtHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSignPsbtProcedure,
-		svc.SignPsbt,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SignPsbt")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSignPsbtWithCosignerHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSignPsbtWithCosignerProcedure,
-		svc.SignPsbtWithCosigner,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SignPsbtWithCosigner")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCombinePsbtHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCombinePsbtProcedure,
-		svc.CombinePsbt,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CombinePsbt")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceFinalizePsbtHandler := connect.NewUnaryHandler(
-		WalletManagerServiceFinalizePsbtProcedure,
-		svc.FinalizePsbt,
-		connect.WithSchema(walletManagerServiceMethods.ByName("FinalizePsbt")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceMultisigPsbtStatusHandler := connect.NewUnaryHandler(
-		WalletManagerServiceMultisigPsbtStatusProcedure,
-		svc.MultisigPsbtStatus,
-		connect.WithSchema(walletManagerServiceMethods.ByName("MultisigPsbtStatus")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceBroadcastTransactionHandler := connect.NewUnaryHandler(
-		WalletManagerServiceBroadcastTransactionProcedure,
-		svc.BroadcastTransaction,
-		connect.WithSchema(walletManagerServiceMethods.ByName("BroadcastTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetAddressUnspentHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetAddressUnspentProcedure,
-		svc.GetAddressUnspent,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetAddressUnspent")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceBroadcastElectrumTransactionHandler := connect.NewUnaryHandler(
-		WalletManagerServiceBroadcastElectrumTransactionProcedure,
-		svc.BroadcastElectrumTransaction,
-		connect.WithSchema(walletManagerServiceMethods.ByName("BroadcastElectrumTransaction")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceEnumerateHardwareDevicesHandler := connect.NewUnaryHandler(
-		WalletManagerServiceEnumerateHardwareDevicesProcedure,
-		svc.EnumerateHardwareDevices,
-		connect.WithSchema(walletManagerServiceMethods.ByName("EnumerateHardwareDevices")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetHardwareXpubHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetHardwareXpubProcedure,
-		svc.GetHardwareXpub,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetHardwareXpub")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSignPsbtWithDeviceHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSignPsbtWithDeviceProcedure,
-		svc.SignPsbtWithDevice,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SignPsbtWithDevice")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServicePromptDevicePinHandler := connect.NewUnaryHandler(
-		WalletManagerServicePromptDevicePinProcedure,
-		svc.PromptDevicePin,
-		connect.WithSchema(walletManagerServiceMethods.ByName("PromptDevicePin")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSendDevicePinHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSendDevicePinProcedure,
-		svc.SendDevicePin,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SendDevicePin")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceCloseDeviceHandler := connect.NewUnaryHandler(
-		WalletManagerServiceCloseDeviceProcedure,
-		svc.CloseDevice,
-		connect.WithSchema(walletManagerServiceMethods.ByName("CloseDevice")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceDeriveKeystoreHandler := connect.NewUnaryHandler(
-		WalletManagerServiceDeriveKeystoreProcedure,
-		svc.DeriveKeystore,
-		connect.WithSchema(walletManagerServiceMethods.ByName("DeriveKeystore")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServicePreviewWalletFromEntropyHandler := connect.NewUnaryHandler(
-		WalletManagerServicePreviewWalletFromEntropyProcedure,
-		svc.PreviewWalletFromEntropy,
-		connect.WithSchema(walletManagerServiceMethods.ByName("PreviewWalletFromEntropy")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetWalletSeedHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetWalletSeedProcedure,
-		svc.GetWalletSeed,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetWalletSeed")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceListCoreVariantsHandler := connect.NewUnaryHandler(
-		WalletManagerServiceListCoreVariantsProcedure,
-		svc.ListCoreVariants,
-		connect.WithSchema(walletManagerServiceMethods.ByName("ListCoreVariants")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetCoreVariantHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetCoreVariantProcedure,
-		svc.GetCoreVariant,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetCoreVariant")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSetCoreVariantHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSetCoreVariantProcedure,
-		svc.SetCoreVariant,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SetCoreVariant")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetElectrumServerHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetElectrumServerProcedure,
-		svc.GetElectrumServer,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetElectrumServer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSetElectrumServerHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSetElectrumServerProcedure,
-		svc.SetElectrumServer,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SetElectrumServer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceGetTorConfigHandler := connect.NewUnaryHandler(
-		WalletManagerServiceGetTorConfigProcedure,
-		svc.GetTorConfig,
-		connect.WithSchema(walletManagerServiceMethods.ByName("GetTorConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceSetTorConfigHandler := connect.NewUnaryHandler(
-		WalletManagerServiceSetTorConfigProcedure,
-		svc.SetTorConfig,
-		connect.WithSchema(walletManagerServiceMethods.ByName("SetTorConfig")),
-		connect.WithHandlerOptions(opts...),
-	)
-	walletManagerServiceWatchWalletDataHandler := connect.NewServerStreamHandler(
-		WalletManagerServiceWatchWalletDataProcedure,
-		svc.WatchWalletData,
-		connect.WithSchema(walletManagerServiceMethods.ByName("WatchWalletData")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/walletmanager.v1.WalletManagerService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case WalletManagerServiceGetWalletStatusProcedure:
-			walletManagerServiceGetWalletStatusHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListSidechainDepositsProcedure:
-			walletManagerServiceListSidechainDepositsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetSidechainDepositTotalsProcedure:
-			walletManagerServiceGetSidechainDepositTotalsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetNodeModeProcedure:
-			walletManagerServiceGetNodeModeHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSetNodeModeProcedure:
-			walletManagerServiceSetNodeModeHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGenerateWalletProcedure:
-			walletManagerServiceGenerateWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceUnlockWalletProcedure:
-			walletManagerServiceUnlockWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceLockWalletProcedure:
-			walletManagerServiceLockWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceEncryptWalletProcedure:
-			walletManagerServiceEncryptWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceChangePasswordProcedure:
-			walletManagerServiceChangePasswordHandler.ServeHTTP(w, r)
-		case WalletManagerServiceRemoveEncryptionProcedure:
-			walletManagerServiceRemoveEncryptionHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListWalletsProcedure:
-			walletManagerServiceListWalletsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSwitchWalletProcedure:
-			walletManagerServiceSwitchWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceUpdateWalletMetadataProcedure:
-			walletManagerServiceUpdateWalletMetadataHandler.ServeHTTP(w, r)
-		case WalletManagerServiceDeleteWalletProcedure:
-			walletManagerServiceDeleteWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceDeleteAllWalletsProcedure:
-			walletManagerServiceDeleteAllWalletsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListWalletBackupsProcedure:
-			walletManagerServiceListWalletBackupsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceRestoreWalletBackupProcedure:
-			walletManagerServiceRestoreWalletBackupHandler.ServeHTTP(w, r)
-		case WalletManagerServiceRestoreWalletBackupStreamProcedure:
-			walletManagerServiceRestoreWalletBackupStreamHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCreateWatchOnlyWalletProcedure:
-			walletManagerServiceCreateWatchOnlyWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCreateElectrumWalletProcedure:
-			walletManagerServiceCreateElectrumWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCreateMultisigWalletProcedure:
-			walletManagerServiceCreateMultisigWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceParseMultisigConfigProcedure:
-			walletManagerServiceParseMultisigConfigHandler.ServeHTTP(w, r)
-		case WalletManagerServiceValidateDescriptorProcedure:
-			walletManagerServiceValidateDescriptorHandler.ServeHTTP(w, r)
-		case WalletManagerServiceValidateDerivationPathProcedure:
-			walletManagerServiceValidateDerivationPathHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListDerivationPathsProcedure:
-			walletManagerServiceListDerivationPathsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCreateBitcoinCoreWalletProcedure:
-			walletManagerServiceCreateBitcoinCoreWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceEnsureCoreWalletsProcedure:
-			walletManagerServiceEnsureCoreWalletsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetBalanceProcedure:
-			walletManagerServiceGetBalanceHandler.ServeHTTP(w, r)
-		case WalletManagerServiceRescanWalletProcedure:
-			walletManagerServiceRescanWalletHandler.ServeHTTP(w, r)
-		case WalletManagerServiceEstimateFeeProcedure:
-			walletManagerServiceEstimateFeeHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetNewAddressProcedure:
-			walletManagerServiceGetNewAddressHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSendTransactionProcedure:
-			walletManagerServiceSendTransactionHandler.ServeHTTP(w, r)
-		case WalletManagerServicePreviewSendProcedure:
-			walletManagerServicePreviewSendHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSetFrozenCoinsProcedure:
-			walletManagerServiceSetFrozenCoinsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCreateDepositProcedure:
-			walletManagerServiceCreateDepositHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListTransactionsProcedure:
-			walletManagerServiceListTransactionsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListUnspentProcedure:
-			walletManagerServiceListUnspentHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListReceiveAddressesProcedure:
-			walletManagerServiceListReceiveAddressesHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetTransactionDetailsProcedure:
-			walletManagerServiceGetTransactionDetailsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceDecodeTransactionProcedure:
-			walletManagerServiceDecodeTransactionHandler.ServeHTTP(w, r)
-		case WalletManagerServiceBumpFeeProcedure:
-			walletManagerServiceBumpFeeHandler.ServeHTTP(w, r)
-		case WalletManagerServicePreviewBumpFeeProcedure:
-			walletManagerServicePreviewBumpFeeHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCreateCpfpProcedure:
-			walletManagerServiceCreateCpfpHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCancelTransactionProcedure:
-			walletManagerServiceCancelTransactionHandler.ServeHTTP(w, r)
-		case WalletManagerServiceDeriveAddressesProcedure:
-			walletManagerServiceDeriveAddressesHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCreatePsbtProcedure:
-			walletManagerServiceCreatePsbtHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSignPsbtProcedure:
-			walletManagerServiceSignPsbtHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSignPsbtWithCosignerProcedure:
-			walletManagerServiceSignPsbtWithCosignerHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCombinePsbtProcedure:
-			walletManagerServiceCombinePsbtHandler.ServeHTTP(w, r)
-		case WalletManagerServiceFinalizePsbtProcedure:
-			walletManagerServiceFinalizePsbtHandler.ServeHTTP(w, r)
-		case WalletManagerServiceMultisigPsbtStatusProcedure:
-			walletManagerServiceMultisigPsbtStatusHandler.ServeHTTP(w, r)
-		case WalletManagerServiceBroadcastTransactionProcedure:
-			walletManagerServiceBroadcastTransactionHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetAddressUnspentProcedure:
-			walletManagerServiceGetAddressUnspentHandler.ServeHTTP(w, r)
-		case WalletManagerServiceBroadcastElectrumTransactionProcedure:
-			walletManagerServiceBroadcastElectrumTransactionHandler.ServeHTTP(w, r)
-		case WalletManagerServiceEnumerateHardwareDevicesProcedure:
-			walletManagerServiceEnumerateHardwareDevicesHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetHardwareXpubProcedure:
-			walletManagerServiceGetHardwareXpubHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSignPsbtWithDeviceProcedure:
-			walletManagerServiceSignPsbtWithDeviceHandler.ServeHTTP(w, r)
-		case WalletManagerServicePromptDevicePinProcedure:
-			walletManagerServicePromptDevicePinHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSendDevicePinProcedure:
-			walletManagerServiceSendDevicePinHandler.ServeHTTP(w, r)
-		case WalletManagerServiceCloseDeviceProcedure:
-			walletManagerServiceCloseDeviceHandler.ServeHTTP(w, r)
-		case WalletManagerServiceDeriveKeystoreProcedure:
-			walletManagerServiceDeriveKeystoreHandler.ServeHTTP(w, r)
-		case WalletManagerServicePreviewWalletFromEntropyProcedure:
-			walletManagerServicePreviewWalletFromEntropyHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetWalletSeedProcedure:
-			walletManagerServiceGetWalletSeedHandler.ServeHTTP(w, r)
-		case WalletManagerServiceListCoreVariantsProcedure:
-			walletManagerServiceListCoreVariantsHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetCoreVariantProcedure:
-			walletManagerServiceGetCoreVariantHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSetCoreVariantProcedure:
-			walletManagerServiceSetCoreVariantHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetElectrumServerProcedure:
-			walletManagerServiceGetElectrumServerHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSetElectrumServerProcedure:
-			walletManagerServiceSetElectrumServerHandler.ServeHTTP(w, r)
-		case WalletManagerServiceGetTorConfigProcedure:
-			walletManagerServiceGetTorConfigHandler.ServeHTTP(w, r)
-		case WalletManagerServiceSetTorConfigProcedure:
-			walletManagerServiceSetTorConfigHandler.ServeHTTP(w, r)
-		case WalletManagerServiceWatchWalletDataProcedure:
-			walletManagerServiceWatchWalletDataHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedWalletManagerServiceHandler) PreviewWalletFromEntropy(context.Context, *v1.PreviewWalletFromEntropyRequest) (*v1.PreviewWalletFromEntropyResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.PreviewWalletFromEntropy is not implemented")
 }
 
-// UnimplementedWalletManagerServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedWalletManagerServiceHandler struct{}
-
-func (UnimplementedWalletManagerServiceHandler) GetWalletStatus(context.Context, *connect.Request[v1.GetWalletStatusRequest]) (*connect.Response[v1.GetWalletStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetWalletStatus is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) GetWalletSeed(context.Context, *v1.GetWalletSeedRequest) (*v1.GetWalletSeedResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetWalletSeed is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListSidechainDeposits(context.Context, *connect.Request[v1.ListSidechainDepositsRequest]) (*connect.Response[v1.ListSidechainDepositsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListSidechainDeposits is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) ListCoreVariants(context.Context, *v1.ListCoreVariantsRequest) (*v1.ListCoreVariantsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.ListCoreVariants is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetSidechainDepositTotals(context.Context, *connect.Request[v1.GetSidechainDepositTotalsRequest]) (*connect.Response[v1.GetSidechainDepositTotalsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetSidechainDepositTotals is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) GetCoreVariant(context.Context, *v1.GetCoreVariantRequest) (*v1.GetCoreVariantResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetCoreVariant is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetNodeMode(context.Context, *connect.Request[v1.GetNodeModeRequest]) (*connect.Response[v1.GetNodeModeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetNodeMode is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) SetCoreVariant(context.Context, *v1.SetCoreVariantRequest) (*v1.SetCoreVariantResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SetCoreVariant is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) SetNodeMode(context.Context, *connect.Request[v1.SetNodeModeRequest]) (*connect.Response[v1.SetNodeModeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SetNodeMode is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) GetElectrumServer(context.Context, *v1.GetElectrumServerRequest) (*v1.GetElectrumServerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetElectrumServer is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) GenerateWallet(context.Context, *connect.Request[v1.GenerateWalletRequest]) (*connect.Response[v1.GenerateWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GenerateWallet is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) SetElectrumServer(context.Context, *v1.SetElectrumServerRequest) (*v1.SetElectrumServerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SetElectrumServer is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) UnlockWallet(context.Context, *connect.Request[v1.UnlockWalletRequest]) (*connect.Response[v1.UnlockWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.UnlockWallet is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) GetTorConfig(context.Context, *v1.GetTorConfigRequest) (*v1.GetTorConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.GetTorConfig is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) LockWallet(context.Context, *connect.Request[v1.LockWalletRequest]) (*connect.Response[v1.LockWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.LockWallet is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) SetTorConfig(context.Context, *v1.SetTorConfigRequest) (*v1.SetTorConfigResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.SetTorConfig is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) EncryptWallet(context.Context, *connect.Request[v1.EncryptWalletRequest]) (*connect.Response[v1.EncryptWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.EncryptWallet is not implemented"))
+func (UnimplementedWalletManagerServiceHandler) WatchWalletData(context.Context, *emptypb.Empty, WalletManagerServiceWatchWalletDataServerStream) error {
+	return connect.NewError(connect.CodeUnimplemented, "walletmanager.v1.WalletManagerService.WatchWalletData is not implemented")
 }
 
-func (UnimplementedWalletManagerServiceHandler) ChangePassword(context.Context, *connect.Request[v1.ChangePasswordRequest]) (*connect.Response[v1.ChangePasswordResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ChangePassword is not implemented"))
+type walletManagerServiceClient struct {
+	client *connect.Client
 }
 
-func (UnimplementedWalletManagerServiceHandler) RemoveEncryption(context.Context, *connect.Request[v1.RemoveEncryptionRequest]) (*connect.Response[v1.RemoveEncryptionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.RemoveEncryption is not implemented"))
+func (c *walletManagerServiceClient) GetWalletStatus(ctx context.Context, req *v1.GetWalletStatusRequest) (*v1.GetWalletStatusResponse, error) {
+	var res v1.GetWalletStatusResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetWalletStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListWallets(context.Context, *connect.Request[v1.ListWalletsRequest]) (*connect.Response[v1.ListWalletsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListWallets is not implemented"))
+func (c *walletManagerServiceClient) ListSidechainDeposits(ctx context.Context, req *v1.ListSidechainDepositsRequest) (*v1.ListSidechainDepositsResponse, error) {
+	var res v1.ListSidechainDepositsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListSidechainDepositsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) SwitchWallet(context.Context, *connect.Request[v1.SwitchWalletRequest]) (*connect.Response[v1.SwitchWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SwitchWallet is not implemented"))
+func (c *walletManagerServiceClient) GetSidechainDepositTotals(ctx context.Context, req *v1.GetSidechainDepositTotalsRequest) (*v1.GetSidechainDepositTotalsResponse, error) {
+	var res v1.GetSidechainDepositTotalsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetSidechainDepositTotalsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) UpdateWalletMetadata(context.Context, *connect.Request[v1.UpdateWalletMetadataRequest]) (*connect.Response[v1.UpdateWalletMetadataResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.UpdateWalletMetadata is not implemented"))
+func (c *walletManagerServiceClient) GetNodeMode(ctx context.Context, req *v1.GetNodeModeRequest) (*v1.GetNodeModeResponse, error) {
+	var res v1.GetNodeModeResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetNodeModeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) DeleteWallet(context.Context, *connect.Request[v1.DeleteWalletRequest]) (*connect.Response[v1.DeleteWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.DeleteWallet is not implemented"))
+func (c *walletManagerServiceClient) SetNodeMode(ctx context.Context, req *v1.SetNodeModeRequest) (*v1.SetNodeModeResponse, error) {
+	var res v1.SetNodeModeResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSetNodeModeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) DeleteAllWallets(context.Context, *connect.Request[v1.DeleteAllWalletsRequest]) (*connect.Response[v1.DeleteAllWalletsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.DeleteAllWallets is not implemented"))
+func (c *walletManagerServiceClient) GenerateWallet(ctx context.Context, req *v1.GenerateWalletRequest) (*v1.GenerateWalletResponse, error) {
+	var res v1.GenerateWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGenerateWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListWalletBackups(context.Context, *connect.Request[v1.ListWalletBackupsRequest]) (*connect.Response[v1.ListWalletBackupsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListWalletBackups is not implemented"))
+func (c *walletManagerServiceClient) UnlockWallet(ctx context.Context, req *v1.UnlockWalletRequest) (*v1.UnlockWalletResponse, error) {
+	var res v1.UnlockWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceUnlockWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) RestoreWalletBackup(context.Context, *connect.Request[v1.RestoreWalletBackupRequest]) (*connect.Response[v1.RestoreWalletBackupResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.RestoreWalletBackup is not implemented"))
+func (c *walletManagerServiceClient) LockWallet(ctx context.Context, req *v1.LockWalletRequest) (*v1.LockWalletResponse, error) {
+	var res v1.LockWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceLockWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) RestoreWalletBackupStream(context.Context, *connect.Request[v1.RestoreWalletBackupRequest], *connect.ServerStream[v1.RestoreWalletBackupProgressResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.RestoreWalletBackupStream is not implemented"))
+func (c *walletManagerServiceClient) EncryptWallet(ctx context.Context, req *v1.EncryptWalletRequest) (*v1.EncryptWalletResponse, error) {
+	var res v1.EncryptWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceEncryptWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CreateWatchOnlyWallet(context.Context, *connect.Request[v1.CreateWatchOnlyWalletRequest]) (*connect.Response[v1.CreateWatchOnlyWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CreateWatchOnlyWallet is not implemented"))
+func (c *walletManagerServiceClient) ChangePassword(ctx context.Context, req *v1.ChangePasswordRequest) (*v1.ChangePasswordResponse, error) {
+	var res v1.ChangePasswordResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceChangePasswordSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CreateElectrumWallet(context.Context, *connect.Request[v1.CreateElectrumWalletRequest]) (*connect.Response[v1.CreateElectrumWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CreateElectrumWallet is not implemented"))
+func (c *walletManagerServiceClient) RemoveEncryption(ctx context.Context, req *v1.RemoveEncryptionRequest) (*v1.RemoveEncryptionResponse, error) {
+	var res v1.RemoveEncryptionResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceRemoveEncryptionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CreateMultisigWallet(context.Context, *connect.Request[v1.CreateMultisigWalletRequest]) (*connect.Response[v1.CreateMultisigWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CreateMultisigWallet is not implemented"))
+func (c *walletManagerServiceClient) ListWallets(ctx context.Context, req *v1.ListWalletsRequest) (*v1.ListWalletsResponse, error) {
+	var res v1.ListWalletsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListWalletsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ParseMultisigConfig(context.Context, *connect.Request[v1.ParseMultisigConfigRequest]) (*connect.Response[v1.ParseMultisigConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ParseMultisigConfig is not implemented"))
+func (c *walletManagerServiceClient) SwitchWallet(ctx context.Context, req *v1.SwitchWalletRequest) (*v1.SwitchWalletResponse, error) {
+	var res v1.SwitchWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSwitchWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ValidateDescriptor(context.Context, *connect.Request[v1.ValidateDescriptorRequest]) (*connect.Response[v1.ValidateDescriptorResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ValidateDescriptor is not implemented"))
+func (c *walletManagerServiceClient) UpdateWalletMetadata(ctx context.Context, req *v1.UpdateWalletMetadataRequest) (*v1.UpdateWalletMetadataResponse, error) {
+	var res v1.UpdateWalletMetadataResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceUpdateWalletMetadataSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ValidateDerivationPath(context.Context, *connect.Request[v1.ValidateDerivationPathRequest]) (*connect.Response[v1.ValidateDerivationPathResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ValidateDerivationPath is not implemented"))
+func (c *walletManagerServiceClient) DeleteWallet(ctx context.Context, req *v1.DeleteWalletRequest) (*v1.DeleteWalletResponse, error) {
+	var res v1.DeleteWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceDeleteWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListDerivationPaths(context.Context, *connect.Request[v1.ListDerivationPathsRequest]) (*connect.Response[v1.ListDerivationPathsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListDerivationPaths is not implemented"))
+func (c *walletManagerServiceClient) DeleteAllWallets(ctx context.Context, req *v1.DeleteAllWalletsRequest) (*v1.DeleteAllWalletsResponse, error) {
+	var res v1.DeleteAllWalletsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceDeleteAllWalletsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CreateBitcoinCoreWallet(context.Context, *connect.Request[v1.CreateBitcoinCoreWalletRequest]) (*connect.Response[v1.CreateBitcoinCoreWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CreateBitcoinCoreWallet is not implemented"))
+func (c *walletManagerServiceClient) ListWalletBackups(ctx context.Context, req *v1.ListWalletBackupsRequest) (*v1.ListWalletBackupsResponse, error) {
+	var res v1.ListWalletBackupsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListWalletBackupsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) RestoreWalletBackup(ctx context.Context, req *v1.RestoreWalletBackupRequest) (*v1.RestoreWalletBackupResponse, error) {
+	var res v1.RestoreWalletBackupResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceRestoreWalletBackupSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) RestoreWalletBackupStream(ctx context.Context, req *v1.RestoreWalletBackupRequest) (WalletManagerServiceRestoreWalletBackupStreamClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, walletManagerServiceRestoreWalletBackupStreamSpec(), req)
+	if err != nil {
+		return WalletManagerServiceRestoreWalletBackupStreamClientStream{}, err
+	}
+	return WalletManagerServiceRestoreWalletBackupStreamClientStream{stream: stream}, nil
+}
+
+func (c *walletManagerServiceClient) CreateWatchOnlyWallet(ctx context.Context, req *v1.CreateWatchOnlyWalletRequest) (*v1.CreateWatchOnlyWalletResponse, error) {
+	var res v1.CreateWatchOnlyWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCreateWatchOnlyWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) CreateElectrumWallet(ctx context.Context, req *v1.CreateElectrumWalletRequest) (*v1.CreateElectrumWalletResponse, error) {
+	var res v1.CreateElectrumWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCreateElectrumWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) CreateMultisigWallet(ctx context.Context, req *v1.CreateMultisigWalletRequest) (*v1.CreateMultisigWalletResponse, error) {
+	var res v1.CreateMultisigWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCreateMultisigWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) ParseMultisigConfig(ctx context.Context, req *v1.ParseMultisigConfigRequest) (*v1.ParseMultisigConfigResponse, error) {
+	var res v1.ParseMultisigConfigResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceParseMultisigConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) ValidateDescriptor(ctx context.Context, req *v1.ValidateDescriptorRequest) (*v1.ValidateDescriptorResponse, error) {
+	var res v1.ValidateDescriptorResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceValidateDescriptorSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) ValidateDerivationPath(ctx context.Context, req *v1.ValidateDerivationPathRequest) (*v1.ValidateDerivationPathResponse, error) {
+	var res v1.ValidateDerivationPathResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceValidateDerivationPathSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) ListDerivationPaths(ctx context.Context, req *v1.ListDerivationPathsRequest) (*v1.ListDerivationPathsResponse, error) {
+	var res v1.ListDerivationPathsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListDerivationPathsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) CreateBitcoinCoreWallet(ctx context.Context, req *v1.CreateBitcoinCoreWalletRequest) (*v1.CreateBitcoinCoreWalletResponse, error) {
+	var res v1.CreateBitcoinCoreWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCreateBitcoinCoreWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) EnsureCoreWallets(ctx context.Context, req *v1.EnsureCoreWalletsRequest) (*v1.EnsureCoreWalletsResponse, error) {
+	var res v1.EnsureCoreWalletsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceEnsureCoreWalletsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) RescanWallet(ctx context.Context, req *v1.RescanWalletRequest) (*v1.RescanWalletResponse, error) {
+	var res v1.RescanWalletResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceRescanWalletSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) EstimateFee(ctx context.Context, req *v1.EstimateFeeRequest) (*v1.EstimateFeeResponse, error) {
+	var res v1.EstimateFeeResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceEstimateFeeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) GetNewAddress(ctx context.Context, req *v1.GetNewAddressRequest) (*v1.GetNewAddressResponse, error) {
+	var res v1.GetNewAddressResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetNewAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) SendTransaction(ctx context.Context, req *v1.SendTransactionRequest) (*v1.SendTransactionResponse, error) {
+	var res v1.SendTransactionResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSendTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) PreviewSend(ctx context.Context, req *v1.PreviewSendRequest) (*v1.PreviewSendResponse, error) {
+	var res v1.PreviewSendResponse
+	if err := c.client.CallUnary(ctx, walletManagerServicePreviewSendSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) SetFrozenCoins(ctx context.Context, req *v1.SetFrozenCoinsRequest) (*emptypb.Empty, error) {
+	var res emptypb.Empty
+	if err := c.client.CallUnary(ctx, walletManagerServiceSetFrozenCoinsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) ListTransactions(ctx context.Context, req *v1.ListTransactionsRequest) (*v1.ListTransactionsResponse, error) {
+	var res v1.ListTransactionsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListTransactionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) ListUnspent(ctx context.Context, req *v1.ListUnspentRequest) (*v1.ListUnspentResponse, error) {
+	var res v1.ListUnspentResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListUnspentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) ListReceiveAddresses(ctx context.Context, req *v1.ListReceiveAddressesRequest) (*v1.ListReceiveAddressesResponse, error) {
+	var res v1.ListReceiveAddressesResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListReceiveAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) GetTransactionDetails(ctx context.Context, req *v1.GetTransactionDetailsRequest) (*v1.GetTransactionDetailsResponse, error) {
+	var res v1.GetTransactionDetailsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetTransactionDetailsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) DecodeTransaction(ctx context.Context, req *v1.DecodeTransactionRequest) (*v1.DecodeTransactionResponse, error) {
+	var res v1.DecodeTransactionResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceDecodeTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) BumpFee(ctx context.Context, req *v1.BumpFeeRequest) (*v1.BumpFeeResponse, error) {
+	var res v1.BumpFeeResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceBumpFeeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) PreviewBumpFee(ctx context.Context, req *v1.PreviewBumpFeeRequest) (*v1.PreviewBumpFeeResponse, error) {
+	var res v1.PreviewBumpFeeResponse
+	if err := c.client.CallUnary(ctx, walletManagerServicePreviewBumpFeeSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) CreateCpfp(ctx context.Context, req *v1.CreateCpfpRequest) (*v1.CreateCpfpResponse, error) {
+	var res v1.CreateCpfpResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCreateCpfpSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) CancelTransaction(ctx context.Context, req *v1.CancelTransactionRequest) (*v1.CancelTransactionResponse, error) {
+	var res v1.CancelTransactionResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCancelTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) DeriveAddresses(ctx context.Context, req *v1.DeriveAddressesRequest) (*v1.DeriveAddressesResponse, error) {
+	var res v1.DeriveAddressesResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceDeriveAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *walletManagerServiceClient) CreatePsbt(ctx context.Context, req *v1.CreatePsbtRequest) (*v1.CreatePsbtResponse, error) {
+	var res v1.CreatePsbtResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCreatePsbtSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) EnsureCoreWallets(context.Context, *connect.Request[v1.EnsureCoreWalletsRequest]) (*connect.Response[v1.EnsureCoreWalletsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.EnsureCoreWallets is not implemented"))
+func (c *walletManagerServiceClient) SignPsbt(ctx context.Context, req *v1.SignPsbtRequest) (*v1.SignPsbtResponse, error) {
+	var res v1.SignPsbtResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSignPsbtSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetBalance is not implemented"))
+func (c *walletManagerServiceClient) SignPsbtWithCosigner(ctx context.Context, req *v1.SignPsbtWithCosignerRequest) (*v1.SignPsbtWithCosignerResponse, error) {
+	var res v1.SignPsbtWithCosignerResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSignPsbtWithCosignerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) RescanWallet(context.Context, *connect.Request[v1.RescanWalletRequest]) (*connect.Response[v1.RescanWalletResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.RescanWallet is not implemented"))
+func (c *walletManagerServiceClient) CombinePsbt(ctx context.Context, req *v1.CombinePsbtRequest) (*v1.CombinePsbtResponse, error) {
+	var res v1.CombinePsbtResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCombinePsbtSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) EstimateFee(context.Context, *connect.Request[v1.EstimateFeeRequest]) (*connect.Response[v1.EstimateFeeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.EstimateFee is not implemented"))
+func (c *walletManagerServiceClient) FinalizePsbt(ctx context.Context, req *v1.FinalizePsbtRequest) (*v1.FinalizePsbtResponse, error) {
+	var res v1.FinalizePsbtResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceFinalizePsbtSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetNewAddress(context.Context, *connect.Request[v1.GetNewAddressRequest]) (*connect.Response[v1.GetNewAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetNewAddress is not implemented"))
+func (c *walletManagerServiceClient) MultisigPsbtStatus(ctx context.Context, req *v1.MultisigPsbtStatusRequest) (*v1.MultisigPsbtStatusResponse, error) {
+	var res v1.MultisigPsbtStatusResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceMultisigPsbtStatusSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) SendTransaction(context.Context, *connect.Request[v1.SendTransactionRequest]) (*connect.Response[v1.SendTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SendTransaction is not implemented"))
+func (c *walletManagerServiceClient) BroadcastTransaction(ctx context.Context, req *v1.BroadcastTransactionRequest) (*v1.BroadcastTransactionResponse, error) {
+	var res v1.BroadcastTransactionResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceBroadcastTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) PreviewSend(context.Context, *connect.Request[v1.PreviewSendRequest]) (*connect.Response[v1.PreviewSendResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.PreviewSend is not implemented"))
+func (c *walletManagerServiceClient) GetAddressUnspent(ctx context.Context, req *v1.GetAddressUnspentRequest) (*v1.GetAddressUnspentResponse, error) {
+	var res v1.GetAddressUnspentResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetAddressUnspentSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) SetFrozenCoins(context.Context, *connect.Request[v1.SetFrozenCoinsRequest]) (*connect.Response[emptypb.Empty], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SetFrozenCoins is not implemented"))
+func (c *walletManagerServiceClient) BroadcastElectrumTransaction(ctx context.Context, req *v1.BroadcastElectrumTransactionRequest) (*v1.BroadcastElectrumTransactionResponse, error) {
+	var res v1.BroadcastElectrumTransactionResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceBroadcastElectrumTransactionSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CreateDeposit is not implemented"))
+func (c *walletManagerServiceClient) EnumerateHardwareDevices(ctx context.Context, req *v1.EnumerateHardwareDevicesRequest) (*v1.EnumerateHardwareDevicesResponse, error) {
+	var res v1.EnumerateHardwareDevicesResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceEnumerateHardwareDevicesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListTransactions(context.Context, *connect.Request[v1.ListTransactionsRequest]) (*connect.Response[v1.ListTransactionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListTransactions is not implemented"))
+func (c *walletManagerServiceClient) GetHardwareXpub(ctx context.Context, req *v1.GetHardwareXpubRequest) (*v1.GetHardwareXpubResponse, error) {
+	var res v1.GetHardwareXpubResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetHardwareXpubSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListUnspent(context.Context, *connect.Request[v1.ListUnspentRequest]) (*connect.Response[v1.ListUnspentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListUnspent is not implemented"))
+func (c *walletManagerServiceClient) SignPsbtWithDevice(ctx context.Context, req *v1.SignPsbtWithDeviceRequest) (*v1.SignPsbtWithDeviceResponse, error) {
+	var res v1.SignPsbtWithDeviceResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSignPsbtWithDeviceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListReceiveAddresses(context.Context, *connect.Request[v1.ListReceiveAddressesRequest]) (*connect.Response[v1.ListReceiveAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListReceiveAddresses is not implemented"))
+func (c *walletManagerServiceClient) PromptDevicePin(ctx context.Context, req *v1.PromptDevicePinRequest) (*v1.PromptDevicePinResponse, error) {
+	var res v1.PromptDevicePinResponse
+	if err := c.client.CallUnary(ctx, walletManagerServicePromptDevicePinSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetTransactionDetails(context.Context, *connect.Request[v1.GetTransactionDetailsRequest]) (*connect.Response[v1.GetTransactionDetailsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetTransactionDetails is not implemented"))
+func (c *walletManagerServiceClient) SendDevicePin(ctx context.Context, req *v1.SendDevicePinRequest) (*v1.SendDevicePinResponse, error) {
+	var res v1.SendDevicePinResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSendDevicePinSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) DecodeTransaction(context.Context, *connect.Request[v1.DecodeTransactionRequest]) (*connect.Response[v1.DecodeTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.DecodeTransaction is not implemented"))
+func (c *walletManagerServiceClient) CloseDevice(ctx context.Context, req *v1.CloseDeviceRequest) (*v1.CloseDeviceResponse, error) {
+	var res v1.CloseDeviceResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceCloseDeviceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) BumpFee(context.Context, *connect.Request[v1.BumpFeeRequest]) (*connect.Response[v1.BumpFeeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.BumpFee is not implemented"))
+func (c *walletManagerServiceClient) DeriveKeystore(ctx context.Context, req *v1.DeriveKeystoreRequest) (*v1.DeriveKeystoreResponse, error) {
+	var res v1.DeriveKeystoreResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceDeriveKeystoreSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) PreviewBumpFee(context.Context, *connect.Request[v1.PreviewBumpFeeRequest]) (*connect.Response[v1.PreviewBumpFeeResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.PreviewBumpFee is not implemented"))
+func (c *walletManagerServiceClient) PreviewWalletFromEntropy(ctx context.Context, req *v1.PreviewWalletFromEntropyRequest) (*v1.PreviewWalletFromEntropyResponse, error) {
+	var res v1.PreviewWalletFromEntropyResponse
+	if err := c.client.CallUnary(ctx, walletManagerServicePreviewWalletFromEntropySpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CreateCpfp(context.Context, *connect.Request[v1.CreateCpfpRequest]) (*connect.Response[v1.CreateCpfpResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CreateCpfp is not implemented"))
+func (c *walletManagerServiceClient) GetWalletSeed(ctx context.Context, req *v1.GetWalletSeedRequest) (*v1.GetWalletSeedResponse, error) {
+	var res v1.GetWalletSeedResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetWalletSeedSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CancelTransaction(context.Context, *connect.Request[v1.CancelTransactionRequest]) (*connect.Response[v1.CancelTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CancelTransaction is not implemented"))
+func (c *walletManagerServiceClient) ListCoreVariants(ctx context.Context, req *v1.ListCoreVariantsRequest) (*v1.ListCoreVariantsResponse, error) {
+	var res v1.ListCoreVariantsResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceListCoreVariantsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) DeriveAddresses(context.Context, *connect.Request[v1.DeriveAddressesRequest]) (*connect.Response[v1.DeriveAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.DeriveAddresses is not implemented"))
+func (c *walletManagerServiceClient) GetCoreVariant(ctx context.Context, req *v1.GetCoreVariantRequest) (*v1.GetCoreVariantResponse, error) {
+	var res v1.GetCoreVariantResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetCoreVariantSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CreatePsbt(context.Context, *connect.Request[v1.CreatePsbtRequest]) (*connect.Response[v1.CreatePsbtResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CreatePsbt is not implemented"))
+func (c *walletManagerServiceClient) SetCoreVariant(ctx context.Context, req *v1.SetCoreVariantRequest) (*v1.SetCoreVariantResponse, error) {
+	var res v1.SetCoreVariantResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSetCoreVariantSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) SignPsbt(context.Context, *connect.Request[v1.SignPsbtRequest]) (*connect.Response[v1.SignPsbtResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SignPsbt is not implemented"))
+func (c *walletManagerServiceClient) GetElectrumServer(ctx context.Context, req *v1.GetElectrumServerRequest) (*v1.GetElectrumServerResponse, error) {
+	var res v1.GetElectrumServerResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetElectrumServerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) SignPsbtWithCosigner(context.Context, *connect.Request[v1.SignPsbtWithCosignerRequest]) (*connect.Response[v1.SignPsbtWithCosignerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SignPsbtWithCosigner is not implemented"))
+func (c *walletManagerServiceClient) SetElectrumServer(ctx context.Context, req *v1.SetElectrumServerRequest) (*v1.SetElectrumServerResponse, error) {
+	var res v1.SetElectrumServerResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSetElectrumServerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) CombinePsbt(context.Context, *connect.Request[v1.CombinePsbtRequest]) (*connect.Response[v1.CombinePsbtResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CombinePsbt is not implemented"))
+func (c *walletManagerServiceClient) GetTorConfig(ctx context.Context, req *v1.GetTorConfigRequest) (*v1.GetTorConfigResponse, error) {
+	var res v1.GetTorConfigResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceGetTorConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) FinalizePsbt(context.Context, *connect.Request[v1.FinalizePsbtRequest]) (*connect.Response[v1.FinalizePsbtResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.FinalizePsbt is not implemented"))
+func (c *walletManagerServiceClient) SetTorConfig(ctx context.Context, req *v1.SetTorConfigRequest) (*v1.SetTorConfigResponse, error) {
+	var res v1.SetTorConfigResponse
+	if err := c.client.CallUnary(ctx, walletManagerServiceSetTorConfigSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) MultisigPsbtStatus(context.Context, *connect.Request[v1.MultisigPsbtStatusRequest]) (*connect.Response[v1.MultisigPsbtStatusResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.MultisigPsbtStatus is not implemented"))
+func (c *walletManagerServiceClient) WatchWalletData(ctx context.Context, req *emptypb.Empty) (WalletManagerServiceWatchWalletDataClientStream, error) {
+	stream, err := c.client.CallServerStream(ctx, walletManagerServiceWatchWalletDataSpec(), req)
+	if err != nil {
+		return WalletManagerServiceWatchWalletDataClientStream{}, err
+	}
+	return WalletManagerServiceWatchWalletDataClientStream{stream: stream}, nil
 }
 
-func (UnimplementedWalletManagerServiceHandler) BroadcastTransaction(context.Context, *connect.Request[v1.BroadcastTransactionRequest]) (*connect.Response[v1.BroadcastTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.BroadcastTransaction is not implemented"))
+type walletManagerServiceHandler struct{ svc WalletManagerServiceHandler }
+
+func (h walletManagerServiceHandler) getWalletStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetAddressUnspent(context.Context, *connect.Request[v1.GetAddressUnspentRequest]) (*connect.Response[v1.GetAddressUnspentResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetAddressUnspent is not implemented"))
+func (h walletManagerServiceHandler) listSidechainDeposits(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListSidechainDepositsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListSidechainDeposits(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) BroadcastElectrumTransaction(context.Context, *connect.Request[v1.BroadcastElectrumTransactionRequest]) (*connect.Response[v1.BroadcastElectrumTransactionResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.BroadcastElectrumTransaction is not implemented"))
+func (h walletManagerServiceHandler) getSidechainDepositTotals(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainDepositTotalsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainDepositTotals(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) EnumerateHardwareDevices(context.Context, *connect.Request[v1.EnumerateHardwareDevicesRequest]) (*connect.Response[v1.EnumerateHardwareDevicesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.EnumerateHardwareDevices is not implemented"))
+func (h walletManagerServiceHandler) getNodeMode(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNodeModeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNodeMode(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetHardwareXpub(context.Context, *connect.Request[v1.GetHardwareXpubRequest]) (*connect.Response[v1.GetHardwareXpubResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetHardwareXpub is not implemented"))
+func (h walletManagerServiceHandler) setNodeMode(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetNodeModeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetNodeMode(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) SignPsbtWithDevice(context.Context, *connect.Request[v1.SignPsbtWithDeviceRequest]) (*connect.Response[v1.SignPsbtWithDeviceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SignPsbtWithDevice is not implemented"))
+func (h walletManagerServiceHandler) generateWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) PromptDevicePin(context.Context, *connect.Request[v1.PromptDevicePinRequest]) (*connect.Response[v1.PromptDevicePinResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.PromptDevicePin is not implemented"))
+func (h walletManagerServiceHandler) unlockWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UnlockWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UnlockWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) SendDevicePin(context.Context, *connect.Request[v1.SendDevicePinRequest]) (*connect.Response[v1.SendDevicePinResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SendDevicePin is not implemented"))
+func (h walletManagerServiceHandler) lockWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.LockWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.LockWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) CloseDevice(context.Context, *connect.Request[v1.CloseDeviceRequest]) (*connect.Response[v1.CloseDeviceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.CloseDevice is not implemented"))
+func (h walletManagerServiceHandler) encryptWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EncryptWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EncryptWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) DeriveKeystore(context.Context, *connect.Request[v1.DeriveKeystoreRequest]) (*connect.Response[v1.DeriveKeystoreResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.DeriveKeystore is not implemented"))
+func (h walletManagerServiceHandler) changePassword(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ChangePasswordRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ChangePassword(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) PreviewWalletFromEntropy(context.Context, *connect.Request[v1.PreviewWalletFromEntropyRequest]) (*connect.Response[v1.PreviewWalletFromEntropyResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.PreviewWalletFromEntropy is not implemented"))
+func (h walletManagerServiceHandler) removeEncryption(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RemoveEncryptionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RemoveEncryption(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetWalletSeed(context.Context, *connect.Request[v1.GetWalletSeedRequest]) (*connect.Response[v1.GetWalletSeedResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetWalletSeed is not implemented"))
+func (h walletManagerServiceHandler) listWallets(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListWalletsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListWallets(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) ListCoreVariants(context.Context, *connect.Request[v1.ListCoreVariantsRequest]) (*connect.Response[v1.ListCoreVariantsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.ListCoreVariants is not implemented"))
+func (h walletManagerServiceHandler) switchWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SwitchWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SwitchWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetCoreVariant(context.Context, *connect.Request[v1.GetCoreVariantRequest]) (*connect.Response[v1.GetCoreVariantResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetCoreVariant is not implemented"))
+func (h walletManagerServiceHandler) updateWalletMetadata(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UpdateWalletMetadataRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.UpdateWalletMetadata(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) SetCoreVariant(context.Context, *connect.Request[v1.SetCoreVariantRequest]) (*connect.Response[v1.SetCoreVariantResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SetCoreVariant is not implemented"))
+func (h walletManagerServiceHandler) deleteWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeleteWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetElectrumServer(context.Context, *connect.Request[v1.GetElectrumServerRequest]) (*connect.Response[v1.GetElectrumServerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetElectrumServer is not implemented"))
+func (h walletManagerServiceHandler) deleteAllWallets(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeleteAllWalletsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeleteAllWallets(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) SetElectrumServer(context.Context, *connect.Request[v1.SetElectrumServerRequest]) (*connect.Response[v1.SetElectrumServerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SetElectrumServer is not implemented"))
+func (h walletManagerServiceHandler) listWalletBackups(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListWalletBackupsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListWalletBackups(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) restoreWalletBackup(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RestoreWalletBackupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RestoreWalletBackup(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) GetTorConfig(context.Context, *connect.Request[v1.GetTorConfigRequest]) (*connect.Response[v1.GetTorConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.GetTorConfig is not implemented"))
+func (h walletManagerServiceHandler) restoreWalletBackupStream(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RestoreWalletBackupRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.RestoreWalletBackupStream(ctx, &req, WalletManagerServiceRestoreWalletBackupStreamServerStream{stream: stream})
+}
+
+func (h walletManagerServiceHandler) createWatchOnlyWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateWatchOnlyWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateWatchOnlyWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) SetTorConfig(context.Context, *connect.Request[v1.SetTorConfigRequest]) (*connect.Response[v1.SetTorConfigResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.SetTorConfig is not implemented"))
+func (h walletManagerServiceHandler) createElectrumWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateElectrumWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateElectrumWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) createMultisigWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateMultisigWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateMultisigWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) parseMultisigConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ParseMultisigConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ParseMultisigConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) validateDescriptor(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ValidateDescriptorRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ValidateDescriptor(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) validateDerivationPath(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ValidateDerivationPathRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ValidateDerivationPath(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) listDerivationPaths(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListDerivationPathsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListDerivationPaths(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedWalletManagerServiceHandler) WatchWalletData(context.Context, *connect.Request[emptypb.Empty], *connect.ServerStream[v1.WatchWalletDataResponse]) error {
-	return connect.NewError(connect.CodeUnimplemented, errors.New("walletmanager.v1.WalletManagerService.WatchWalletData is not implemented"))
+func (h walletManagerServiceHandler) createBitcoinCoreWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateBitcoinCoreWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateBitcoinCoreWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) ensureCoreWallets(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EnsureCoreWalletsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EnsureCoreWallets(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) rescanWallet(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RescanWalletRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RescanWallet(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) estimateFee(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EstimateFeeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EstimateFee(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getNewAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) sendTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SendTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SendTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) previewSend(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PreviewSendRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PreviewSend(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) setFrozenCoins(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetFrozenCoinsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetFrozenCoins(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) listTransactions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListTransactionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListTransactions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) listUnspent(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUnspentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUnspent(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) listReceiveAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListReceiveAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListReceiveAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getTransactionDetails(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransactionDetailsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransactionDetails(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) decodeTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DecodeTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DecodeTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) bumpFee(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BumpFeeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BumpFee(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) previewBumpFee(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PreviewBumpFeeRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PreviewBumpFee(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) createCpfp(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateCpfpRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateCpfp(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) cancelTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CancelTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CancelTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) deriveAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeriveAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeriveAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) createPsbt(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreatePsbtRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreatePsbt(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) signPsbt(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignPsbtRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignPsbt(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) signPsbtWithCosigner(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignPsbtWithCosignerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignPsbtWithCosigner(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) combinePsbt(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CombinePsbtRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CombinePsbt(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) finalizePsbt(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.FinalizePsbtRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.FinalizePsbt(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) multisigPsbtStatus(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MultisigPsbtStatusRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.MultisigPsbtStatus(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) broadcastTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BroadcastTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BroadcastTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getAddressUnspent(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetAddressUnspentRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetAddressUnspent(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) broadcastElectrumTransaction(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.BroadcastElectrumTransactionRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.BroadcastElectrumTransaction(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) enumerateHardwareDevices(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.EnumerateHardwareDevicesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.EnumerateHardwareDevices(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getHardwareXpub(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetHardwareXpubRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetHardwareXpub(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) signPsbtWithDevice(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SignPsbtWithDeviceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SignPsbtWithDevice(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) promptDevicePin(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PromptDevicePinRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PromptDevicePin(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) sendDevicePin(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SendDevicePinRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SendDevicePin(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) closeDevice(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CloseDeviceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CloseDevice(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) deriveKeystore(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.DeriveKeystoreRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.DeriveKeystore(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) previewWalletFromEntropy(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.PreviewWalletFromEntropyRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.PreviewWalletFromEntropy(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getWalletSeed(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletSeedRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletSeed(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) listCoreVariants(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListCoreVariantsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListCoreVariants(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getCoreVariant(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetCoreVariantRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetCoreVariant(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) setCoreVariant(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetCoreVariantRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetCoreVariant(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getElectrumServer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetElectrumServerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetElectrumServer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) setElectrumServer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetElectrumServerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetElectrumServer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) getTorConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTorConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTorConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) setTorConfig(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetTorConfigRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetTorConfig(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h walletManagerServiceHandler) watchWalletData(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req emptypb.Empty
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	return h.svc.WatchWalletData(ctx, &req, WalletManagerServiceWatchWalletDataServerStream{stream: stream})
 }
diff --git a/sidechain-orchestrator/gen/zside/v1/zsidev1connect/zside.connect.go b/sidechain-orchestrator/gen/zside/v1/zsidev1connect/zside.connect.go
index 2afbf3a807..b272929f6c 100644
--- a/sidechain-orchestrator/gen/zside/v1/zsidev1connect/zside.connect.go
+++ b/sidechain-orchestrator/gen/zside/v1/zsidev1connect/zside.connect.go
@@ -5,996 +5,1152 @@
 package zsidev1connect
 
 import (
-	connect "connectrpc.com/connect"
+	connect "connectrpc.com/connect/v2"
 	context "context"
-	errors "errors"
 	v1 "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/zside/v1"
-	http "net/http"
-	strings "strings"
+	sync "sync"
 )
 
-// This is a compile-time assertion to ensure that this generated file and the connect package are
-// compatible. If you get a compiler error that this constant is not defined, this code was
-// generated with a version of connect newer than the one compiled into your binary. You can fix the
-// problem by either regenerating this code with an older version of connect or updating the connect
-// version compiled into your binary.
-const _ = connect.IsAtLeastVersion1_13_0
-
 const (
 	// ZSideServiceName is the fully-qualified name of the ZSideService service.
 	ZSideServiceName = "zside.v1.ZSideService"
 )
 
-// These constants are the fully-qualified names of the RPCs defined in this package. They're
-// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+// These constants are the procedure names of the RPCs defined in this package. They're exposed at
+// runtime as Spec.Procedure and as the final two segments of the HTTP route.
 //
 // Note that these are different from the fully-qualified method names used by
 // google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
 // reflection-formatted method names, remove the leading slash and convert the remaining slash to a
 // period.
 const (
-	// ZSideServiceGetBalanceProcedure is the fully-qualified name of the ZSideService's GetBalance RPC.
+	// ZSideServiceGetBalanceProcedure is the procedure name of the ZSideService's GetBalance RPC.
 	ZSideServiceGetBalanceProcedure = "/zside.v1.ZSideService/GetBalance"
-	// ZSideServiceGetBlockCountProcedure is the fully-qualified name of the ZSideService's
-	// GetBlockCount RPC.
+	// ZSideServiceGetBlockCountProcedure is the procedure name of the ZSideService's GetBlockCount RPC.
 	ZSideServiceGetBlockCountProcedure = "/zside.v1.ZSideService/GetBlockCount"
-	// ZSideServiceStopProcedure is the fully-qualified name of the ZSideService's Stop RPC.
+	// ZSideServiceStopProcedure is the procedure name of the ZSideService's Stop RPC.
 	ZSideServiceStopProcedure = "/zside.v1.ZSideService/Stop"
-	// ZSideServiceWithdrawProcedure is the fully-qualified name of the ZSideService's Withdraw RPC.
+	// ZSideServiceWithdrawProcedure is the procedure name of the ZSideService's Withdraw RPC.
 	ZSideServiceWithdrawProcedure = "/zside.v1.ZSideService/Withdraw"
-	// ZSideServiceTransferProcedure is the fully-qualified name of the ZSideService's Transfer RPC.
+	// ZSideServiceTransferProcedure is the procedure name of the ZSideService's Transfer RPC.
 	ZSideServiceTransferProcedure = "/zside.v1.ZSideService/Transfer"
-	// ZSideServiceGetSidechainWealthProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetSidechainWealthProcedure is the procedure name of the ZSideService's
 	// GetSidechainWealth RPC.
 	ZSideServiceGetSidechainWealthProcedure = "/zside.v1.ZSideService/GetSidechainWealth"
-	// ZSideServiceCreateDepositProcedure is the fully-qualified name of the ZSideService's
-	// CreateDeposit RPC.
+	// ZSideServiceCreateDepositProcedure is the procedure name of the ZSideService's CreateDeposit RPC.
 	ZSideServiceCreateDepositProcedure = "/zside.v1.ZSideService/CreateDeposit"
-	// ZSideServiceGetPendingWithdrawalBundleProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetPendingWithdrawalBundleProcedure is the procedure name of the ZSideService's
 	// GetPendingWithdrawalBundle RPC.
 	ZSideServiceGetPendingWithdrawalBundleProcedure = "/zside.v1.ZSideService/GetPendingWithdrawalBundle"
-	// ZSideServiceConnectPeerProcedure is the fully-qualified name of the ZSideService's ConnectPeer
-	// RPC.
+	// ZSideServiceConnectPeerProcedure is the procedure name of the ZSideService's ConnectPeer RPC.
 	ZSideServiceConnectPeerProcedure = "/zside.v1.ZSideService/ConnectPeer"
-	// ZSideServiceListPeersProcedure is the fully-qualified name of the ZSideService's ListPeers RPC.
+	// ZSideServiceListPeersProcedure is the procedure name of the ZSideService's ListPeers RPC.
 	ZSideServiceListPeersProcedure = "/zside.v1.ZSideService/ListPeers"
-	// ZSideServiceMineProcedure is the fully-qualified name of the ZSideService's Mine RPC.
+	// ZSideServiceMineProcedure is the procedure name of the ZSideService's Mine RPC.
 	ZSideServiceMineProcedure = "/zside.v1.ZSideService/Mine"
-	// ZSideServiceGetBlockProcedure is the fully-qualified name of the ZSideService's GetBlock RPC.
+	// ZSideServiceGetBlockProcedure is the procedure name of the ZSideService's GetBlock RPC.
 	ZSideServiceGetBlockProcedure = "/zside.v1.ZSideService/GetBlock"
-	// ZSideServiceGetBestMainchainBlockHashProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetBestMainchainBlockHashProcedure is the procedure name of the ZSideService's
 	// GetBestMainchainBlockHash RPC.
 	ZSideServiceGetBestMainchainBlockHashProcedure = "/zside.v1.ZSideService/GetBestMainchainBlockHash"
-	// ZSideServiceGetBestSidechainBlockHashProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetBestSidechainBlockHashProcedure is the procedure name of the ZSideService's
 	// GetBestSidechainBlockHash RPC.
 	ZSideServiceGetBestSidechainBlockHashProcedure = "/zside.v1.ZSideService/GetBestSidechainBlockHash"
-	// ZSideServiceGetBmmInclusionsProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetBmmInclusionsProcedure is the procedure name of the ZSideService's
 	// GetBmmInclusions RPC.
 	ZSideServiceGetBmmInclusionsProcedure = "/zside.v1.ZSideService/GetBmmInclusions"
-	// ZSideServiceGetWalletUtxosProcedure is the fully-qualified name of the ZSideService's
-	// GetWalletUtxos RPC.
+	// ZSideServiceGetWalletUtxosProcedure is the procedure name of the ZSideService's GetWalletUtxos
+	// RPC.
 	ZSideServiceGetWalletUtxosProcedure = "/zside.v1.ZSideService/GetWalletUtxos"
-	// ZSideServiceListUtxosProcedure is the fully-qualified name of the ZSideService's ListUtxos RPC.
+	// ZSideServiceListUtxosProcedure is the procedure name of the ZSideService's ListUtxos RPC.
 	ZSideServiceListUtxosProcedure = "/zside.v1.ZSideService/ListUtxos"
-	// ZSideServiceRemoveFromMempoolProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceRemoveFromMempoolProcedure is the procedure name of the ZSideService's
 	// RemoveFromMempool RPC.
 	ZSideServiceRemoveFromMempoolProcedure = "/zside.v1.ZSideService/RemoveFromMempool"
-	// ZSideServiceGetLatestFailedWithdrawalBundleHeightProcedure is the fully-qualified name of the
+	// ZSideServiceGetLatestFailedWithdrawalBundleHeightProcedure is the procedure name of the
 	// ZSideService's GetLatestFailedWithdrawalBundleHeight RPC.
 	ZSideServiceGetLatestFailedWithdrawalBundleHeightProcedure = "/zside.v1.ZSideService/GetLatestFailedWithdrawalBundleHeight"
-	// ZSideServiceGenerateMnemonicProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGenerateMnemonicProcedure is the procedure name of the ZSideService's
 	// GenerateMnemonic RPC.
 	ZSideServiceGenerateMnemonicProcedure = "/zside.v1.ZSideService/GenerateMnemonic"
-	// ZSideServiceSetSeedFromMnemonicProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceSetSeedFromMnemonicProcedure is the procedure name of the ZSideService's
 	// SetSeedFromMnemonic RPC.
 	ZSideServiceSetSeedFromMnemonicProcedure = "/zside.v1.ZSideService/SetSeedFromMnemonic"
-	// ZSideServiceCallRawProcedure is the fully-qualified name of the ZSideService's CallRaw RPC.
+	// ZSideServiceCallRawProcedure is the procedure name of the ZSideService's CallRaw RPC.
 	ZSideServiceCallRawProcedure = "/zside.v1.ZSideService/CallRaw"
-	// ZSideServiceGetNewShieldedAddressProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetNewShieldedAddressProcedure is the procedure name of the ZSideService's
 	// GetNewShieldedAddress RPC.
 	ZSideServiceGetNewShieldedAddressProcedure = "/zside.v1.ZSideService/GetNewShieldedAddress"
-	// ZSideServiceGetNewTransparentAddressProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetNewTransparentAddressProcedure is the procedure name of the ZSideService's
 	// GetNewTransparentAddress RPC.
 	ZSideServiceGetNewTransparentAddressProcedure = "/zside.v1.ZSideService/GetNewTransparentAddress"
-	// ZSideServiceGetShieldedWalletAddressesProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceGetShieldedWalletAddressesProcedure is the procedure name of the ZSideService's
 	// GetShieldedWalletAddresses RPC.
 	ZSideServiceGetShieldedWalletAddressesProcedure = "/zside.v1.ZSideService/GetShieldedWalletAddresses"
-	// ZSideServiceGetTransparentWalletAddressesProcedure is the fully-qualified name of the
-	// ZSideService's GetTransparentWalletAddresses RPC.
+	// ZSideServiceGetTransparentWalletAddressesProcedure is the procedure name of the ZSideService's
+	// GetTransparentWalletAddresses RPC.
 	ZSideServiceGetTransparentWalletAddressesProcedure = "/zside.v1.ZSideService/GetTransparentWalletAddresses"
-	// ZSideServiceShieldProcedure is the fully-qualified name of the ZSideService's Shield RPC.
+	// ZSideServiceShieldProcedure is the procedure name of the ZSideService's Shield RPC.
 	ZSideServiceShieldProcedure = "/zside.v1.ZSideService/Shield"
-	// ZSideServiceUnshieldProcedure is the fully-qualified name of the ZSideService's Unshield RPC.
+	// ZSideServiceUnshieldProcedure is the procedure name of the ZSideService's Unshield RPC.
 	ZSideServiceUnshieldProcedure = "/zside.v1.ZSideService/Unshield"
-	// ZSideServiceShieldedTransferProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceShieldedTransferProcedure is the procedure name of the ZSideService's
 	// ShieldedTransfer RPC.
 	ZSideServiceShieldedTransferProcedure = "/zside.v1.ZSideService/ShieldedTransfer"
-	// ZSideServiceTransparentTransferProcedure is the fully-qualified name of the ZSideService's
+	// ZSideServiceTransparentTransferProcedure is the procedure name of the ZSideService's
 	// TransparentTransfer RPC.
 	ZSideServiceTransparentTransferProcedure = "/zside.v1.ZSideService/TransparentTransfer"
 )
 
+var (
+	zSideServiceGetBalanceSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetBalance"),
+			Procedure:  ZSideServiceGetBalanceProcedure,
+		}
+	})
+	zSideServiceGetBlockCountSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetBlockCount"),
+			Procedure:  ZSideServiceGetBlockCountProcedure,
+		}
+	})
+	zSideServiceStopSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("Stop"),
+			Procedure:  ZSideServiceStopProcedure,
+		}
+	})
+	zSideServiceWithdrawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("Withdraw"),
+			Procedure:  ZSideServiceWithdrawProcedure,
+		}
+	})
+	zSideServiceTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("Transfer"),
+			Procedure:  ZSideServiceTransferProcedure,
+		}
+	})
+	zSideServiceGetSidechainWealthSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetSidechainWealth"),
+			Procedure:  ZSideServiceGetSidechainWealthProcedure,
+		}
+	})
+	zSideServiceCreateDepositSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("CreateDeposit"),
+			Procedure:  ZSideServiceCreateDepositProcedure,
+		}
+	})
+	zSideServiceGetPendingWithdrawalBundleSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetPendingWithdrawalBundle"),
+			Procedure:  ZSideServiceGetPendingWithdrawalBundleProcedure,
+		}
+	})
+	zSideServiceConnectPeerSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("ConnectPeer"),
+			Procedure:  ZSideServiceConnectPeerProcedure,
+		}
+	})
+	zSideServiceListPeersSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("ListPeers"),
+			Procedure:  ZSideServiceListPeersProcedure,
+		}
+	})
+	zSideServiceMineSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("Mine"),
+			Procedure:  ZSideServiceMineProcedure,
+		}
+	})
+	zSideServiceGetBlockSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetBlock"),
+			Procedure:  ZSideServiceGetBlockProcedure,
+		}
+	})
+	zSideServiceGetBestMainchainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetBestMainchainBlockHash"),
+			Procedure:  ZSideServiceGetBestMainchainBlockHashProcedure,
+		}
+	})
+	zSideServiceGetBestSidechainBlockHashSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetBestSidechainBlockHash"),
+			Procedure:  ZSideServiceGetBestSidechainBlockHashProcedure,
+		}
+	})
+	zSideServiceGetBmmInclusionsSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetBmmInclusions"),
+			Procedure:  ZSideServiceGetBmmInclusionsProcedure,
+		}
+	})
+	zSideServiceGetWalletUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetWalletUtxos"),
+			Procedure:  ZSideServiceGetWalletUtxosProcedure,
+		}
+	})
+	zSideServiceListUtxosSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("ListUtxos"),
+			Procedure:  ZSideServiceListUtxosProcedure,
+		}
+	})
+	zSideServiceRemoveFromMempoolSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("RemoveFromMempool"),
+			Procedure:  ZSideServiceRemoveFromMempoolProcedure,
+		}
+	})
+	zSideServiceGetLatestFailedWithdrawalBundleHeightSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetLatestFailedWithdrawalBundleHeight"),
+			Procedure:  ZSideServiceGetLatestFailedWithdrawalBundleHeightProcedure,
+		}
+	})
+	zSideServiceGenerateMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GenerateMnemonic"),
+			Procedure:  ZSideServiceGenerateMnemonicProcedure,
+		}
+	})
+	zSideServiceSetSeedFromMnemonicSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("SetSeedFromMnemonic"),
+			Procedure:  ZSideServiceSetSeedFromMnemonicProcedure,
+		}
+	})
+	zSideServiceCallRawSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("CallRaw"),
+			Procedure:  ZSideServiceCallRawProcedure,
+		}
+	})
+	zSideServiceGetNewShieldedAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetNewShieldedAddress"),
+			Procedure:  ZSideServiceGetNewShieldedAddressProcedure,
+		}
+	})
+	zSideServiceGetNewTransparentAddressSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetNewTransparentAddress"),
+			Procedure:  ZSideServiceGetNewTransparentAddressProcedure,
+		}
+	})
+	zSideServiceGetShieldedWalletAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetShieldedWalletAddresses"),
+			Procedure:  ZSideServiceGetShieldedWalletAddressesProcedure,
+		}
+	})
+	zSideServiceGetTransparentWalletAddressesSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("GetTransparentWalletAddresses"),
+			Procedure:  ZSideServiceGetTransparentWalletAddressesProcedure,
+		}
+	})
+	zSideServiceShieldSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("Shield"),
+			Procedure:  ZSideServiceShieldProcedure,
+		}
+	})
+	zSideServiceUnshieldSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("Unshield"),
+			Procedure:  ZSideServiceUnshieldProcedure,
+		}
+	})
+	zSideServiceShieldedTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("ShieldedTransfer"),
+			Procedure:  ZSideServiceShieldedTransferProcedure,
+		}
+	})
+	zSideServiceTransparentTransferSpec = sync.OnceValue(func() connect.Spec {
+		return connect.Spec{
+			StreamType: connect.StreamTypeUnary,
+			Schema:     v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods().ByName("TransparentTransfer"),
+			Procedure:  ZSideServiceTransparentTransferProcedure,
+		}
+	})
+)
+
 // ZSideServiceClient is a client for the zside.v1.ZSideService service.
 type ZSideServiceClient interface {
-	// Get wallet balance (total and available, both transparent and shielded).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the zside node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain (transparent).
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get a new shielded address.
-	GetNewShieldedAddress(context.Context, *connect.Request[v1.GetNewShieldedAddressRequest]) (*connect.Response[v1.GetNewShieldedAddressResponse], error)
-	// Get a new transparent address.
-	GetNewTransparentAddress(context.Context, *connect.Request[v1.GetNewTransparentAddressRequest]) (*connect.Response[v1.GetNewTransparentAddressResponse], error)
-	// Get shielded wallet addresses.
-	GetShieldedWalletAddresses(context.Context, *connect.Request[v1.GetShieldedWalletAddressesRequest]) (*connect.Response[v1.GetShieldedWalletAddressesResponse], error)
-	// Get transparent wallet addresses.
-	GetTransparentWalletAddresses(context.Context, *connect.Request[v1.GetTransparentWalletAddressesRequest]) (*connect.Response[v1.GetTransparentWalletAddressesResponse], error)
-	// Shield transparent funds to shielded pool.
-	Shield(context.Context, *connect.Request[v1.ShieldRequest]) (*connect.Response[v1.ShieldResponse], error)
-	// Unshield (deshield) shielded funds to transparent pool.
-	Unshield(context.Context, *connect.Request[v1.UnshieldRequest]) (*connect.Response[v1.UnshieldResponse], error)
-	// Send a shielded transfer.
-	ShieldedTransfer(context.Context, *connect.Request[v1.ShieldedTransferRequest]) (*connect.Response[v1.ShieldedTransferResponse], error)
-	// Send a transparent transfer.
-	TransparentTransfer(context.Context, *connect.Request[v1.TransparentTransferRequest]) (*connect.Response[v1.TransparentTransferResponse], error)
-}
-
-// NewZSideServiceClient constructs a client for the zside.v1.ZSideService service. By default, it
-// uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
-// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
-// connect.WithGRPCWeb() options.
-//
-// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
-// http://api.acme.com or https://acme.com/grpc).
-func NewZSideServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ZSideServiceClient {
-	baseURL = strings.TrimRight(baseURL, "/")
-	zSideServiceMethods := v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods()
-	return &zSideServiceClient{
-		getBalance: connect.NewClient[v1.GetBalanceRequest, v1.GetBalanceResponse](
-			httpClient,
-			baseURL+ZSideServiceGetBalanceProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetBalance")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlockCount: connect.NewClient[v1.GetBlockCountRequest, v1.GetBlockCountResponse](
-			httpClient,
-			baseURL+ZSideServiceGetBlockCountProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetBlockCount")),
-			connect.WithClientOptions(opts...),
-		),
-		stop: connect.NewClient[v1.StopRequest, v1.StopResponse](
-			httpClient,
-			baseURL+ZSideServiceStopProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("Stop")),
-			connect.WithClientOptions(opts...),
-		),
-		withdraw: connect.NewClient[v1.WithdrawRequest, v1.WithdrawResponse](
-			httpClient,
-			baseURL+ZSideServiceWithdrawProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("Withdraw")),
-			connect.WithClientOptions(opts...),
-		),
-		transfer: connect.NewClient[v1.TransferRequest, v1.TransferResponse](
-			httpClient,
-			baseURL+ZSideServiceTransferProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("Transfer")),
-			connect.WithClientOptions(opts...),
-		),
-		getSidechainWealth: connect.NewClient[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse](
-			httpClient,
-			baseURL+ZSideServiceGetSidechainWealthProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetSidechainWealth")),
-			connect.WithClientOptions(opts...),
-		),
-		createDeposit: connect.NewClient[v1.CreateDepositRequest, v1.CreateDepositResponse](
-			httpClient,
-			baseURL+ZSideServiceCreateDepositProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("CreateDeposit")),
-			connect.WithClientOptions(opts...),
-		),
-		getPendingWithdrawalBundle: connect.NewClient[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse](
-			httpClient,
-			baseURL+ZSideServiceGetPendingWithdrawalBundleProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetPendingWithdrawalBundle")),
-			connect.WithClientOptions(opts...),
-		),
-		connectPeer: connect.NewClient[v1.ConnectPeerRequest, v1.ConnectPeerResponse](
-			httpClient,
-			baseURL+ZSideServiceConnectPeerProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("ConnectPeer")),
-			connect.WithClientOptions(opts...),
-		),
-		listPeers: connect.NewClient[v1.ListPeersRequest, v1.ListPeersResponse](
-			httpClient,
-			baseURL+ZSideServiceListPeersProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("ListPeers")),
-			connect.WithClientOptions(opts...),
-		),
-		mine: connect.NewClient[v1.MineRequest, v1.MineResponse](
-			httpClient,
-			baseURL+ZSideServiceMineProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("Mine")),
-			connect.WithClientOptions(opts...),
-		),
-		getBlock: connect.NewClient[v1.GetBlockRequest, v1.GetBlockResponse](
-			httpClient,
-			baseURL+ZSideServiceGetBlockProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetBlock")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestMainchainBlockHash: connect.NewClient[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse](
-			httpClient,
-			baseURL+ZSideServiceGetBestMainchainBlockHashProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetBestMainchainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBestSidechainBlockHash: connect.NewClient[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse](
-			httpClient,
-			baseURL+ZSideServiceGetBestSidechainBlockHashProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetBestSidechainBlockHash")),
-			connect.WithClientOptions(opts...),
-		),
-		getBmmInclusions: connect.NewClient[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse](
-			httpClient,
-			baseURL+ZSideServiceGetBmmInclusionsProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetBmmInclusions")),
-			connect.WithClientOptions(opts...),
-		),
-		getWalletUtxos: connect.NewClient[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse](
-			httpClient,
-			baseURL+ZSideServiceGetWalletUtxosProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetWalletUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		listUtxos: connect.NewClient[v1.ListUtxosRequest, v1.ListUtxosResponse](
-			httpClient,
-			baseURL+ZSideServiceListUtxosProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("ListUtxos")),
-			connect.WithClientOptions(opts...),
-		),
-		removeFromMempool: connect.NewClient[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse](
-			httpClient,
-			baseURL+ZSideServiceRemoveFromMempoolProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("RemoveFromMempool")),
-			connect.WithClientOptions(opts...),
-		),
-		getLatestFailedWithdrawalBundleHeight: connect.NewClient[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse](
-			httpClient,
-			baseURL+ZSideServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-			connect.WithClientOptions(opts...),
-		),
-		generateMnemonic: connect.NewClient[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse](
-			httpClient,
-			baseURL+ZSideServiceGenerateMnemonicProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GenerateMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		setSeedFromMnemonic: connect.NewClient[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse](
-			httpClient,
-			baseURL+ZSideServiceSetSeedFromMnemonicProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("SetSeedFromMnemonic")),
-			connect.WithClientOptions(opts...),
-		),
-		callRaw: connect.NewClient[v1.CallRawRequest, v1.CallRawResponse](
-			httpClient,
-			baseURL+ZSideServiceCallRawProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("CallRaw")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewShieldedAddress: connect.NewClient[v1.GetNewShieldedAddressRequest, v1.GetNewShieldedAddressResponse](
-			httpClient,
-			baseURL+ZSideServiceGetNewShieldedAddressProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetNewShieldedAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		getNewTransparentAddress: connect.NewClient[v1.GetNewTransparentAddressRequest, v1.GetNewTransparentAddressResponse](
-			httpClient,
-			baseURL+ZSideServiceGetNewTransparentAddressProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetNewTransparentAddress")),
-			connect.WithClientOptions(opts...),
-		),
-		getShieldedWalletAddresses: connect.NewClient[v1.GetShieldedWalletAddressesRequest, v1.GetShieldedWalletAddressesResponse](
-			httpClient,
-			baseURL+ZSideServiceGetShieldedWalletAddressesProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetShieldedWalletAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		getTransparentWalletAddresses: connect.NewClient[v1.GetTransparentWalletAddressesRequest, v1.GetTransparentWalletAddressesResponse](
-			httpClient,
-			baseURL+ZSideServiceGetTransparentWalletAddressesProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("GetTransparentWalletAddresses")),
-			connect.WithClientOptions(opts...),
-		),
-		shield: connect.NewClient[v1.ShieldRequest, v1.ShieldResponse](
-			httpClient,
-			baseURL+ZSideServiceShieldProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("Shield")),
-			connect.WithClientOptions(opts...),
-		),
-		unshield: connect.NewClient[v1.UnshieldRequest, v1.UnshieldResponse](
-			httpClient,
-			baseURL+ZSideServiceUnshieldProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("Unshield")),
-			connect.WithClientOptions(opts...),
-		),
-		shieldedTransfer: connect.NewClient[v1.ShieldedTransferRequest, v1.ShieldedTransferResponse](
-			httpClient,
-			baseURL+ZSideServiceShieldedTransferProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("ShieldedTransfer")),
-			connect.WithClientOptions(opts...),
-		),
-		transparentTransfer: connect.NewClient[v1.TransparentTransferRequest, v1.TransparentTransferResponse](
-			httpClient,
-			baseURL+ZSideServiceTransparentTransferProcedure,
-			connect.WithSchema(zSideServiceMethods.ByName("TransparentTransfer")),
-			connect.WithClientOptions(opts...),
-		),
-	}
-}
-
-// zSideServiceClient implements ZSideServiceClient.
-type zSideServiceClient struct {
-	getBalance                            *connect.Client[v1.GetBalanceRequest, v1.GetBalanceResponse]
-	getBlockCount                         *connect.Client[v1.GetBlockCountRequest, v1.GetBlockCountResponse]
-	stop                                  *connect.Client[v1.StopRequest, v1.StopResponse]
-	withdraw                              *connect.Client[v1.WithdrawRequest, v1.WithdrawResponse]
-	transfer                              *connect.Client[v1.TransferRequest, v1.TransferResponse]
-	getSidechainWealth                    *connect.Client[v1.GetSidechainWealthRequest, v1.GetSidechainWealthResponse]
-	createDeposit                         *connect.Client[v1.CreateDepositRequest, v1.CreateDepositResponse]
-	getPendingWithdrawalBundle            *connect.Client[v1.GetPendingWithdrawalBundleRequest, v1.GetPendingWithdrawalBundleResponse]
-	connectPeer                           *connect.Client[v1.ConnectPeerRequest, v1.ConnectPeerResponse]
-	listPeers                             *connect.Client[v1.ListPeersRequest, v1.ListPeersResponse]
-	mine                                  *connect.Client[v1.MineRequest, v1.MineResponse]
-	getBlock                              *connect.Client[v1.GetBlockRequest, v1.GetBlockResponse]
-	getBestMainchainBlockHash             *connect.Client[v1.GetBestMainchainBlockHashRequest, v1.GetBestMainchainBlockHashResponse]
-	getBestSidechainBlockHash             *connect.Client[v1.GetBestSidechainBlockHashRequest, v1.GetBestSidechainBlockHashResponse]
-	getBmmInclusions                      *connect.Client[v1.GetBmmInclusionsRequest, v1.GetBmmInclusionsResponse]
-	getWalletUtxos                        *connect.Client[v1.GetWalletUtxosRequest, v1.GetWalletUtxosResponse]
-	listUtxos                             *connect.Client[v1.ListUtxosRequest, v1.ListUtxosResponse]
-	removeFromMempool                     *connect.Client[v1.RemoveFromMempoolRequest, v1.RemoveFromMempoolResponse]
-	getLatestFailedWithdrawalBundleHeight *connect.Client[v1.GetLatestFailedWithdrawalBundleHeightRequest, v1.GetLatestFailedWithdrawalBundleHeightResponse]
-	generateMnemonic                      *connect.Client[v1.GenerateMnemonicRequest, v1.GenerateMnemonicResponse]
-	setSeedFromMnemonic                   *connect.Client[v1.SetSeedFromMnemonicRequest, v1.SetSeedFromMnemonicResponse]
-	callRaw                               *connect.Client[v1.CallRawRequest, v1.CallRawResponse]
-	getNewShieldedAddress                 *connect.Client[v1.GetNewShieldedAddressRequest, v1.GetNewShieldedAddressResponse]
-	getNewTransparentAddress              *connect.Client[v1.GetNewTransparentAddressRequest, v1.GetNewTransparentAddressResponse]
-	getShieldedWalletAddresses            *connect.Client[v1.GetShieldedWalletAddressesRequest, v1.GetShieldedWalletAddressesResponse]
-	getTransparentWalletAddresses         *connect.Client[v1.GetTransparentWalletAddressesRequest, v1.GetTransparentWalletAddressesResponse]
-	shield                                *connect.Client[v1.ShieldRequest, v1.ShieldResponse]
-	unshield                              *connect.Client[v1.UnshieldRequest, v1.UnshieldResponse]
-	shieldedTransfer                      *connect.Client[v1.ShieldedTransferRequest, v1.ShieldedTransferResponse]
-	transparentTransfer                   *connect.Client[v1.TransparentTransferRequest, v1.TransparentTransferResponse]
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetNewShieldedAddress(context.Context, *v1.GetNewShieldedAddressRequest) (*v1.GetNewShieldedAddressResponse, error)
+	GetNewTransparentAddress(context.Context, *v1.GetNewTransparentAddressRequest) (*v1.GetNewTransparentAddressResponse, error)
+	GetShieldedWalletAddresses(context.Context, *v1.GetShieldedWalletAddressesRequest) (*v1.GetShieldedWalletAddressesResponse, error)
+	GetTransparentWalletAddresses(context.Context, *v1.GetTransparentWalletAddressesRequest) (*v1.GetTransparentWalletAddressesResponse, error)
+	Shield(context.Context, *v1.ShieldRequest) (*v1.ShieldResponse, error)
+	Unshield(context.Context, *v1.UnshieldRequest) (*v1.UnshieldResponse, error)
+	ShieldedTransfer(context.Context, *v1.ShieldedTransferRequest) (*v1.ShieldedTransferResponse, error)
+	TransparentTransfer(context.Context, *v1.TransparentTransferRequest) (*v1.TransparentTransferResponse, error)
+}
+
+// NewZSideServiceClient constructs a client for the zside.v1.ZSideService service. Multiple service
+// clients may share a single connect.Client.
+func NewZSideServiceClient(client *connect.Client) ZSideServiceClient {
+	return &zSideServiceClient{client: client}
 }
 
-// GetBalance calls zside.v1.ZSideService.GetBalance.
-func (c *zSideServiceClient) GetBalance(ctx context.Context, req *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return c.getBalance.CallUnary(ctx, req)
+// ZSideServiceHandler is an implementation of the zside.v1.ZSideService service.
+type ZSideServiceHandler interface {
+	GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error)
+	GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error)
+	Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error)
+	Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error)
+	Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error)
+	GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error)
+	CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error)
+	GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error)
+	ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error)
+	ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error)
+	Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error)
+	GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error)
+	GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error)
+	GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error)
+	GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error)
+	GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error)
+	ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error)
+	RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error)
+	GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error)
+	GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error)
+	SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error)
+	CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error)
+	GetNewShieldedAddress(context.Context, *v1.GetNewShieldedAddressRequest) (*v1.GetNewShieldedAddressResponse, error)
+	GetNewTransparentAddress(context.Context, *v1.GetNewTransparentAddressRequest) (*v1.GetNewTransparentAddressResponse, error)
+	GetShieldedWalletAddresses(context.Context, *v1.GetShieldedWalletAddressesRequest) (*v1.GetShieldedWalletAddressesResponse, error)
+	GetTransparentWalletAddresses(context.Context, *v1.GetTransparentWalletAddressesRequest) (*v1.GetTransparentWalletAddressesResponse, error)
+	Shield(context.Context, *v1.ShieldRequest) (*v1.ShieldResponse, error)
+	Unshield(context.Context, *v1.UnshieldRequest) (*v1.UnshieldResponse, error)
+	ShieldedTransfer(context.Context, *v1.ShieldedTransferRequest) (*v1.ShieldedTransferResponse, error)
+	TransparentTransfer(context.Context, *v1.TransparentTransferRequest) (*v1.TransparentTransferResponse, error)
+}
+
+// RegisterZSideServiceHandler registers svc as the zside.v1.ZSideService implementation on server.
+func RegisterZSideServiceHandler(server *connect.Server, svc ZSideServiceHandler) {
+	adapter := zSideServiceHandler{svc: svc}
+	server.Register(
+		connect.Method{Spec: zSideServiceGetBalanceSpec(), Handler: adapter.getBalance},
+		connect.Method{Spec: zSideServiceGetBlockCountSpec(), Handler: adapter.getBlockCount},
+		connect.Method{Spec: zSideServiceStopSpec(), Handler: adapter.stop},
+		connect.Method{Spec: zSideServiceWithdrawSpec(), Handler: adapter.withdraw},
+		connect.Method{Spec: zSideServiceTransferSpec(), Handler: adapter.transfer},
+		connect.Method{Spec: zSideServiceGetSidechainWealthSpec(), Handler: adapter.getSidechainWealth},
+		connect.Method{Spec: zSideServiceCreateDepositSpec(), Handler: adapter.createDeposit},
+		connect.Method{Spec: zSideServiceGetPendingWithdrawalBundleSpec(), Handler: adapter.getPendingWithdrawalBundle},
+		connect.Method{Spec: zSideServiceConnectPeerSpec(), Handler: adapter.connectPeer},
+		connect.Method{Spec: zSideServiceListPeersSpec(), Handler: adapter.listPeers},
+		connect.Method{Spec: zSideServiceMineSpec(), Handler: adapter.mine},
+		connect.Method{Spec: zSideServiceGetBlockSpec(), Handler: adapter.getBlock},
+		connect.Method{Spec: zSideServiceGetBestMainchainBlockHashSpec(), Handler: adapter.getBestMainchainBlockHash},
+		connect.Method{Spec: zSideServiceGetBestSidechainBlockHashSpec(), Handler: adapter.getBestSidechainBlockHash},
+		connect.Method{Spec: zSideServiceGetBmmInclusionsSpec(), Handler: adapter.getBmmInclusions},
+		connect.Method{Spec: zSideServiceGetWalletUtxosSpec(), Handler: adapter.getWalletUtxos},
+		connect.Method{Spec: zSideServiceListUtxosSpec(), Handler: adapter.listUtxos},
+		connect.Method{Spec: zSideServiceRemoveFromMempoolSpec(), Handler: adapter.removeFromMempool},
+		connect.Method{Spec: zSideServiceGetLatestFailedWithdrawalBundleHeightSpec(), Handler: adapter.getLatestFailedWithdrawalBundleHeight},
+		connect.Method{Spec: zSideServiceGenerateMnemonicSpec(), Handler: adapter.generateMnemonic},
+		connect.Method{Spec: zSideServiceSetSeedFromMnemonicSpec(), Handler: adapter.setSeedFromMnemonic},
+		connect.Method{Spec: zSideServiceCallRawSpec(), Handler: adapter.callRaw},
+		connect.Method{Spec: zSideServiceGetNewShieldedAddressSpec(), Handler: adapter.getNewShieldedAddress},
+		connect.Method{Spec: zSideServiceGetNewTransparentAddressSpec(), Handler: adapter.getNewTransparentAddress},
+		connect.Method{Spec: zSideServiceGetShieldedWalletAddressesSpec(), Handler: adapter.getShieldedWalletAddresses},
+		connect.Method{Spec: zSideServiceGetTransparentWalletAddressesSpec(), Handler: adapter.getTransparentWalletAddresses},
+		connect.Method{Spec: zSideServiceShieldSpec(), Handler: adapter.shield},
+		connect.Method{Spec: zSideServiceUnshieldSpec(), Handler: adapter.unshield},
+		connect.Method{Spec: zSideServiceShieldedTransferSpec(), Handler: adapter.shieldedTransfer},
+		connect.Method{Spec: zSideServiceTransparentTransferSpec(), Handler: adapter.transparentTransfer},
+	)
 }
 
-// GetBlockCount calls zside.v1.ZSideService.GetBlockCount.
-func (c *zSideServiceClient) GetBlockCount(ctx context.Context, req *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return c.getBlockCount.CallUnary(ctx, req)
+// UnimplementedZSideServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedZSideServiceHandler struct{}
+
+func (UnimplementedZSideServiceHandler) GetBalance(context.Context, *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetBalance is not implemented")
 }
 
-// Stop calls zside.v1.ZSideService.Stop.
-func (c *zSideServiceClient) Stop(ctx context.Context, req *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return c.stop.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetBlockCount(context.Context, *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetBlockCount is not implemented")
 }
 
-// Withdraw calls zside.v1.ZSideService.Withdraw.
-func (c *zSideServiceClient) Withdraw(ctx context.Context, req *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return c.withdraw.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) Stop(context.Context, *v1.StopRequest) (*v1.StopResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.Stop is not implemented")
 }
 
-// Transfer calls zside.v1.ZSideService.Transfer.
-func (c *zSideServiceClient) Transfer(ctx context.Context, req *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return c.transfer.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) Withdraw(context.Context, *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.Withdraw is not implemented")
 }
 
-// GetSidechainWealth calls zside.v1.ZSideService.GetSidechainWealth.
-func (c *zSideServiceClient) GetSidechainWealth(ctx context.Context, req *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return c.getSidechainWealth.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) Transfer(context.Context, *v1.TransferRequest) (*v1.TransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.Transfer is not implemented")
 }
 
-// CreateDeposit calls zside.v1.ZSideService.CreateDeposit.
-func (c *zSideServiceClient) CreateDeposit(ctx context.Context, req *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return c.createDeposit.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetSidechainWealth(context.Context, *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetSidechainWealth is not implemented")
 }
 
-// GetPendingWithdrawalBundle calls zside.v1.ZSideService.GetPendingWithdrawalBundle.
-func (c *zSideServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return c.getPendingWithdrawalBundle.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) CreateDeposit(context.Context, *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.CreateDeposit is not implemented")
 }
 
-// ConnectPeer calls zside.v1.ZSideService.ConnectPeer.
-func (c *zSideServiceClient) ConnectPeer(ctx context.Context, req *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return c.connectPeer.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetPendingWithdrawalBundle(context.Context, *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetPendingWithdrawalBundle is not implemented")
 }
 
-// ListPeers calls zside.v1.ZSideService.ListPeers.
-func (c *zSideServiceClient) ListPeers(ctx context.Context, req *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return c.listPeers.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) ConnectPeer(context.Context, *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.ConnectPeer is not implemented")
 }
 
-// Mine calls zside.v1.ZSideService.Mine.
-func (c *zSideServiceClient) Mine(ctx context.Context, req *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return c.mine.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) ListPeers(context.Context, *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.ListPeers is not implemented")
 }
 
-// GetBlock calls zside.v1.ZSideService.GetBlock.
-func (c *zSideServiceClient) GetBlock(ctx context.Context, req *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return c.getBlock.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) Mine(context.Context, *v1.MineRequest) (*v1.MineResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.Mine is not implemented")
 }
 
-// GetBestMainchainBlockHash calls zside.v1.ZSideService.GetBestMainchainBlockHash.
-func (c *zSideServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return c.getBestMainchainBlockHash.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetBlock(context.Context, *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetBlock is not implemented")
 }
 
-// GetBestSidechainBlockHash calls zside.v1.ZSideService.GetBestSidechainBlockHash.
-func (c *zSideServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return c.getBestSidechainBlockHash.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetBestMainchainBlockHash(context.Context, *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetBestMainchainBlockHash is not implemented")
 }
 
-// GetBmmInclusions calls zside.v1.ZSideService.GetBmmInclusions.
-func (c *zSideServiceClient) GetBmmInclusions(ctx context.Context, req *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return c.getBmmInclusions.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetBestSidechainBlockHash(context.Context, *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetBestSidechainBlockHash is not implemented")
 }
 
-// GetWalletUtxos calls zside.v1.ZSideService.GetWalletUtxos.
-func (c *zSideServiceClient) GetWalletUtxos(ctx context.Context, req *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return c.getWalletUtxos.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetBmmInclusions(context.Context, *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetBmmInclusions is not implemented")
 }
 
-// ListUtxos calls zside.v1.ZSideService.ListUtxos.
-func (c *zSideServiceClient) ListUtxos(ctx context.Context, req *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return c.listUtxos.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetWalletUtxos(context.Context, *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetWalletUtxos is not implemented")
 }
 
-// RemoveFromMempool calls zside.v1.ZSideService.RemoveFromMempool.
-func (c *zSideServiceClient) RemoveFromMempool(ctx context.Context, req *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return c.removeFromMempool.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) ListUtxos(context.Context, *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.ListUtxos is not implemented")
 }
 
-// GetLatestFailedWithdrawalBundleHeight calls
-// zside.v1.ZSideService.GetLatestFailedWithdrawalBundleHeight.
-func (c *zSideServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return c.getLatestFailedWithdrawalBundleHeight.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) RemoveFromMempool(context.Context, *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.RemoveFromMempool is not implemented")
 }
 
-// GenerateMnemonic calls zside.v1.ZSideService.GenerateMnemonic.
-func (c *zSideServiceClient) GenerateMnemonic(ctx context.Context, req *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return c.generateMnemonic.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetLatestFailedWithdrawalBundleHeight is not implemented")
 }
 
-// SetSeedFromMnemonic calls zside.v1.ZSideService.SetSeedFromMnemonic.
-func (c *zSideServiceClient) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return c.setSeedFromMnemonic.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GenerateMnemonic(context.Context, *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GenerateMnemonic is not implemented")
 }
 
-// CallRaw calls zside.v1.ZSideService.CallRaw.
-func (c *zSideServiceClient) CallRaw(ctx context.Context, req *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return c.callRaw.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) SetSeedFromMnemonic(context.Context, *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.SetSeedFromMnemonic is not implemented")
 }
 
-// GetNewShieldedAddress calls zside.v1.ZSideService.GetNewShieldedAddress.
-func (c *zSideServiceClient) GetNewShieldedAddress(ctx context.Context, req *connect.Request[v1.GetNewShieldedAddressRequest]) (*connect.Response[v1.GetNewShieldedAddressResponse], error) {
-	return c.getNewShieldedAddress.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) CallRaw(context.Context, *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.CallRaw is not implemented")
 }
 
-// GetNewTransparentAddress calls zside.v1.ZSideService.GetNewTransparentAddress.
-func (c *zSideServiceClient) GetNewTransparentAddress(ctx context.Context, req *connect.Request[v1.GetNewTransparentAddressRequest]) (*connect.Response[v1.GetNewTransparentAddressResponse], error) {
-	return c.getNewTransparentAddress.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetNewShieldedAddress(context.Context, *v1.GetNewShieldedAddressRequest) (*v1.GetNewShieldedAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetNewShieldedAddress is not implemented")
 }
 
-// GetShieldedWalletAddresses calls zside.v1.ZSideService.GetShieldedWalletAddresses.
-func (c *zSideServiceClient) GetShieldedWalletAddresses(ctx context.Context, req *connect.Request[v1.GetShieldedWalletAddressesRequest]) (*connect.Response[v1.GetShieldedWalletAddressesResponse], error) {
-	return c.getShieldedWalletAddresses.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetNewTransparentAddress(context.Context, *v1.GetNewTransparentAddressRequest) (*v1.GetNewTransparentAddressResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetNewTransparentAddress is not implemented")
 }
 
-// GetTransparentWalletAddresses calls zside.v1.ZSideService.GetTransparentWalletAddresses.
-func (c *zSideServiceClient) GetTransparentWalletAddresses(ctx context.Context, req *connect.Request[v1.GetTransparentWalletAddressesRequest]) (*connect.Response[v1.GetTransparentWalletAddressesResponse], error) {
-	return c.getTransparentWalletAddresses.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetShieldedWalletAddresses(context.Context, *v1.GetShieldedWalletAddressesRequest) (*v1.GetShieldedWalletAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetShieldedWalletAddresses is not implemented")
 }
 
-// Shield calls zside.v1.ZSideService.Shield.
-func (c *zSideServiceClient) Shield(ctx context.Context, req *connect.Request[v1.ShieldRequest]) (*connect.Response[v1.ShieldResponse], error) {
-	return c.shield.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) GetTransparentWalletAddresses(context.Context, *v1.GetTransparentWalletAddressesRequest) (*v1.GetTransparentWalletAddressesResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.GetTransparentWalletAddresses is not implemented")
 }
 
-// Unshield calls zside.v1.ZSideService.Unshield.
-func (c *zSideServiceClient) Unshield(ctx context.Context, req *connect.Request[v1.UnshieldRequest]) (*connect.Response[v1.UnshieldResponse], error) {
-	return c.unshield.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) Shield(context.Context, *v1.ShieldRequest) (*v1.ShieldResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.Shield is not implemented")
 }
 
-// ShieldedTransfer calls zside.v1.ZSideService.ShieldedTransfer.
-func (c *zSideServiceClient) ShieldedTransfer(ctx context.Context, req *connect.Request[v1.ShieldedTransferRequest]) (*connect.Response[v1.ShieldedTransferResponse], error) {
-	return c.shieldedTransfer.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) Unshield(context.Context, *v1.UnshieldRequest) (*v1.UnshieldResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.Unshield is not implemented")
 }
 
-// TransparentTransfer calls zside.v1.ZSideService.TransparentTransfer.
-func (c *zSideServiceClient) TransparentTransfer(ctx context.Context, req *connect.Request[v1.TransparentTransferRequest]) (*connect.Response[v1.TransparentTransferResponse], error) {
-	return c.transparentTransfer.CallUnary(ctx, req)
+func (UnimplementedZSideServiceHandler) ShieldedTransfer(context.Context, *v1.ShieldedTransferRequest) (*v1.ShieldedTransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.ShieldedTransfer is not implemented")
 }
 
-// ZSideServiceHandler is an implementation of the zside.v1.ZSideService service.
-type ZSideServiceHandler interface {
-	// Get wallet balance (total and available, both transparent and shielded).
-	GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error)
-	// Get current block count.
-	GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error)
-	// Stop the zside node.
-	Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error)
-	// Withdraw to mainchain.
-	Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error)
-	// Transfer within sidechain (transparent).
-	Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error)
-	// Get total sidechain wealth in sats.
-	GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error)
-	// Create a deposit transaction.
-	CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error)
-	// Get pending withdrawal bundle.
-	GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error)
-	// Connect to a peer.
-	ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error)
-	// List connected peers.
-	ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error)
-	// Mine a block.
-	Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error)
-	// Get block by hash.
-	GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error)
-	// Get best mainchain block hash.
-	GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error)
-	// Get best sidechain block hash.
-	GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error)
-	// Get BMM inclusions for a block.
-	GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error)
-	// Get wallet UTXOs.
-	GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error)
-	// List all UTXOs.
-	ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error)
-	// Remove transaction from mempool.
-	RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error)
-	// Get latest failed withdrawal bundle height.
-	GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error)
-	// Generate a new mnemonic.
-	GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error)
-	// Set seed from mnemonic.
-	SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error)
-	// Raw JSON-RPC passthrough for debug console.
-	CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error)
-	// Get a new shielded address.
-	GetNewShieldedAddress(context.Context, *connect.Request[v1.GetNewShieldedAddressRequest]) (*connect.Response[v1.GetNewShieldedAddressResponse], error)
-	// Get a new transparent address.
-	GetNewTransparentAddress(context.Context, *connect.Request[v1.GetNewTransparentAddressRequest]) (*connect.Response[v1.GetNewTransparentAddressResponse], error)
-	// Get shielded wallet addresses.
-	GetShieldedWalletAddresses(context.Context, *connect.Request[v1.GetShieldedWalletAddressesRequest]) (*connect.Response[v1.GetShieldedWalletAddressesResponse], error)
-	// Get transparent wallet addresses.
-	GetTransparentWalletAddresses(context.Context, *connect.Request[v1.GetTransparentWalletAddressesRequest]) (*connect.Response[v1.GetTransparentWalletAddressesResponse], error)
-	// Shield transparent funds to shielded pool.
-	Shield(context.Context, *connect.Request[v1.ShieldRequest]) (*connect.Response[v1.ShieldResponse], error)
-	// Unshield (deshield) shielded funds to transparent pool.
-	Unshield(context.Context, *connect.Request[v1.UnshieldRequest]) (*connect.Response[v1.UnshieldResponse], error)
-	// Send a shielded transfer.
-	ShieldedTransfer(context.Context, *connect.Request[v1.ShieldedTransferRequest]) (*connect.Response[v1.ShieldedTransferResponse], error)
-	// Send a transparent transfer.
-	TransparentTransfer(context.Context, *connect.Request[v1.TransparentTransferRequest]) (*connect.Response[v1.TransparentTransferResponse], error)
-}
-
-// NewZSideServiceHandler builds an HTTP handler from the service implementation. It returns the
-// path on which to mount the handler and the handler itself.
-//
-// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
-// and JSON codecs. They also support gzip compression.
-func NewZSideServiceHandler(svc ZSideServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
-	zSideServiceMethods := v1.File_zside_v1_zside_proto.Services().ByName("ZSideService").Methods()
-	zSideServiceGetBalanceHandler := connect.NewUnaryHandler(
-		ZSideServiceGetBalanceProcedure,
-		svc.GetBalance,
-		connect.WithSchema(zSideServiceMethods.ByName("GetBalance")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetBlockCountHandler := connect.NewUnaryHandler(
-		ZSideServiceGetBlockCountProcedure,
-		svc.GetBlockCount,
-		connect.WithSchema(zSideServiceMethods.ByName("GetBlockCount")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceStopHandler := connect.NewUnaryHandler(
-		ZSideServiceStopProcedure,
-		svc.Stop,
-		connect.WithSchema(zSideServiceMethods.ByName("Stop")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceWithdrawHandler := connect.NewUnaryHandler(
-		ZSideServiceWithdrawProcedure,
-		svc.Withdraw,
-		connect.WithSchema(zSideServiceMethods.ByName("Withdraw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceTransferHandler := connect.NewUnaryHandler(
-		ZSideServiceTransferProcedure,
-		svc.Transfer,
-		connect.WithSchema(zSideServiceMethods.ByName("Transfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetSidechainWealthHandler := connect.NewUnaryHandler(
-		ZSideServiceGetSidechainWealthProcedure,
-		svc.GetSidechainWealth,
-		connect.WithSchema(zSideServiceMethods.ByName("GetSidechainWealth")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceCreateDepositHandler := connect.NewUnaryHandler(
-		ZSideServiceCreateDepositProcedure,
-		svc.CreateDeposit,
-		connect.WithSchema(zSideServiceMethods.ByName("CreateDeposit")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetPendingWithdrawalBundleHandler := connect.NewUnaryHandler(
-		ZSideServiceGetPendingWithdrawalBundleProcedure,
-		svc.GetPendingWithdrawalBundle,
-		connect.WithSchema(zSideServiceMethods.ByName("GetPendingWithdrawalBundle")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceConnectPeerHandler := connect.NewUnaryHandler(
-		ZSideServiceConnectPeerProcedure,
-		svc.ConnectPeer,
-		connect.WithSchema(zSideServiceMethods.ByName("ConnectPeer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceListPeersHandler := connect.NewUnaryHandler(
-		ZSideServiceListPeersProcedure,
-		svc.ListPeers,
-		connect.WithSchema(zSideServiceMethods.ByName("ListPeers")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceMineHandler := connect.NewUnaryHandler(
-		ZSideServiceMineProcedure,
-		svc.Mine,
-		connect.WithSchema(zSideServiceMethods.ByName("Mine")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetBlockHandler := connect.NewUnaryHandler(
-		ZSideServiceGetBlockProcedure,
-		svc.GetBlock,
-		connect.WithSchema(zSideServiceMethods.ByName("GetBlock")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetBestMainchainBlockHashHandler := connect.NewUnaryHandler(
-		ZSideServiceGetBestMainchainBlockHashProcedure,
-		svc.GetBestMainchainBlockHash,
-		connect.WithSchema(zSideServiceMethods.ByName("GetBestMainchainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetBestSidechainBlockHashHandler := connect.NewUnaryHandler(
-		ZSideServiceGetBestSidechainBlockHashProcedure,
-		svc.GetBestSidechainBlockHash,
-		connect.WithSchema(zSideServiceMethods.ByName("GetBestSidechainBlockHash")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetBmmInclusionsHandler := connect.NewUnaryHandler(
-		ZSideServiceGetBmmInclusionsProcedure,
-		svc.GetBmmInclusions,
-		connect.WithSchema(zSideServiceMethods.ByName("GetBmmInclusions")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetWalletUtxosHandler := connect.NewUnaryHandler(
-		ZSideServiceGetWalletUtxosProcedure,
-		svc.GetWalletUtxos,
-		connect.WithSchema(zSideServiceMethods.ByName("GetWalletUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceListUtxosHandler := connect.NewUnaryHandler(
-		ZSideServiceListUtxosProcedure,
-		svc.ListUtxos,
-		connect.WithSchema(zSideServiceMethods.ByName("ListUtxos")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceRemoveFromMempoolHandler := connect.NewUnaryHandler(
-		ZSideServiceRemoveFromMempoolProcedure,
-		svc.RemoveFromMempool,
-		connect.WithSchema(zSideServiceMethods.ByName("RemoveFromMempool")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetLatestFailedWithdrawalBundleHeightHandler := connect.NewUnaryHandler(
-		ZSideServiceGetLatestFailedWithdrawalBundleHeightProcedure,
-		svc.GetLatestFailedWithdrawalBundleHeight,
-		connect.WithSchema(zSideServiceMethods.ByName("GetLatestFailedWithdrawalBundleHeight")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGenerateMnemonicHandler := connect.NewUnaryHandler(
-		ZSideServiceGenerateMnemonicProcedure,
-		svc.GenerateMnemonic,
-		connect.WithSchema(zSideServiceMethods.ByName("GenerateMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceSetSeedFromMnemonicHandler := connect.NewUnaryHandler(
-		ZSideServiceSetSeedFromMnemonicProcedure,
-		svc.SetSeedFromMnemonic,
-		connect.WithSchema(zSideServiceMethods.ByName("SetSeedFromMnemonic")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceCallRawHandler := connect.NewUnaryHandler(
-		ZSideServiceCallRawProcedure,
-		svc.CallRaw,
-		connect.WithSchema(zSideServiceMethods.ByName("CallRaw")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetNewShieldedAddressHandler := connect.NewUnaryHandler(
-		ZSideServiceGetNewShieldedAddressProcedure,
-		svc.GetNewShieldedAddress,
-		connect.WithSchema(zSideServiceMethods.ByName("GetNewShieldedAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetNewTransparentAddressHandler := connect.NewUnaryHandler(
-		ZSideServiceGetNewTransparentAddressProcedure,
-		svc.GetNewTransparentAddress,
-		connect.WithSchema(zSideServiceMethods.ByName("GetNewTransparentAddress")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetShieldedWalletAddressesHandler := connect.NewUnaryHandler(
-		ZSideServiceGetShieldedWalletAddressesProcedure,
-		svc.GetShieldedWalletAddresses,
-		connect.WithSchema(zSideServiceMethods.ByName("GetShieldedWalletAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceGetTransparentWalletAddressesHandler := connect.NewUnaryHandler(
-		ZSideServiceGetTransparentWalletAddressesProcedure,
-		svc.GetTransparentWalletAddresses,
-		connect.WithSchema(zSideServiceMethods.ByName("GetTransparentWalletAddresses")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceShieldHandler := connect.NewUnaryHandler(
-		ZSideServiceShieldProcedure,
-		svc.Shield,
-		connect.WithSchema(zSideServiceMethods.ByName("Shield")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceUnshieldHandler := connect.NewUnaryHandler(
-		ZSideServiceUnshieldProcedure,
-		svc.Unshield,
-		connect.WithSchema(zSideServiceMethods.ByName("Unshield")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceShieldedTransferHandler := connect.NewUnaryHandler(
-		ZSideServiceShieldedTransferProcedure,
-		svc.ShieldedTransfer,
-		connect.WithSchema(zSideServiceMethods.ByName("ShieldedTransfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	zSideServiceTransparentTransferHandler := connect.NewUnaryHandler(
-		ZSideServiceTransparentTransferProcedure,
-		svc.TransparentTransfer,
-		connect.WithSchema(zSideServiceMethods.ByName("TransparentTransfer")),
-		connect.WithHandlerOptions(opts...),
-	)
-	return "/zside.v1.ZSideService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case ZSideServiceGetBalanceProcedure:
-			zSideServiceGetBalanceHandler.ServeHTTP(w, r)
-		case ZSideServiceGetBlockCountProcedure:
-			zSideServiceGetBlockCountHandler.ServeHTTP(w, r)
-		case ZSideServiceStopProcedure:
-			zSideServiceStopHandler.ServeHTTP(w, r)
-		case ZSideServiceWithdrawProcedure:
-			zSideServiceWithdrawHandler.ServeHTTP(w, r)
-		case ZSideServiceTransferProcedure:
-			zSideServiceTransferHandler.ServeHTTP(w, r)
-		case ZSideServiceGetSidechainWealthProcedure:
-			zSideServiceGetSidechainWealthHandler.ServeHTTP(w, r)
-		case ZSideServiceCreateDepositProcedure:
-			zSideServiceCreateDepositHandler.ServeHTTP(w, r)
-		case ZSideServiceGetPendingWithdrawalBundleProcedure:
-			zSideServiceGetPendingWithdrawalBundleHandler.ServeHTTP(w, r)
-		case ZSideServiceConnectPeerProcedure:
-			zSideServiceConnectPeerHandler.ServeHTTP(w, r)
-		case ZSideServiceListPeersProcedure:
-			zSideServiceListPeersHandler.ServeHTTP(w, r)
-		case ZSideServiceMineProcedure:
-			zSideServiceMineHandler.ServeHTTP(w, r)
-		case ZSideServiceGetBlockProcedure:
-			zSideServiceGetBlockHandler.ServeHTTP(w, r)
-		case ZSideServiceGetBestMainchainBlockHashProcedure:
-			zSideServiceGetBestMainchainBlockHashHandler.ServeHTTP(w, r)
-		case ZSideServiceGetBestSidechainBlockHashProcedure:
-			zSideServiceGetBestSidechainBlockHashHandler.ServeHTTP(w, r)
-		case ZSideServiceGetBmmInclusionsProcedure:
-			zSideServiceGetBmmInclusionsHandler.ServeHTTP(w, r)
-		case ZSideServiceGetWalletUtxosProcedure:
-			zSideServiceGetWalletUtxosHandler.ServeHTTP(w, r)
-		case ZSideServiceListUtxosProcedure:
-			zSideServiceListUtxosHandler.ServeHTTP(w, r)
-		case ZSideServiceRemoveFromMempoolProcedure:
-			zSideServiceRemoveFromMempoolHandler.ServeHTTP(w, r)
-		case ZSideServiceGetLatestFailedWithdrawalBundleHeightProcedure:
-			zSideServiceGetLatestFailedWithdrawalBundleHeightHandler.ServeHTTP(w, r)
-		case ZSideServiceGenerateMnemonicProcedure:
-			zSideServiceGenerateMnemonicHandler.ServeHTTP(w, r)
-		case ZSideServiceSetSeedFromMnemonicProcedure:
-			zSideServiceSetSeedFromMnemonicHandler.ServeHTTP(w, r)
-		case ZSideServiceCallRawProcedure:
-			zSideServiceCallRawHandler.ServeHTTP(w, r)
-		case ZSideServiceGetNewShieldedAddressProcedure:
-			zSideServiceGetNewShieldedAddressHandler.ServeHTTP(w, r)
-		case ZSideServiceGetNewTransparentAddressProcedure:
-			zSideServiceGetNewTransparentAddressHandler.ServeHTTP(w, r)
-		case ZSideServiceGetShieldedWalletAddressesProcedure:
-			zSideServiceGetShieldedWalletAddressesHandler.ServeHTTP(w, r)
-		case ZSideServiceGetTransparentWalletAddressesProcedure:
-			zSideServiceGetTransparentWalletAddressesHandler.ServeHTTP(w, r)
-		case ZSideServiceShieldProcedure:
-			zSideServiceShieldHandler.ServeHTTP(w, r)
-		case ZSideServiceUnshieldProcedure:
-			zSideServiceUnshieldHandler.ServeHTTP(w, r)
-		case ZSideServiceShieldedTransferProcedure:
-			zSideServiceShieldedTransferHandler.ServeHTTP(w, r)
-		case ZSideServiceTransparentTransferProcedure:
-			zSideServiceTransparentTransferHandler.ServeHTTP(w, r)
-		default:
-			http.NotFound(w, r)
-		}
-	})
+func (UnimplementedZSideServiceHandler) TransparentTransfer(context.Context, *v1.TransparentTransferRequest) (*v1.TransparentTransferResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "zside.v1.ZSideService.TransparentTransfer is not implemented")
 }
 
-// UnimplementedZSideServiceHandler returns CodeUnimplemented from all methods.
-type UnimplementedZSideServiceHandler struct{}
+type zSideServiceClient struct {
+	client *connect.Client
+}
 
-func (UnimplementedZSideServiceHandler) GetBalance(context.Context, *connect.Request[v1.GetBalanceRequest]) (*connect.Response[v1.GetBalanceResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetBalance is not implemented"))
+func (c *zSideServiceClient) GetBalance(ctx context.Context, req *v1.GetBalanceRequest) (*v1.GetBalanceResponse, error) {
+	var res v1.GetBalanceResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetBalanceSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetBlockCount(context.Context, *connect.Request[v1.GetBlockCountRequest]) (*connect.Response[v1.GetBlockCountResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetBlockCount is not implemented"))
+func (c *zSideServiceClient) GetBlockCount(ctx context.Context, req *v1.GetBlockCountRequest) (*v1.GetBlockCountResponse, error) {
+	var res v1.GetBlockCountResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetBlockCountSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) Stop(context.Context, *connect.Request[v1.StopRequest]) (*connect.Response[v1.StopResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.Stop is not implemented"))
+func (c *zSideServiceClient) Stop(ctx context.Context, req *v1.StopRequest) (*v1.StopResponse, error) {
+	var res v1.StopResponse
+	if err := c.client.CallUnary(ctx, zSideServiceStopSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) Withdraw(context.Context, *connect.Request[v1.WithdrawRequest]) (*connect.Response[v1.WithdrawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.Withdraw is not implemented"))
+func (c *zSideServiceClient) Withdraw(ctx context.Context, req *v1.WithdrawRequest) (*v1.WithdrawResponse, error) {
+	var res v1.WithdrawResponse
+	if err := c.client.CallUnary(ctx, zSideServiceWithdrawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) Transfer(context.Context, *connect.Request[v1.TransferRequest]) (*connect.Response[v1.TransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.Transfer is not implemented"))
+func (c *zSideServiceClient) Transfer(ctx context.Context, req *v1.TransferRequest) (*v1.TransferResponse, error) {
+	var res v1.TransferResponse
+	if err := c.client.CallUnary(ctx, zSideServiceTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetSidechainWealth(context.Context, *connect.Request[v1.GetSidechainWealthRequest]) (*connect.Response[v1.GetSidechainWealthResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetSidechainWealth is not implemented"))
+func (c *zSideServiceClient) GetSidechainWealth(ctx context.Context, req *v1.GetSidechainWealthRequest) (*v1.GetSidechainWealthResponse, error) {
+	var res v1.GetSidechainWealthResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetSidechainWealthSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) CreateDeposit(context.Context, *connect.Request[v1.CreateDepositRequest]) (*connect.Response[v1.CreateDepositResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.CreateDeposit is not implemented"))
+func (c *zSideServiceClient) CreateDeposit(ctx context.Context, req *v1.CreateDepositRequest) (*v1.CreateDepositResponse, error) {
+	var res v1.CreateDepositResponse
+	if err := c.client.CallUnary(ctx, zSideServiceCreateDepositSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetPendingWithdrawalBundle(context.Context, *connect.Request[v1.GetPendingWithdrawalBundleRequest]) (*connect.Response[v1.GetPendingWithdrawalBundleResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetPendingWithdrawalBundle is not implemented"))
+func (c *zSideServiceClient) GetPendingWithdrawalBundle(ctx context.Context, req *v1.GetPendingWithdrawalBundleRequest) (*v1.GetPendingWithdrawalBundleResponse, error) {
+	var res v1.GetPendingWithdrawalBundleResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetPendingWithdrawalBundleSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) ConnectPeer(context.Context, *connect.Request[v1.ConnectPeerRequest]) (*connect.Response[v1.ConnectPeerResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.ConnectPeer is not implemented"))
+func (c *zSideServiceClient) ConnectPeer(ctx context.Context, req *v1.ConnectPeerRequest) (*v1.ConnectPeerResponse, error) {
+	var res v1.ConnectPeerResponse
+	if err := c.client.CallUnary(ctx, zSideServiceConnectPeerSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) ListPeers(context.Context, *connect.Request[v1.ListPeersRequest]) (*connect.Response[v1.ListPeersResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.ListPeers is not implemented"))
+func (c *zSideServiceClient) ListPeers(ctx context.Context, req *v1.ListPeersRequest) (*v1.ListPeersResponse, error) {
+	var res v1.ListPeersResponse
+	if err := c.client.CallUnary(ctx, zSideServiceListPeersSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) Mine(context.Context, *connect.Request[v1.MineRequest]) (*connect.Response[v1.MineResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.Mine is not implemented"))
+func (c *zSideServiceClient) Mine(ctx context.Context, req *v1.MineRequest) (*v1.MineResponse, error) {
+	var res v1.MineResponse
+	if err := c.client.CallUnary(ctx, zSideServiceMineSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetBlock(context.Context, *connect.Request[v1.GetBlockRequest]) (*connect.Response[v1.GetBlockResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetBlock is not implemented"))
+func (c *zSideServiceClient) GetBlock(ctx context.Context, req *v1.GetBlockRequest) (*v1.GetBlockResponse, error) {
+	var res v1.GetBlockResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetBlockSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetBestMainchainBlockHash(context.Context, *connect.Request[v1.GetBestMainchainBlockHashRequest]) (*connect.Response[v1.GetBestMainchainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetBestMainchainBlockHash is not implemented"))
+func (c *zSideServiceClient) GetBestMainchainBlockHash(ctx context.Context, req *v1.GetBestMainchainBlockHashRequest) (*v1.GetBestMainchainBlockHashResponse, error) {
+	var res v1.GetBestMainchainBlockHashResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetBestMainchainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetBestSidechainBlockHash(context.Context, *connect.Request[v1.GetBestSidechainBlockHashRequest]) (*connect.Response[v1.GetBestSidechainBlockHashResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetBestSidechainBlockHash is not implemented"))
+func (c *zSideServiceClient) GetBestSidechainBlockHash(ctx context.Context, req *v1.GetBestSidechainBlockHashRequest) (*v1.GetBestSidechainBlockHashResponse, error) {
+	var res v1.GetBestSidechainBlockHashResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetBestSidechainBlockHashSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetBmmInclusions(context.Context, *connect.Request[v1.GetBmmInclusionsRequest]) (*connect.Response[v1.GetBmmInclusionsResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetBmmInclusions is not implemented"))
+func (c *zSideServiceClient) GetBmmInclusions(ctx context.Context, req *v1.GetBmmInclusionsRequest) (*v1.GetBmmInclusionsResponse, error) {
+	var res v1.GetBmmInclusionsResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetBmmInclusionsSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetWalletUtxos(context.Context, *connect.Request[v1.GetWalletUtxosRequest]) (*connect.Response[v1.GetWalletUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetWalletUtxos is not implemented"))
+func (c *zSideServiceClient) GetWalletUtxos(ctx context.Context, req *v1.GetWalletUtxosRequest) (*v1.GetWalletUtxosResponse, error) {
+	var res v1.GetWalletUtxosResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetWalletUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) ListUtxos(context.Context, *connect.Request[v1.ListUtxosRequest]) (*connect.Response[v1.ListUtxosResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.ListUtxos is not implemented"))
+func (c *zSideServiceClient) ListUtxos(ctx context.Context, req *v1.ListUtxosRequest) (*v1.ListUtxosResponse, error) {
+	var res v1.ListUtxosResponse
+	if err := c.client.CallUnary(ctx, zSideServiceListUtxosSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) RemoveFromMempool(context.Context, *connect.Request[v1.RemoveFromMempoolRequest]) (*connect.Response[v1.RemoveFromMempoolResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.RemoveFromMempool is not implemented"))
+func (c *zSideServiceClient) RemoveFromMempool(ctx context.Context, req *v1.RemoveFromMempoolRequest) (*v1.RemoveFromMempoolResponse, error) {
+	var res v1.RemoveFromMempoolResponse
+	if err := c.client.CallUnary(ctx, zSideServiceRemoveFromMempoolSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GetLatestFailedWithdrawalBundleHeight(context.Context, *connect.Request[v1.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[v1.GetLatestFailedWithdrawalBundleHeightResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetLatestFailedWithdrawalBundleHeight is not implemented"))
+func (c *zSideServiceClient) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *v1.GetLatestFailedWithdrawalBundleHeightRequest) (*v1.GetLatestFailedWithdrawalBundleHeightResponse, error) {
+	var res v1.GetLatestFailedWithdrawalBundleHeightResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetLatestFailedWithdrawalBundleHeightSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) GenerateMnemonic(context.Context, *connect.Request[v1.GenerateMnemonicRequest]) (*connect.Response[v1.GenerateMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GenerateMnemonic is not implemented"))
+func (c *zSideServiceClient) GenerateMnemonic(ctx context.Context, req *v1.GenerateMnemonicRequest) (*v1.GenerateMnemonicResponse, error) {
+	var res v1.GenerateMnemonicResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGenerateMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
 }
 
-func (UnimplementedZSideServiceHandler) SetSeedFromMnemonic(context.Context, *connect.Request[v1.SetSeedFromMnemonicRequest]) (*connect.Response[v1.SetSeedFromMnemonicResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.SetSeedFromMnemonic is not implemented"))
+func (c *zSideServiceClient) SetSeedFromMnemonic(ctx context.Context, req *v1.SetSeedFromMnemonicRequest) (*v1.SetSeedFromMnemonicResponse, error) {
+	var res v1.SetSeedFromMnemonicResponse
+	if err := c.client.CallUnary(ctx, zSideServiceSetSeedFromMnemonicSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) CallRaw(ctx context.Context, req *v1.CallRawRequest) (*v1.CallRawResponse, error) {
+	var res v1.CallRawResponse
+	if err := c.client.CallUnary(ctx, zSideServiceCallRawSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) GetNewShieldedAddress(ctx context.Context, req *v1.GetNewShieldedAddressRequest) (*v1.GetNewShieldedAddressResponse, error) {
+	var res v1.GetNewShieldedAddressResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetNewShieldedAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) GetNewTransparentAddress(ctx context.Context, req *v1.GetNewTransparentAddressRequest) (*v1.GetNewTransparentAddressResponse, error) {
+	var res v1.GetNewTransparentAddressResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetNewTransparentAddressSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) GetShieldedWalletAddresses(ctx context.Context, req *v1.GetShieldedWalletAddressesRequest) (*v1.GetShieldedWalletAddressesResponse, error) {
+	var res v1.GetShieldedWalletAddressesResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetShieldedWalletAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) GetTransparentWalletAddresses(ctx context.Context, req *v1.GetTransparentWalletAddressesRequest) (*v1.GetTransparentWalletAddressesResponse, error) {
+	var res v1.GetTransparentWalletAddressesResponse
+	if err := c.client.CallUnary(ctx, zSideServiceGetTransparentWalletAddressesSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) Shield(ctx context.Context, req *v1.ShieldRequest) (*v1.ShieldResponse, error) {
+	var res v1.ShieldResponse
+	if err := c.client.CallUnary(ctx, zSideServiceShieldSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) Unshield(ctx context.Context, req *v1.UnshieldRequest) (*v1.UnshieldResponse, error) {
+	var res v1.UnshieldResponse
+	if err := c.client.CallUnary(ctx, zSideServiceUnshieldSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) ShieldedTransfer(ctx context.Context, req *v1.ShieldedTransferRequest) (*v1.ShieldedTransferResponse, error) {
+	var res v1.ShieldedTransferResponse
+	if err := c.client.CallUnary(ctx, zSideServiceShieldedTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+func (c *zSideServiceClient) TransparentTransfer(ctx context.Context, req *v1.TransparentTransferRequest) (*v1.TransparentTransferResponse, error) {
+	var res v1.TransparentTransferResponse
+	if err := c.client.CallUnary(ctx, zSideServiceTransparentTransferSpec(), req, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}
+
+type zSideServiceHandler struct{ svc ZSideServiceHandler }
+
+func (h zSideServiceHandler) getBalance(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBalanceRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBalance(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) CallRaw(context.Context, *connect.Request[v1.CallRawRequest]) (*connect.Response[v1.CallRawResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.CallRaw is not implemented"))
+func (h zSideServiceHandler) getBlockCount(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockCountRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlockCount(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) GetNewShieldedAddress(context.Context, *connect.Request[v1.GetNewShieldedAddressRequest]) (*connect.Response[v1.GetNewShieldedAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetNewShieldedAddress is not implemented"))
+func (h zSideServiceHandler) stop(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.StopRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Stop(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) GetNewTransparentAddress(context.Context, *connect.Request[v1.GetNewTransparentAddressRequest]) (*connect.Response[v1.GetNewTransparentAddressResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetNewTransparentAddress is not implemented"))
+func (h zSideServiceHandler) withdraw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.WithdrawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Withdraw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) GetShieldedWalletAddresses(context.Context, *connect.Request[v1.GetShieldedWalletAddressesRequest]) (*connect.Response[v1.GetShieldedWalletAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetShieldedWalletAddresses is not implemented"))
+func (h zSideServiceHandler) transfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Transfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) GetTransparentWalletAddresses(context.Context, *connect.Request[v1.GetTransparentWalletAddressesRequest]) (*connect.Response[v1.GetTransparentWalletAddressesResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.GetTransparentWalletAddresses is not implemented"))
+func (h zSideServiceHandler) getSidechainWealth(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetSidechainWealthRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetSidechainWealth(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) Shield(context.Context, *connect.Request[v1.ShieldRequest]) (*connect.Response[v1.ShieldResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.Shield is not implemented"))
+func (h zSideServiceHandler) createDeposit(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CreateDepositRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CreateDeposit(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) Unshield(context.Context, *connect.Request[v1.UnshieldRequest]) (*connect.Response[v1.UnshieldResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.Unshield is not implemented"))
+func (h zSideServiceHandler) getPendingWithdrawalBundle(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetPendingWithdrawalBundleRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetPendingWithdrawalBundle(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) ShieldedTransfer(context.Context, *connect.Request[v1.ShieldedTransferRequest]) (*connect.Response[v1.ShieldedTransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.ShieldedTransfer is not implemented"))
+func (h zSideServiceHandler) connectPeer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ConnectPeerRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ConnectPeer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
 
-func (UnimplementedZSideServiceHandler) TransparentTransfer(context.Context, *connect.Request[v1.TransparentTransferRequest]) (*connect.Response[v1.TransparentTransferResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("zside.v1.ZSideService.TransparentTransfer is not implemented"))
+func (h zSideServiceHandler) listPeers(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListPeersRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListPeers(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) mine(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.MineRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Mine(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getBlock(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBlockRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBlock(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getBestMainchainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestMainchainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestMainchainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getBestSidechainBlockHash(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBestSidechainBlockHashRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBestSidechainBlockHash(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getBmmInclusions(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetBmmInclusionsRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetBmmInclusions(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getWalletUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetWalletUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetWalletUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) listUtxos(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ListUtxosRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ListUtxos(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) removeFromMempool(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.RemoveFromMempoolRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.RemoveFromMempool(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getLatestFailedWithdrawalBundleHeight(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetLatestFailedWithdrawalBundleHeightRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetLatestFailedWithdrawalBundleHeight(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) generateMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GenerateMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GenerateMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) setSeedFromMnemonic(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.SetSeedFromMnemonicRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.SetSeedFromMnemonic(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) callRaw(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.CallRawRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.CallRaw(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getNewShieldedAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewShieldedAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewShieldedAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getNewTransparentAddress(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetNewTransparentAddressRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetNewTransparentAddress(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getShieldedWalletAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetShieldedWalletAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetShieldedWalletAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) getTransparentWalletAddresses(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.GetTransparentWalletAddressesRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.GetTransparentWalletAddresses(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) shield(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ShieldRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Shield(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) unshield(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.UnshieldRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.Unshield(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) shieldedTransfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.ShieldedTransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.ShieldedTransfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
+}
+
+func (h zSideServiceHandler) transparentTransfer(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+	var req v1.TransparentTransferRequest
+	if err := stream.Receive(&req); err != nil {
+		return err
+	}
+	res, err := h.svc.TransparentTransfer(ctx, &req)
+	if err != nil {
+		return err
+	}
+	return stream.Send(res)
 }
diff --git a/sidechain-orchestrator/go.mod b/sidechain-orchestrator/go.mod
index 9b66dba5b3..4da5f55524 100644
--- a/sidechain-orchestrator/go.mod
+++ b/sidechain-orchestrator/go.mod
@@ -6,7 +6,9 @@ require (
 	buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.12-20260825204119-511051f7f437.1
 	buf.build/go/protovalidate v1.4.0
 	connectrpc.com/connect v1.20.0
-	filippo.io/edwards25519 v1.1.1
+	connectrpc.com/connect/v2 v2.0.1
+	connectrpc.com/grpchealth v1.5.0
+	github.com/LayerTwo-Labs/sidesail/sqlitemigrate v0.0.0
 	github.com/barebitcoin/btc-buf v0.0.0-20260808142039-a2f409838633
 	github.com/btcsuite/btcd v0.25.0
 	github.com/btcsuite/btcd/btcec/v2 v2.5.0
@@ -16,7 +18,6 @@ require (
 	github.com/fsnotify/fsnotify v1.9.0
 	github.com/gowebpki/jcs v1.0.1
 	github.com/mattn/go-sqlite3 v1.14.45
-	github.com/mr-tron/base58 v1.3.0
 	github.com/rs/zerolog v1.35.1
 	github.com/samber/lo v1.53.0
 	github.com/stretchr/testify v1.12.1
@@ -25,6 +26,7 @@ require (
 	github.com/urfave/cli/v2 v2.27.7
 	golang.org/x/crypto v0.53.0
 	golang.org/x/net v0.55.0
+	golang.org/x/sys v0.46.0
 	golang.org/x/text v0.41.0
 	google.golang.org/protobuf v1.36.12
 	lukechampine.com/blake3 v1.4.1
@@ -33,43 +35,34 @@ require (
 require (
 	cel.dev/cel-go v0.32.0 // indirect
 	cel.dev/expr v0.25.3 // indirect
+	connectrpc.com/grpcreflect v1.3.0 // indirect
+	github.com/FactomProject/basen v0.0.0-20150613233007-fe3947df716e // indirect
+	github.com/FactomProject/btcutilecc v0.0.0-20130527213604-d3a63a5752ec // indirect
 	github.com/antlr4-go/antlr/v4 v4.13.1 // indirect
 	github.com/btcsuite/btcd/address/v2 v2.0.0 // indirect
 	github.com/btcsuite/btcd/btcutil/v2 v2.0.1 // indirect
 	github.com/btcsuite/btcd/chaincfg/v2 v2.0.0 // indirect
 	github.com/btcsuite/btcd/chainhash/v2 v2.0.0 // indirect
 	github.com/btcsuite/btcd/wire/v2 v2.0.1 // indirect
-	github.com/kcalvinalvin/anet v0.0.0-20251112173137-d8ddc1f6dbee // indirect
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
-	github.com/tidwall/gjson v1.19.0 // indirect
-	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/pretty v1.2.0 // indirect
-	go.yaml.in/yaml/v3 v3.0.5 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 // indirect
-)
-
-require (
-	connectrpc.com/grpchealth v1.5.0 // indirect
-	connectrpc.com/grpcreflect v1.3.0 // indirect
-	github.com/FactomProject/basen v0.0.0-20150613233007-fe3947df716e // indirect
-	github.com/FactomProject/btcutilecc v0.0.0-20130527213604-d3a63a5752ec // indirect
-	github.com/LayerTwo-Labs/sidesail/sqlitemigrate v0.0.0
 	github.com/btcsuite/btclog v1.0.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/decred/dcrd/crypto/blake256 v1.1.0 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect
 	github.com/gorilla/mux v1.8.1 // indirect
+	github.com/kcalvinalvin/anet v0.0.0-20251112173137-d8ddc1f6dbee // indirect
+	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/oklog/ulid/v2 v2.1.2 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/tidwall/gjson v1.19.0 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
+	go.yaml.in/yaml/v3 v3.0.5 // indirect
 	golang.org/x/exp v0.0.0-20260820142414-ca536658362e // indirect
-	golang.org/x/sys v0.46.0
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 // indirect
 )
 
 replace github.com/LayerTwo-Labs/sidesail/sqlitemigrate => ../sqlitemigrate
diff --git a/sidechain-orchestrator/go.sum b/sidechain-orchestrator/go.sum
index 3c3962a27d..90eff40496 100644
--- a/sidechain-orchestrator/go.sum
+++ b/sidechain-orchestrator/go.sum
@@ -8,12 +8,12 @@ cel.dev/expr v0.25.3 h1:A2jO8jwOugrrovveCWfj0KEZOfqiLgAcwjpHPhzIGw0=
 cel.dev/expr v0.25.3/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4=
 connectrpc.com/connect v1.20.0 h1:6TNDAB+WeNd2uolWNlYczB5E0KNNaVMNUEx8JEUsPmQ=
 connectrpc.com/connect v1.20.0/go.mod h1:A2ygJrukXwWy32vkCAAHNVguZrqZ+jeZ9rGRnGR4dN4=
+connectrpc.com/connect/v2 v2.0.1 h1:WTAycxe87UqxSM5oxS30d1dalZ+C5xz8Ec8O6zVYkHQ=
+connectrpc.com/connect/v2 v2.0.1/go.mod h1:N32OLrstcPUzkykFynnefFro3+xzSdOrZlK2jHmS/xo=
 connectrpc.com/grpchealth v1.5.0 h1:nHEVTwz9WYKxW2JTYUFD337q76oAZMvot9jX0WjVCQo=
 connectrpc.com/grpchealth v1.5.0/go.mod h1:fC9WGwKmDruKCNh8wj2rThiaxxoiXxvsCVIu2Ex2voA=
 connectrpc.com/grpcreflect v1.3.0 h1:Y4V+ACf8/vOb1XOc251Qun7jMB75gCUNw6llvB9csXc=
 connectrpc.com/grpcreflect v1.3.0/go.mod h1:nfloOtCS8VUQOQ1+GTdFzVg2CJo4ZGaat8JIovCtDYs=
-filippo.io/edwards25519 v1.1.1 h1:YpjwWWlNmGIDyXOn8zLzqiD+9TyIlPhGFG96P39uBpw=
-filippo.io/edwards25519 v1.1.1/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 github.com/FactomProject/basen v0.0.0-20150613233007-fe3947df716e h1:ahyvB3q25YnZWly5Gq1ekg6jcmWaGj/vG/MhF4aisoc=
 github.com/FactomProject/basen v0.0.0-20150613233007-fe3947df716e/go.mod h1:kGUqhHd//musdITWjFvNTHn90WG9bMLBEPQZ17Cmlpw=
 github.com/FactomProject/btcutilecc v0.0.0-20130527213604-d3a63a5752ec h1:1Qb69mGp/UtRPn422BH4/Y4Q3SLUrD9KHuDkm8iodFc=
@@ -87,8 +87,8 @@ github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
 github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
@@ -120,21 +120,18 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.45 h1:6KA/spDguL3KV8rnybG7ezSaE4SeMR3KC9VbUoAQaIk=
 github.com/mattn/go-sqlite3 v1.14.45/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
-github.com/mr-tron/base58 v1.3.0 h1:K6Y13R2h+dku0wOqKtecgRnBUBPrZzLZy5aIj8lCcJI=
-github.com/mr-tron/base58 v1.3.0/go.mod h1:2BuubE67DCSWwVfx37JWNG8emOC0sHEU4/HpcYgCLX8=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/oklog/ulid/v2 v2.1.2 h1:IEclFb9JNvzYA6MW2SCxbLzcHTVsfqm3PrqGQJH5zec=
 github.com/oklog/ulid/v2 v2.1.2/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNsTT1QQ=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
 github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/pborman/getopt v0.0.0-20170112200414-7148bc3a4c30/go.mod h1:85jBQOZwpVEaDAr341tbn15RS4fCAsIst0qp7i8ex1o=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rodaine/protogofakeit v0.1.1 h1:ZKouljuRM3A+TArppfBqnH8tGZHOwM/pjvtXe9DaXH8=
 github.com/rodaine/protogofakeit v0.1.1/go.mod h1:pXn/AstBYMaSfc1/RqH3N82pBuxtWgejz1AlYpY1mI0=
@@ -148,14 +145,12 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.1.5-0.20170601210322-f6abca593680/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
-github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
+github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/tidwall/gjson v1.19.0 h1:xwxm7n691Uf3u5OFjzngavjGTh55KX5q/9w9xHW88JU=
@@ -180,8 +175,6 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
 golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
-golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
-golang.org/x/exp v0.0.0-20260112195511-716be5621a96/go.mod h1:nzimsREAkjBCIEFtHiYkrJyT+2uy9YZJB7H1k68CXZU=
 golang.org/x/exp v0.0.0-20260820142414-ca536658362e h1:01Ju2A/fZKkci4zqx0eZxw//DnRYOnBiGJG14hFBhO8=
 golang.org/x/exp v0.0.0-20260820142414-ca536658362e/go.mod h1:zeBbvyFKDaLwa7CH/zI8KXt7gTl14SF7sO08Pl5jBCM=
 golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -201,14 +194,12 @@ golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
 golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
-golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
 golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8=
 golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -224,11 +215,8 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=
 google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
@@ -236,7 +224,6 @@ gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 launchpad.net/gocheck v0.0.0-20140225173054-000000000087 h1:Izowp2XBH6Ya6rv+hqbceQyw/gSGoXfH/UPoTGduL54=
 launchpad.net/gocheck v0.0.0-20140225173054-000000000087/go.mod h1:hj7XX3B/0A+80Vse0e+BUHsHMTEhd0O4cpUHr/e/BUM=
diff --git a/sidechain-orchestrator/keep_l1_shutdown_test.go b/sidechain-orchestrator/keep_l1_shutdown_test.go
index ea0cce190c..ac7e32cad6 100644
--- a/sidechain-orchestrator/keep_l1_shutdown_test.go
+++ b/sidechain-orchestrator/keep_l1_shutdown_test.go
@@ -32,7 +32,7 @@ func startManagedSleeper(t *testing.T, o *Orchestrator) BinaryConfig {
 	pid, err := o.process.Start(context.Background(), cfg, []string{"30"}, nil)
 	require.NoError(t, err)
 	require.Greater(t, pid, 0)
-	t.Cleanup(func() { _ = o.process.Stop(context.Background(), "sleep-test", true) })
+	stopOnCleanup(t, o.process, "sleep-test")
 	return cfg
 }
 
diff --git a/sidechain-orchestrator/localauth/connect.go b/sidechain-orchestrator/localauth/connect.go
new file mode 100644
index 0000000000..1d05f82c2c
--- /dev/null
+++ b/sidechain-orchestrator/localauth/connect.go
@@ -0,0 +1,43 @@
+package localauth
+
+import (
+	"context"
+	"net/http"
+
+	"connectrpc.com/connect/v2"
+)
+
+// ClientInterceptor sends the local auth token with each v2 call.
+func ClientInterceptor(dir string) connect.ClientInterceptor {
+	return func(next connect.ClientFunc) connect.ClientFunc {
+		return func(ctx context.Context, spec connect.Spec) (connect.ClientStream, error) {
+			token := TokenFromContext(ctx)
+			if token == "" {
+				var err error
+				token, err = ReadCookie(dir)
+				if err != nil {
+					return nil, err
+				}
+			}
+			if token != "" {
+				info, _ := connect.CallInfoForClientContext(ctx)
+				info.RequestHeader().Set(authHeader, scheme+token)
+			}
+			return next(ctx, spec)
+		}
+	}
+}
+
+// ServerInterceptor checks the local auth token for each v2 call.
+func ServerInterceptor(dir string) connect.ServerInterceptor {
+	return func(next connect.ServerFunc) connect.ServerFunc {
+		return func(ctx context.Context, spec connect.Spec, stream connect.ServerStream) error {
+			info, _ := connect.CallInfoForServerContext(ctx)
+			ctx, err := verifyToken(ctx, http.Header{authHeader: {info.RequestHeader().Get(authHeader)}}, dir)
+			if err != nil {
+				return connect.NewError(connect.Code(err.Code()), err.Message()).WithCause(err)
+			}
+			return next(ctx, spec, stream)
+		}
+	}
+}
diff --git a/sidechain-orchestrator/localauth/connect_test.go b/sidechain-orchestrator/localauth/connect_test.go
new file mode 100644
index 0000000000..3cc361b408
--- /dev/null
+++ b/sidechain-orchestrator/localauth/connect_test.go
@@ -0,0 +1,221 @@
+package localauth_test
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+
+	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/localauth"
+)
+
+func authServer(t *testing.T, dir string) *httptest.Server {
+	t.Helper()
+	server := connect.NewServer(localauth.ServerInterceptor(dir))
+	for _, streamType := range []connect.StreamType{connect.StreamTypeUnary, connect.StreamTypeServer} {
+		server.Register(connect.Method{
+			Spec: connect.Spec{Procedure: authProcedure(streamType), StreamType: streamType},
+			Handler: func(ctx context.Context, _ connect.Spec, stream connect.ServerStream) error {
+				message := new(wrapperspb.StringValue)
+				if err := stream.Receive(message); err != nil {
+					return err
+				}
+				info, _ := connect.CallInfoForServerContext(ctx)
+				info.ResponseHeader().Set("X-Test-Header", info.RequestHeader().Get("X-Test-Header"))
+				info.ResponseTrailer().Set("X-Test-Trailer", "complete")
+				if dir != "" && localauth.TokenFromContext(ctx) == "" {
+					return connect.NewError(connect.CodeInternal, "the auth token is absent")
+				}
+				if err := stream.Send(message); err != nil {
+					return err
+				}
+				if streamType == connect.StreamTypeServer {
+					return stream.Send(wrapperspb.String("second"))
+				}
+				return nil
+			},
+		})
+	}
+	mux := http.NewServeMux()
+	connecthttp.Mount(mux, server, connecthttp.WithReadMaxBytes(0))
+	httpServer := httptest.NewUnstartedServer(mux)
+	httpServer.EnableHTTP2 = true
+	httpServer.StartTLS()
+	t.Cleanup(httpServer.Close)
+	return httpServer
+}
+
+func authProcedure(streamType connect.StreamType) string {
+	if streamType == connect.StreamTypeServer {
+		return "/localauth.test.v2.EchoService/Stream"
+	}
+	return "/localauth.test.v2.EchoService/Echo"
+}
+
+func TestV1ClientsUseV2Auth(t *testing.T) {
+	for _, protocol := range []struct {
+		name    string
+		options []connectv1.ClientOption
+	}{
+		{name: "Connect"},
+		{name: "gRPC", options: []connectv1.ClientOption{connectv1.WithGRPC()}},
+		{name: "gRPC-Web", options: []connectv1.ClientOption{connectv1.WithGRPCWeb()}},
+	} {
+		t.Run(protocol.name, func(t *testing.T) {
+			dir := t.TempDir()
+			_, err := localauth.WriteCookie(dir)
+			require.NoError(t, err)
+			server := authServer(t, dir)
+
+			for _, authorized := range []bool{false, true} {
+				options := append([]connectv1.ClientOption{}, protocol.options...)
+				if authorized {
+					options = append(options, connectv1.WithInterceptors(localauth.Interceptor(dir)))
+				}
+				client := connectv1.NewClient[wrapperspb.StringValue, wrapperspb.StringValue](
+					server.Client(), server.URL+authProcedure(connect.StreamTypeUnary), options...,
+				)
+				request := connectv1.NewRequest(wrapperspb.String("first"))
+				request.Header().Set("X-Test-Header", "metadata")
+				response, err := client.CallUnary(t.Context(), request)
+				if !authorized {
+					require.Equal(t, connectv1.CodeUnauthenticated, connectv1.CodeOf(err), "%v", err)
+				} else {
+					require.NoError(t, err)
+					require.Equal(t, "first", response.Msg.Value)
+					require.Equal(t, "metadata", response.Header().Get("X-Test-Header"))
+					require.Equal(t, "complete", response.Trailer().Get("X-Test-Trailer"))
+				}
+
+				client = connectv1.NewClient[wrapperspb.StringValue, wrapperspb.StringValue](
+					server.Client(), server.URL+authProcedure(connect.StreamTypeServer), options...,
+				)
+				request = connectv1.NewRequest(wrapperspb.String("first"))
+				request.Header().Set("X-Test-Header", "metadata")
+				stream, err := client.CallServerStream(t.Context(), request)
+				if !authorized {
+					if err == nil {
+						require.False(t, stream.Receive())
+						err = stream.Err()
+						require.NoError(t, stream.Close())
+					}
+					require.Equal(t, connectv1.CodeUnauthenticated, connectv1.CodeOf(err), "%v", err)
+					continue
+				}
+				require.NoError(t, err)
+				var messages []string
+				for stream.Receive() {
+					messages = append(messages, stream.Msg().Value)
+				}
+				require.NoError(t, stream.Err())
+				require.NoError(t, stream.Close())
+				require.Equal(t, []string{"first", "second"}, messages)
+				require.Equal(t, "metadata", stream.ResponseHeader().Get("X-Test-Header"))
+				require.Equal(t, "complete", stream.ResponseTrailer().Get("X-Test-Trailer"))
+			}
+		})
+	}
+}
+
+func TestV2ClientAuth(t *testing.T) {
+	dir := t.TempDir()
+	token, err := localauth.WriteCookie(dir)
+	require.NoError(t, err)
+	server := authServer(t, dir)
+	for _, tt := range []struct {
+		name  string
+		dir   string
+		token string
+		code  connect.Code
+	}{
+		{name: "the client reads the cookie", dir: dir},
+		{name: "the context holds the token", token: token},
+		{name: "the token is absent", code: connect.CodeUnauthenticated},
+		{name: "the context token is wrong", dir: dir, token: "wrong", code: connect.CodeUnauthenticated},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			client := connect.NewClient(
+				connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0)),
+				localauth.ClientInterceptor(tt.dir),
+			)
+			for _, streamType := range []connect.StreamType{connect.StreamTypeUnary, connect.StreamTypeServer} {
+				ctx, info := connect.NewClientContext(localauth.WithToken(t.Context(), tt.token))
+				info.RequestHeader().Set("X-Test-Header", "metadata")
+				spec := connect.Spec{Procedure: authProcedure(streamType), StreamType: streamType}
+				if streamType == connect.StreamTypeUnary {
+					response := new(wrapperspb.StringValue)
+					err := client.CallUnary(ctx, spec, wrapperspb.String("first"), response)
+					if tt.code != 0 {
+						require.Equal(t, tt.code, connect.CodeOf(err))
+						continue
+					}
+					require.NoError(t, err)
+					require.Equal(t, "first", response.Value)
+				} else {
+					stream, err := client.CallServerStream(ctx, spec, wrapperspb.String("first"))
+					require.NoError(t, err)
+					response := new(wrapperspb.StringValue)
+					err = stream.Receive(response)
+					if tt.code != 0 {
+						require.Equal(t, tt.code, connect.CodeOf(err))
+						require.NoError(t, stream.Close())
+						continue
+					}
+					require.NoError(t, err)
+					require.Equal(t, "first", response.Value)
+					require.NoError(t, stream.Receive(response))
+					require.Equal(t, "second", response.Value)
+					require.ErrorIs(t, stream.Receive(response), io.EOF)
+					require.NoError(t, stream.Close())
+				}
+				require.Equal(t, "metadata", info.ResponseHeader().Get("X-Test-Header"))
+				require.Equal(t, "complete", info.ResponseTrailer().Get("X-Test-Trailer"))
+			}
+		})
+	}
+}
+
+func TestV2AuthWithNoCookie(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		dir  string
+		code connect.Code
+	}{
+		{name: "auth is disabled"},
+		{name: "the server cookie is absent", dir: t.TempDir(), code: connect.CodeUnauthenticated},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			server := authServer(t, test.dir)
+			client := connect.NewClient(
+				connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0)),
+				localauth.ClientInterceptor(test.dir),
+			)
+			err := client.CallUnary(t.Context(), connect.Spec{Procedure: authProcedure(connect.StreamTypeUnary)},
+				wrapperspb.String("first"), new(wrapperspb.StringValue))
+			if test.code != 0 {
+				require.Equal(t, test.code, connect.CodeOf(err))
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestV2KeepsTheReadLimit(t *testing.T) {
+	server := authServer(t, "")
+	client := connect.NewClient(connecthttp.NewTransport(server.Client(), server.URL, connecthttp.WithReadMaxBytes(0)))
+	message := strings.Repeat("a", 5<<20)
+	response := new(wrapperspb.StringValue)
+	err := client.CallUnary(t.Context(), connect.Spec{Procedure: authProcedure(connect.StreamTypeUnary)},
+		wrapperspb.String(message), response)
+	require.NoError(t, err)
+	require.Equal(t, message, response.Value)
+}
diff --git a/sidechain-orchestrator/localauth/localauth.go b/sidechain-orchestrator/localauth/localauth.go
index 6eb5bf980e..e7054779c9 100644
--- a/sidechain-orchestrator/localauth/localauth.go
+++ b/sidechain-orchestrator/localauth/localauth.go
@@ -202,6 +202,14 @@ func attach(ctx context.Context, h http.Header, dir string) {
 // (explicit insecure/test mode). Missing cookie, missing header, or mismatch ⇒
 // CodeUnauthenticated. Match ⇒ pass with the token injected into ctx.
 func verify(ctx context.Context, h http.Header, dir string) (context.Context, error) {
+	ctx, err := verifyToken(ctx, h, dir)
+	if err != nil {
+		return ctx, err
+	}
+	return ctx, nil
+}
+
+func verifyToken(ctx context.Context, h http.Header, dir string) (context.Context, *connect.Error) {
 	if dir == "" {
 		return ctx, nil
 	}
diff --git a/sidechain-orchestrator/orchestrator.go b/sidechain-orchestrator/orchestrator.go
index db414976ce..48c6390f5e 100644
--- a/sidechain-orchestrator/orchestrator.go
+++ b/sidechain-orchestrator/orchestrator.go
@@ -20,7 +20,8 @@ import (
 	"syscall"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"golang.org/x/net/http2"
 
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
@@ -2611,14 +2612,15 @@ func (o *Orchestrator) callEnforcerStopRPC() error {
 			},
 		},
 	}
-	client := enforcerrpc.NewValidatorServiceClient(
+	client := enforcerrpc.NewValidatorServiceClient(connect.NewClient(connecthttp.NewTransport(
 		httpClient,
 		cfg.RPCURL(),
-		connect.WithGRPC(),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	)))
 	rpcCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 	defer cancel()
-	_, err := client.Stop(rpcCtx, connect.NewRequest(&enforcerpb.StopRequest{}))
+	_, err := client.Stop(rpcCtx, &enforcerpb.StopRequest{})
 	return err
 }
 
@@ -3345,7 +3347,7 @@ func (o *Orchestrator) EnforcerValidator() (enforcerrpc.ValidatorServiceClient,
 	if err != nil {
 		return nil, err
 	}
-	return enforcerrpc.NewValidatorServiceClient(o.enforcerHTTP(), endpoint, connect.WithGRPC()), nil
+	return enforcerrpc.NewValidatorServiceClient(connect.NewClient(connecthttp.NewTransport(o.enforcerHTTP(), endpoint, connecthttp.WithReadMaxBytes(0), connecthttp.WithGRPC()))), nil
 }
 
 // ChainTip returns the mainchain tip the enforcer has validated.
@@ -3354,11 +3356,11 @@ func (o *Orchestrator) ChainTip(ctx context.Context) (string, int32, error) {
 	if err != nil {
 		return "", 0, err
 	}
-	resp, err := validator.GetChainTip(ctx, connect.NewRequest(&enforcerpb.GetChainTipRequest{}))
+	resp, err := validator.GetChainTip(ctx, &enforcerpb.GetChainTipRequest{})
 	if err != nil {
 		return "", 0, err
 	}
-	info := resp.Msg.GetBlockHeaderInfo()
+	info := resp.GetBlockHeaderInfo()
 	return info.GetBlockHash().GetHex().GetValue(), int32(info.GetHeight()), nil
 }
 
@@ -3604,12 +3606,12 @@ func (c *enforcerSyncConnection) Fetch(ctx context.Context) (*ChainSyncResult, e
 	}
 	rpcCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
 	defer cancel()
-	resp, err := client.GetChainTip(rpcCtx, connect.NewRequest(&enforcerpb.GetChainTipRequest{}))
+	resp, err := client.GetChainTip(rpcCtx, &enforcerpb.GetChainTipRequest{})
 	if err != nil {
 		return nil, err
 	}
 	return &ChainSyncResult{
-		Blocks: int64(resp.Msg.GetBlockHeaderInfo().GetHeight()),
+		Blocks: int64(resp.GetBlockHeaderInfo().GetHeight()),
 	}, nil
 }
 
diff --git a/sidechain-orchestrator/orchestrator_test.go b/sidechain-orchestrator/orchestrator_test.go
index 630b4230ba..df79396922 100644
--- a/sidechain-orchestrator/orchestrator_test.go
+++ b/sidechain-orchestrator/orchestrator_test.go
@@ -65,6 +65,15 @@ func newTestProcessManager(t *testing.T) (*ProcessManager, string) {
 	return pm, dir
 }
 
+// stopOnCleanup kills the process at cleanup and waits for its log tail to finish.
+func stopOnCleanup(t *testing.T, pm *ProcessManager, name string) {
+	t.Helper()
+	t.Cleanup(func() {
+		_ = pm.Stop(context.Background(), name, true)
+		pm.WaitForExit(name, 5*time.Second)
+	})
+}
+
 func newTestDownloadManager(t *testing.T) (*DownloadManager, string) {
 	t.Helper()
 	dir := t.TempDir()
diff --git a/sidechain-orchestrator/remote_enforcer.go b/sidechain-orchestrator/remote_enforcer.go
index 01d8073137..9c8289d383 100644
--- a/sidechain-orchestrator/remote_enforcer.go
+++ b/sidechain-orchestrator/remote_enforcer.go
@@ -6,7 +6,8 @@ import (
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
+	connectv1 "connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"connectrpc.com/grpchealth"
 
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
@@ -90,7 +91,7 @@ type enforcerHealthCheck struct {
 // network publishes its validator address before the host stands up, and this
 // install runs none of it, so an unreachable host is not a fault here.
 func remoteEnforcerCheckError(network string, err error) error {
-	if connect.CodeOf(err) == connect.CodeUnavailable {
+	if connect.CodeOf(err) == connect.CodeUnavailable || connectv1.CodeOf(err) == connectv1.CodeUnavailable {
 		return fmt.Errorf("the remote enforcer for %s is not live yet", network)
 	}
 	return fmt.Errorf("check the remote validator service: %w", err)
@@ -110,7 +111,7 @@ func (h *enforcerHealthCheck) Check(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	health := grpchealth.NewClient(h.orch.enforcerHTTP(), endpoint, connect.WithGRPC())
+	health := grpchealth.NewClient(h.orch.enforcerHTTP(), endpoint, connectv1.WithGRPC())
 	status, err := health.Check(ctx, &grpchealth.CheckRequest{Service: "cusf.mainchain.v1.ValidatorService"})
 	if err != nil {
 		return remoteEnforcerCheckError(config.NetworkDisplayName(config.Network(h.orch.CurrentNetwork())), err)
@@ -118,7 +119,7 @@ func (h *enforcerHealthCheck) Check(ctx context.Context) error {
 	if status.Status != grpchealth.StatusServing {
 		return fmt.Errorf("the remote validator service is not ready")
 	}
-	_, err = client.GetChainTip(ctx, connect.NewRequest(&enforcerpb.GetChainTipRequest{}))
+	_, err = client.GetChainTip(ctx, &enforcerpb.GetChainTipRequest{})
 	return err
 }
 
diff --git a/sidechain-orchestrator/remote_enforcer_health_test.go b/sidechain-orchestrator/remote_enforcer_health_test.go
index 386e46df9f..e9a28853f5 100644
--- a/sidechain-orchestrator/remote_enforcer_health_test.go
+++ b/sidechain-orchestrator/remote_enforcer_health_test.go
@@ -8,12 +8,12 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"connectrpc.com/grpchealth"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	enforcerpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1"
 	enforcerrpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/cusf/mainchain/v1/mainchainv1connect"
 )
 
@@ -24,18 +24,15 @@ func TestRemoteHealthFailureClearsStartupState(t *testing.T) {
 			checker := grpchealth.NewStaticChecker(service)
 			checker.SetStatus(service, grpchealth.StatusNotServing)
 			mux := http.NewServeMux()
-			path, handler := grpchealth.NewHandler(checker)
 			var checks atomic.Int32
+			path, handler := grpchealth.NewHandler(checker)
 			mux.Handle(path, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 				handler.ServeHTTP(w, r)
 				checks.Add(1)
 			}))
-			mux.Handle(enforcerrpc.ValidatorServiceGetChainTipProcedure, connect.NewUnaryHandler(
-				enforcerrpc.ValidatorServiceGetChainTipProcedure,
-				func(context.Context, *connect.Request[enforcerpb.GetChainTipRequest]) (*connect.Response[enforcerpb.GetChainTipResponse], error) {
-					return connect.NewResponse(&enforcerpb.GetChainTipResponse{BlockHeaderInfo: &enforcerpb.BlockHeaderInfo{Height: 42}}), nil
-				},
-			))
+			rpcServer := connect.NewServer()
+			enforcerrpc.RegisterValidatorServiceHandler(rpcServer, remoteValidator{height: 42})
+			connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 			server := httptest.NewUnstartedServer(mux)
 			server.Config.Protocols = new(http.Protocols)
 			server.Config.Protocols.SetHTTP1(true)
diff --git a/sidechain-orchestrator/remote_enforcer_test.go b/sidechain-orchestrator/remote_enforcer_test.go
index c462324cc0..080785923c 100644
--- a/sidechain-orchestrator/remote_enforcer_test.go
+++ b/sidechain-orchestrator/remote_enforcer_test.go
@@ -16,7 +16,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"connectrpc.com/grpchealth"
 
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
@@ -26,20 +27,26 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+type remoteValidator struct {
+	enforcerrpc.UnimplementedValidatorServiceHandler
+	height  uint32
+	failure *atomic.Bool
+}
+
+func (v remoteValidator) GetChainTip(context.Context, *enforcerpb.GetChainTipRequest) (*enforcerpb.GetChainTipResponse, error) {
+	if v.failure != nil && v.failure.Load() {
+		return nil, connect.NewError(connect.CodeUnavailable, "validator is offline")
+	}
+	return &enforcerpb.GetChainTipResponse{BlockHeaderInfo: &enforcerpb.BlockHeaderInfo{Height: v.height}}, nil
+}
+
 func remoteValidatorServer(t *testing.T, height uint32, failure *atomic.Bool) *httptest.Server {
 	t.Helper()
 	mux := http.NewServeMux()
-	mux.Handle(enforcerrpc.ValidatorServiceGetChainTipProcedure, connect.NewUnaryHandler(
-		enforcerrpc.ValidatorServiceGetChainTipProcedure,
-		func(context.Context, *connect.Request[enforcerpb.GetChainTipRequest]) (*connect.Response[enforcerpb.GetChainTipResponse], error) {
-			if failure != nil && failure.Load() {
-				return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("validator is offline"))
-			}
-			return connect.NewResponse(&enforcerpb.GetChainTipResponse{BlockHeaderInfo: &enforcerpb.BlockHeaderInfo{Height: height}}), nil
-		},
-	))
-	healthPath, healthHandler := grpchealth.NewHandler(grpchealth.NewStaticChecker("cusf.mainchain.v1.ValidatorService"))
-	mux.Handle(healthPath, healthHandler)
+	rpcServer := connect.NewServer()
+	enforcerrpc.RegisterValidatorServiceHandler(rpcServer, remoteValidator{height: height, failure: failure})
+	mux.Handle(grpchealth.NewHandler(grpchealth.NewStaticChecker("cusf.mainchain.v1.ValidatorService")))
+	connecthttp.Mount(mux, rpcServer, connecthttp.WithReadMaxBytes(0))
 	server := httptest.NewUnstartedServer(mux)
 	server.Config.Protocols = new(http.Protocols)
 	server.Config.Protocols.SetHTTP1(true)
@@ -95,9 +102,9 @@ func TestRemoteEnforcerKeepsOneBridge(t *testing.T) {
 	}
 	client, err := o.EnforcerValidator()
 	require.NoError(t, err)
-	tip, err := client.GetChainTip(context.Background(), connect.NewRequest(&enforcerpb.GetChainTipRequest{}))
+	tip, err := client.GetChainTip(context.Background(), &enforcerpb.GetChainTipRequest{})
 	require.NoError(t, err)
-	require.EqualValues(t, 42, tip.Msg.BlockHeaderInfo.Height)
+	require.EqualValues(t, 42, tip.BlockHeaderInfo.Height)
 	status, err := (&enforcerSyncConnection{o: o}).Fetch(context.Background())
 	require.NoError(t, err)
 	require.EqualValues(t, 42, status.Blocks)
@@ -109,18 +116,18 @@ func TestRemoteEnforcerKeepsClientAfterEndpointChange(t *testing.T) {
 	o := remoteTestOrchestrator(t, firstServer.URL)
 	first, err := o.EnforcerURL()
 	require.NoError(t, err)
-	client := enforcerrpc.NewValidatorServiceClient(o.enforcerHTTP(), first, connect.WithGRPC())
-	tip, err := client.GetChainTip(context.Background(), connect.NewRequest(&enforcerpb.GetChainTipRequest{}))
+	client := enforcerrpc.NewValidatorServiceClient(connect.NewClient(connecthttp.NewTransport(o.enforcerHTTP(), first, connecthttp.WithReadMaxBytes(0), connecthttp.WithGRPC())))
+	tip, err := client.GetChainTip(context.Background(), &enforcerpb.GetChainTipRequest{})
 	require.NoError(t, err)
-	require.EqualValues(t, 42, tip.Msg.BlockHeaderInfo.Height)
+	require.EqualValues(t, 42, tip.BlockHeaderInfo.Height)
 	entry := config.PublishedEndpoints(config.NetworkSignet)
 	entry.Services.Enforcer.URL = secondServer.URL
 	config.SetNetworkEndpoints(config.NetworkSignet, entry)
 	second, err := o.EnforcerURL()
 	require.NoError(t, err)
-	tip, err = client.GetChainTip(context.Background(), connect.NewRequest(&enforcerpb.GetChainTipRequest{}))
+	tip, err = client.GetChainTip(context.Background(), &enforcerpb.GetChainTipRequest{})
 	require.NoError(t, err)
-	require.EqualValues(t, 56, tip.Msg.BlockHeaderInfo.Height)
+	require.EqualValues(t, 56, tip.BlockHeaderInfo.Height)
 	require.Equal(t, first, second)
 	status, err := (&enforcerSyncConnection{o: o}).Fetch(context.Background())
 	require.NoError(t, err)
@@ -439,6 +446,7 @@ func installRemoteTestDaemon(t *testing.T, o *Orchestrator) (BinaryConfig, map[s
 		o.StopAllMonitors()
 		if o.process.IsRunning(cfg.Name) {
 			require.NoError(t, o.Stop(context.Background(), cfg.Name, true, StopOptions{ForceBackend: true}))
+			o.process.WaitForExit(cfg.Name, 5*time.Second)
 		}
 	})
 	return cfg, env, argsPath
@@ -543,11 +551,11 @@ func TestRemoteSidechainStopsBeforeAnUnavailableValidator(t *testing.T) {
 // A network publishes its validator address before the host stands up. Until it
 // answers, light mode waits; it does not report a broken install.
 func TestRemoteEnforcerCheckErrorNamesAHostThatIsNotUp(t *testing.T) {
-	unreachable := connect.NewError(connect.CodeUnavailable, fmt.Errorf("dial tcp: no such host"))
+	unreachable := connect.Errorf(connect.CodeUnavailable, "dial tcp: no such host")
 	require.EqualError(t, remoteEnforcerCheckError("Betanet", unreachable),
 		"the remote enforcer for Betanet is not live yet")
 
-	refused := connect.NewError(connect.CodeInternal, fmt.Errorf("bad certificate"))
+	refused := connect.Errorf(connect.CodeInternal, "bad certificate")
 	require.EqualError(t, remoteEnforcerCheckError("Betanet", refused),
 		"check the remote validator service: internal: bad certificate")
 }
diff --git a/sidechain-orchestrator/replay_locktime_integration_test.go b/sidechain-orchestrator/replay_locktime_integration_test.go
index 4c7e287472..3b4bbc40fb 100644
--- a/sidechain-orchestrator/replay_locktime_integration_test.go
+++ b/sidechain-orchestrator/replay_locktime_integration_test.go
@@ -9,7 +9,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config/netcatalog"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/testharness"
@@ -45,12 +44,12 @@ func TestReplayLockTime(t *testing.T) {
 
 		dest := freshAddress(ctx, t, node)
 
-		normal, err := node.WalletClient.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+		normal, err := node.WalletClient.SendTransaction(ctx, &pb.SendTransactionRequest{
 			Destinations: map[string]int64{dest: 100_000_000},
-		}))
+		})
 		require.NoError(t, err, "normal send should succeed on stock bitcoind")
 		require.NoError(t, node.Mine(ctx, t, 1))
-		requireConfirmed(ctx, t, node, normal.Msg.Txid)
+		requireConfirmed(ctx, t, node, normal.Txid)
 
 		for _, lockTime := range []uint32{betanetLockTime, ecashMainnetLockTime} {
 			_, err = broadcastProtected(ctx, t, node, dest, lockTime)
@@ -161,9 +160,9 @@ func startFundedNode(t *testing.T, bitcoindBin string) *testharness.Node {
 
 func freshAddress(ctx context.Context, t *testing.T, n *testharness.Node) string {
 	t.Helper()
-	resp, err := n.WalletClient.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+	resp, err := n.WalletClient.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 	require.NoError(t, err)
-	return resp.Msg.Address
+	return resp.Address
 }
 
 func requireConfirmed(ctx context.Context, t *testing.T, n *testharness.Node, txid string) {
diff --git a/sidechain-orchestrator/reset_to_block.go b/sidechain-orchestrator/reset_to_block.go
index 233f59571c..c882228934 100644
--- a/sidechain-orchestrator/reset_to_block.go
+++ b/sidechain-orchestrator/reset_to_block.go
@@ -9,7 +9,7 @@ import (
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 )
 
 // resetSyncPollInterval is how often the replay reads Core's tip while
@@ -59,7 +59,7 @@ type resetTarget struct {
 func resolveResetTarget(ctx context.Context, client *CoreStatusClient, target string) (resetTarget, error) {
 	trimmed := strings.TrimSpace(target)
 	if trimmed == "" {
-		return resetTarget{}, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("name the block to reset to, by height or by hash"))
+		return resetTarget{}, connect.Errorf(connect.CodeInvalidArgument, "name the block to reset to, by height or by hash")
 	}
 
 	hash := ""
@@ -68,14 +68,14 @@ func resolveResetTarget(ctx context.Context, client *CoreStatusClient, target st
 	} else {
 		height, err := strconv.ParseUint(strings.ReplaceAll(trimmed, " ", ""), 10, 32)
 		if err != nil {
-			return resetTarget{}, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("read %q as a height or as a 64-character hash", trimmed))
+			return resetTarget{}, connect.Errorf(connect.CodeInvalidArgument, "read %q as a height or as a 64-character hash", trimmed)
 		}
 		tipHeight, _, err := coreTip(ctx, client)
 		if err != nil {
 			return resetTarget{}, err
 		}
 		if uint32(height) > tipHeight {
-			return resetTarget{}, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("no block at height %d: this node holds a chain that ends at %d", height, tipHeight))
+			return resetTarget{}, connect.Errorf(connect.CodeInvalidArgument, "no block at height %d: this node holds a chain that ends at %d", height, tipHeight)
 		}
 		raw, err := client.call(ctx, "getblockhash", height)
 		if err != nil {
@@ -88,7 +88,7 @@ func resolveResetTarget(ctx context.Context, client *CoreStatusClient, target st
 
 	header, err := readBlockHeader(ctx, client, hash)
 	if isBlockNotFound(err) {
-		return resetTarget{}, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("this node holds no block %s", hash))
+		return resetTarget{}, connect.Errorf(connect.CodeInvalidArgument, "this node holds no block %s", hash)
 	}
 	if err != nil {
 		return resetTarget{}, err
@@ -96,7 +96,7 @@ func resolveResetTarget(ctx context.Context, client *CoreStatusClient, target st
 	// A block off the active chain has nothing above it to replay, and Core
 	// would climb back to a tip the caller never named.
 	if header.Confirmations < 0 {
-		return resetTarget{}, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("block %s sits off the chain this node follows", hash))
+		return resetTarget{}, connect.Errorf(connect.CodeInvalidArgument, "block %s sits off the chain this node follows", hash)
 	}
 	if header.Height < 0 {
 		return resetTarget{}, fmt.Errorf("block %s reports no height", hash)
@@ -116,7 +116,7 @@ func (o *Orchestrator) ResetToBlock(ctx context.Context, target string, enforcer
 
 	client, err := o.CoreStatusClient()
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("bitcoin core rpc: %w", err))
+		return nil, connect.NewError(connect.CodeUnavailable, fmt.Errorf("bitcoin core rpc: %w", err).Error())
 	}
 
 	// Resolve before the channel so a bad target is an RPC error, not a stream
diff --git a/sidechain-orchestrator/reset_to_block_test.go b/sidechain-orchestrator/reset_to_block_test.go
index 56b1c4bf5c..b2ff5ddc45 100644
--- a/sidechain-orchestrator/reset_to_block_test.go
+++ b/sidechain-orchestrator/reset_to_block_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 )
 
 const (
diff --git a/sidechain-orchestrator/rpcmeter/proxy_test.go b/sidechain-orchestrator/rpcmeter/proxy_test.go
new file mode 100644
index 0000000000..a2524012f5
--- /dev/null
+++ b/sidechain-orchestrator/rpcmeter/proxy_test.go
@@ -0,0 +1,68 @@
+package rpcmeter
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+
+	"connectrpc.com/connect"
+	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/localauth"
+	corepb "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha"
+	corerpc "github.com/barebitcoin/btc-buf/gen/bitcoin/bitcoind/v1alpha/bitcoindv1alphaconnect"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+)
+
+type testBitcoinService struct {
+	corerpc.UnimplementedBitcoinServiceHandler
+	failure atomic.Bool
+}
+
+func (s *testBitcoinService) GetBlockchainInfo(context.Context, *connect.Request[corepb.GetBlockchainInfoRequest]) (*connect.Response[corepb.GetBlockchainInfoResponse], error) {
+	if s.failure.Load() {
+		return nil, connect.NewError(connect.CodeUnavailable, errors.New("the node is offline"))
+	}
+	return connect.NewResponse(&corepb.GetBlockchainInfoResponse{Blocks: 42}), nil
+}
+
+func TestProxyAuthAndMetrics(t *testing.T) {
+	dir := t.TempDir()
+	_, err := localauth.WriteCookie(dir)
+	require.NoError(t, err)
+	meter := New(t.Context(), zerolog.Nop(), 0)
+	service := new(testBitcoinService)
+	mux := http.NewServeMux()
+	mux.Handle(corerpc.NewBitcoinServiceHandler(service,
+		connect.WithInterceptors(localauth.Interceptor(dir), meter.Interceptor()),
+	))
+	server := httptest.NewServer(mux)
+	t.Cleanup(server.Close)
+
+	client := corerpc.NewBitcoinServiceClient(server.Client(), server.URL)
+	_, err = client.GetBlockchainInfo(t.Context(), connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	require.Equal(t, connect.CodeUnauthenticated, connect.CodeOf(err))
+	meter.mu.Lock()
+	require.Empty(t, meter.stats)
+	meter.mu.Unlock()
+
+	client = corerpc.NewBitcoinServiceClient(server.Client(), server.URL,
+		connect.WithInterceptors(localauth.Interceptor(dir)),
+	)
+	response, err := client.GetBlockchainInfo(t.Context(), connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	require.NoError(t, err)
+	require.Equal(t, uint32(42), response.Msg.Blocks)
+	service.failure.Store(true)
+	_, err = client.GetBlockchainInfo(t.Context(), connect.NewRequest(&corepb.GetBlockchainInfoRequest{}))
+	require.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
+
+	meter.mu.Lock()
+	defer meter.mu.Unlock()
+	stat := meter.stats["GetBlockchainInfo"]
+	require.NotNil(t, stat)
+	require.Equal(t, int64(2), stat.count)
+	require.Equal(t, int64(1), stat.errors)
+	require.Positive(t, stat.totalDur)
+}
diff --git a/sidechain-orchestrator/sidechain/bbc/handler.go b/sidechain-orchestrator/sidechain/bbc/handler.go
index df73593c4a..87dca85865 100644
--- a/sidechain-orchestrator/sidechain/bbc/handler.go
+++ b/sidechain-orchestrator/sidechain/bbc/handler.go
@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"math"
 
-	"connectrpc.com/connect"
-
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bbc/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bbc/v1/bbcv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain/corenode"
@@ -24,15 +22,15 @@ func NewHandler(client *Client) *Handler {
 	return &Handler{client: client}
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, _ *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, _ *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.client.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) GetBlockchainInfo(ctx context.Context, _ *connect.Request[pb.GetBlockchainInfoRequest]) (*connect.Response[pb.GetBlockchainInfoResponse], error) {
+func (h *Handler) GetBlockchainInfo(ctx context.Context, _ *pb.GetBlockchainInfoRequest) (*pb.GetBlockchainInfoResponse, error) {
 	raw, err := h.client.GetBlockchainInfo(ctx)
 	if err != nil {
 		return nil, err
@@ -55,7 +53,7 @@ func (h *Handler) GetBlockchainInfo(ctx context.Context, _ *connect.Request[pb.G
 	if err := json.Unmarshal(raw, &info); err != nil {
 		return nil, fmt.Errorf("decode getblockchaininfo result: %w", err)
 	}
-	return connect.NewResponse(&pb.GetBlockchainInfoResponse{
+	return &pb.GetBlockchainInfoResponse{
 		Chain:                info.Chain,
 		Blocks:               info.Blocks,
 		Headers:              info.Headers,
@@ -69,62 +67,62 @@ func (h *Handler) GetBlockchainInfo(ctx context.Context, _ *connect.Request[pb.G
 		SizeOnDisk:           info.SizeOnDisk,
 		Pruned:               info.Pruned,
 		Warnings:             info.Warnings,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetSidechainInfo(ctx context.Context, _ *connect.Request[pb.GetSidechainInfoRequest]) (*connect.Response[pb.GetSidechainInfoResponse], error) {
+func (h *Handler) GetSidechainInfo(ctx context.Context, _ *pb.GetSidechainInfoRequest) (*pb.GetSidechainInfoResponse, error) {
 	info, err := h.client.GetSidechainInfo(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainInfoResponse{
+	return &pb.GetSidechainInfoResponse{
 		Synced:       info.Synced,
 		MainchainTip: info.MainchainTip,
 		LastError:    info.LastError,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetMainchainTip(ctx context.Context, _ *connect.Request[pb.GetMainchainTipRequest]) (*connect.Response[pb.GetMainchainTipResponse], error) {
+func (h *Handler) GetMainchainTip(ctx context.Context, _ *pb.GetMainchainTipRequest) (*pb.GetMainchainTipResponse, error) {
 	hash, err := h.client.GetMainchainTip(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetMainchainTipResponse{BlockHash: hash}), nil
+	return &pb.GetMainchainTipResponse{BlockHash: hash}, nil
 }
 
-func (h *Handler) GetBmmCommitment(ctx context.Context, req *connect.Request[pb.GetBmmCommitmentRequest]) (*connect.Response[pb.GetBmmCommitmentResponse], error) {
-	commitment, err := h.client.GetBmmCommitment(ctx, req.Msg.MainchainBlockHash)
+func (h *Handler) GetBmmCommitment(ctx context.Context, req *pb.GetBmmCommitmentRequest) (*pb.GetBmmCommitmentResponse, error) {
+	commitment, err := h.client.GetBmmCommitment(ctx, req.MainchainBlockHash)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmCommitmentResponse{Commitment: commitment}), nil
+	return &pb.GetBmmCommitmentResponse{Commitment: commitment}, nil
 }
 
-func (h *Handler) GetNewAddress(ctx context.Context, _ *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *Handler) GetNewAddress(ctx context.Context, _ *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	address, err := h.client.GetNewAddress(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewAddressResponse{Address: address}), nil
+	return &pb.GetNewAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) Send(ctx context.Context, req *connect.Request[pb.SendRequest]) (*connect.Response[pb.SendResponse], error) {
-	txid, err := h.client.SendToAddress(ctx, req.Msg.Address, req.Msg.AmountSats, req.Msg.SubtractFeeFromAmount)
+func (h *Handler) Send(ctx context.Context, req *pb.SendRequest) (*pb.SendResponse, error) {
+	txid, err := h.client.SendToAddress(ctx, req.Address, req.AmountSats, req.SubtractFeeFromAmount)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SendResponse{Txid: txid}), nil
+	return &pb.SendResponse{Txid: txid}, nil
 }
 
-func (h *Handler) EstimateFee(ctx context.Context, _ *connect.Request[pb.EstimateFeeRequest]) (*connect.Response[pb.EstimateFeeResponse], error) {
+func (h *Handler) EstimateFee(ctx context.Context, _ *pb.EstimateFeeRequest) (*pb.EstimateFeeResponse, error) {
 	feeRate, err := h.client.EstimateSmartFee(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.EstimateFeeResponse{SatsPerKvb: int64(math.Round(feeRate * 1e8))}), nil
+	return &pb.EstimateFeeResponse{SatsPerKvb: int64(math.Round(feeRate * 1e8))}, nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, _ *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, _ *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	unspent, err := h.client.ListUnspent(ctx)
 	if err != nil {
 		return nil, err
@@ -139,11 +137,11 @@ func (h *Handler) ListUtxos(ctx context.Context, _ *connect.Request[pb.ListUtxos
 			Confirmations: u.Confirmations,
 		})
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{Utxos: utxos}), nil
+	return &pb.ListUtxosResponse{Utxos: utxos}, nil
 }
 
-func (h *Handler) ListTransactions(ctx context.Context, req *connect.Request[pb.ListTransactionsRequest]) (*connect.Response[pb.ListTransactionsResponse], error) {
-	count := int(req.Msg.Count)
+func (h *Handler) ListTransactions(ctx context.Context, req *pb.ListTransactionsRequest) (*pb.ListTransactionsResponse, error) {
+	count := int(req.Count)
 	if count <= 0 {
 		count = 100
 	}
@@ -162,12 +160,12 @@ func (h *Handler) ListTransactions(ctx context.Context, req *connect.Request[pb.
 			Category:      tx.Category,
 		})
 	}
-	return connect.NewResponse(&pb.ListTransactionsResponse{Transactions: out}), nil
+	return &pb.ListTransactionsResponse{Transactions: out}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, _ *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, _ *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.client.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/bitassets/handler.go b/sidechain-orchestrator/sidechain/bitassets/handler.go
index 0b99c7d1c4..8678d14fb1 100644
--- a/sidechain-orchestrator/sidechain/bitassets/handler.go
+++ b/sidechain-orchestrator/sidechain/bitassets/handler.go
@@ -5,8 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"connectrpc.com/connect"
-
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitassets/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitassets/v1/bitassetsv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
@@ -41,53 +39,53 @@ func (h *Handler) WalletBalance(ctx context.Context) (total, available int64, er
 
 // --- Common Node methods ---
 
-func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *Handler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	total, available, err := h.WalletBalance(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		TotalSats:     total,
 		AvailableSats: available,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, req *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, req *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.proxy.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, req *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, req *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.proxy.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
 
-func (h *Handler) GetNewAddress(ctx context.Context, req *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *Handler) GetNewAddress(ctx context.Context, req *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	address, err := h.proxy.GetNewAddress(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewAddressResponse{Address: address}), nil
+	return &pb.GetNewAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) Withdraw(ctx context.Context, req *connect.Request[pb.WithdrawRequest]) (*connect.Response[pb.WithdrawResponse], error) {
-	txid, err := h.proxy.Withdraw(ctx, req.Msg.Address, req.Msg.AmountSats, req.Msg.SideFeeSats, req.Msg.MainFeeSats)
+func (h *Handler) Withdraw(ctx context.Context, req *pb.WithdrawRequest) (*pb.WithdrawResponse, error) {
+	txid, err := h.proxy.Withdraw(ctx, req.Address, req.AmountSats, req.SideFeeSats, req.MainFeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.WithdrawResponse{Txid: txid}), nil
+	return &pb.WithdrawResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.TransferRequest]) (*connect.Response[pb.TransferResponse], error) {
+func (h *Handler) Transfer(ctx context.Context, req *pb.TransferRequest) (*pb.TransferResponse, error) {
 	// BitAssets transfer accepts [dest, value, fee, memo]
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats}
-	if req.Msg.Memo != nil {
-		params = append(params, *req.Msg.Memo)
+	params := []any{req.Address, req.AmountSats, req.FeeSats}
+	if req.Memo != nil {
+		params = append(params, *req.Memo)
 	} else {
 		params = append(params, nil)
 	}
@@ -95,358 +93,358 @@ func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.Transfer
 	if err := h.proxy.Client.Call(ctx, "transfer", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferResponse{Txid: txid}), nil
+	return &pb.TransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Mine(ctx context.Context, req *connect.Request[pb.MineRequest]) (*connect.Response[pb.MineResponse], error) {
-	raw, err := h.proxy.Mine(ctx, req.Msg.FeeSats)
+func (h *Handler) Mine(ctx context.Context, req *pb.MineRequest) (*pb.MineResponse, error) {
+	raw, err := h.proxy.Mine(ctx, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MineResponse{BmmResultJson: string(raw)}), nil
+	return &pb.MineResponse{BmmResultJson: string(raw)}, nil
 }
 
-func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[pb.GetPendingWithdrawalBundleRequest]) (*connect.Response[pb.GetPendingWithdrawalBundleResponse], error) {
+func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *pb.GetPendingWithdrawalBundleRequest) (*pb.GetPendingWithdrawalBundleResponse, error) {
 	raw, err := h.proxy.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}), nil
+	return &pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.GetWalletUtxosRequest]) (*connect.Response[pb.GetWalletUtxosResponse], error) {
+func (h *Handler) GetWalletUtxos(ctx context.Context, req *pb.GetWalletUtxosRequest) (*pb.GetWalletUtxosResponse, error) {
 	raw, err := h.proxy.GetWalletUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.GetWalletUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, req *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, req *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	raw, err := h.proxy.ListUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.ListUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) RemoveFromMempool(ctx context.Context, req *connect.Request[pb.RemoveFromMempoolRequest]) (*connect.Response[pb.RemoveFromMempoolResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Msg.Txid}, nil); err != nil {
+func (h *Handler) RemoveFromMempool(ctx context.Context, req *pb.RemoveFromMempoolRequest) (*pb.RemoveFromMempoolResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Txid}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RemoveFromMempoolResponse{}), nil
+	return &pb.RemoveFromMempoolResponse{}, nil
 }
 
-func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[pb.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[pb.GetLatestFailedWithdrawalBundleHeightResponse], error) {
+func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *pb.GetLatestFailedWithdrawalBundleHeightRequest) (*pb.GetLatestFailedWithdrawalBundleHeightResponse, error) {
 	height, err := h.proxy.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}), nil
+	return &pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}, nil
 }
 
-func (h *Handler) CallRaw(ctx context.Context, req *connect.Request[pb.CallRawRequest]) (*connect.Response[pb.CallRawResponse], error) {
+func (h *Handler) CallRaw(ctx context.Context, req *pb.CallRawRequest) (*pb.CallRawResponse, error) {
 	var params any
-	if req.Msg.ParamsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.ParamsJson), &params); err != nil {
+	if req.ParamsJson != "" {
+		if err := json.Unmarshal([]byte(req.ParamsJson), &params); err != nil {
 			return nil, fmt.Errorf("unmarshal params: %w", err)
 		}
 	}
-	raw, err := h.proxy.CallRaw(ctx, req.Msg.Method, params)
+	raw, err := h.proxy.CallRaw(ctx, req.Method, params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CallRawResponse{ResultJson: string(raw)}), nil
+	return &pb.CallRawResponse{ResultJson: string(raw)}, nil
 }
 
 // --- BitAssets-specific methods ---
 
-func (h *Handler) GetSidechainWealth(ctx context.Context, req *connect.Request[pb.GetSidechainWealthRequest]) (*connect.Response[pb.GetSidechainWealthResponse], error) {
+func (h *Handler) GetSidechainWealth(ctx context.Context, req *pb.GetSidechainWealthRequest) (*pb.GetSidechainWealthResponse, error) {
 	var sats int64
 	if err := h.proxy.Client.Call(ctx, "sidechain_wealth", nil, &sats); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainWealthResponse{Sats: sats}), nil
+	return &pb.GetSidechainWealthResponse{Sats: sats}, nil
 }
 
-func (h *Handler) CreateDeposit(ctx context.Context, req *connect.Request[pb.CreateDepositRequest]) (*connect.Response[pb.CreateDepositResponse], error) {
+func (h *Handler) CreateDeposit(ctx context.Context, req *pb.CreateDepositRequest) (*pb.CreateDepositResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.ValueSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.ValueSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_deposit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CreateDepositResponse{Txid: txid}), nil
+	return &pb.CreateDepositResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ConnectPeer(ctx context.Context, req *connect.Request[pb.ConnectPeerRequest]) (*connect.Response[pb.ConnectPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ConnectPeer(ctx context.Context, req *pb.ConnectPeerRequest) (*pb.ConnectPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ConnectPeerResponse{}), nil
+	return &pb.ConnectPeerResponse{}, nil
 }
 
-func (h *Handler) ForgetPeer(ctx context.Context, req *connect.Request[pb.ForgetPeerRequest]) (*connect.Response[pb.ForgetPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "forget_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ForgetPeer(ctx context.Context, req *pb.ForgetPeerRequest) (*pb.ForgetPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "forget_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ForgetPeerResponse{}), nil
+	return &pb.ForgetPeerResponse{}, nil
 }
 
-func (h *Handler) ListPeers(ctx context.Context, req *connect.Request[pb.ListPeersRequest]) (*connect.Response[pb.ListPeersResponse], error) {
+func (h *Handler) ListPeers(ctx context.Context, req *pb.ListPeersRequest) (*pb.ListPeersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_peers", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListPeersResponse{PeersJson: string(raw)}), nil
+	return &pb.ListPeersResponse{PeersJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBlock(ctx context.Context, req *connect.Request[pb.GetBlockRequest]) (*connect.Response[pb.GetBlockResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Msg.Hash})
+func (h *Handler) GetBlock(ctx context.Context, req *pb.GetBlockRequest) (*pb.GetBlockResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Hash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockResponse{BlockJson: string(raw)}), nil
+	return &pb.GetBlockResponse{BlockJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestMainchainBlockHashRequest]) (*connect.Response[pb.GetBestMainchainBlockHashResponse], error) {
+func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *pb.GetBestMainchainBlockHashRequest) (*pb.GetBestMainchainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_mainchain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestMainchainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestMainchainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestSidechainBlockHashRequest]) (*connect.Response[pb.GetBestSidechainBlockHashResponse], error) {
+func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *pb.GetBestSidechainBlockHashRequest) (*pb.GetBestSidechainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_sidechain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestSidechainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestSidechainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBmmInclusions(ctx context.Context, req *connect.Request[pb.GetBmmInclusionsRequest]) (*connect.Response[pb.GetBmmInclusionsResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.Msg.BlockHash})
+func (h *Handler) GetBmmInclusions(ctx context.Context, req *pb.GetBmmInclusionsRequest) (*pb.GetBmmInclusionsResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.BlockHash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmInclusionsResponse{Inclusions: string(raw)}), nil
+	return &pb.GetBmmInclusionsResponse{Inclusions: string(raw)}, nil
 }
 
-func (h *Handler) GenerateMnemonic(ctx context.Context, req *connect.Request[pb.GenerateMnemonicRequest]) (*connect.Response[pb.GenerateMnemonicResponse], error) {
+func (h *Handler) GenerateMnemonic(ctx context.Context, req *pb.GenerateMnemonicRequest) (*pb.GenerateMnemonicResponse, error) {
 	var mnemonic string
 	if err := h.proxy.Client.Call(ctx, "generate_mnemonic", nil, &mnemonic); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GenerateMnemonicResponse{Mnemonic: mnemonic}), nil
+	return &pb.GenerateMnemonicResponse{Mnemonic: mnemonic}, nil
 }
 
-func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[pb.SetSeedFromMnemonicRequest]) (*connect.Response[pb.SetSeedFromMnemonicResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Msg.Mnemonic}, nil); err != nil {
+func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *pb.SetSeedFromMnemonicRequest) (*pb.SetSeedFromMnemonicResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Mnemonic}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SetSeedFromMnemonicResponse{}), nil
+	return &pb.SetSeedFromMnemonicResponse{}, nil
 }
 
-func (h *Handler) GetBitAssetData(ctx context.Context, req *connect.Request[pb.GetBitAssetDataRequest]) (*connect.Response[pb.GetBitAssetDataResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "bitasset_data", []any{req.Msg.AssetId})
+func (h *Handler) GetBitAssetData(ctx context.Context, req *pb.GetBitAssetDataRequest) (*pb.GetBitAssetDataResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "bitasset_data", []any{req.AssetId})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBitAssetDataResponse{DataJson: string(raw)}), nil
+	return &pb.GetBitAssetDataResponse{DataJson: string(raw)}, nil
 }
 
-func (h *Handler) ListBitAssets(ctx context.Context, req *connect.Request[pb.ListBitAssetsRequest]) (*connect.Response[pb.ListBitAssetsResponse], error) {
+func (h *Handler) ListBitAssets(ctx context.Context, req *pb.ListBitAssetsRequest) (*pb.ListBitAssetsResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "bitassets", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListBitAssetsResponse{BitassetsJson: string(raw)}), nil
+	return &pb.ListBitAssetsResponse{BitassetsJson: string(raw)}, nil
 }
 
-func (h *Handler) RegisterBitAsset(ctx context.Context, req *connect.Request[pb.RegisterBitAssetRequest]) (*connect.Response[pb.RegisterBitAssetResponse], error) {
+func (h *Handler) RegisterBitAsset(ctx context.Context, req *pb.RegisterBitAssetRequest) (*pb.RegisterBitAssetResponse, error) {
 	var data any
-	if req.Msg.DataJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.DataJson), &data); err != nil {
+	if req.DataJson != "" {
+		if err := json.Unmarshal([]byte(req.DataJson), &data); err != nil {
 			return nil, fmt.Errorf("unmarshal data: %w", err)
 		}
 	}
 	var txid string
-	params := []any{req.Msg.PlaintextName, req.Msg.InitialSupply, data}
+	params := []any{req.PlaintextName, req.InitialSupply, data}
 	if err := h.proxy.Client.Call(ctx, "register_bitasset", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RegisterBitAssetResponse{Txid: txid}), nil
+	return &pb.RegisterBitAssetResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ReserveBitAsset(ctx context.Context, req *connect.Request[pb.ReserveBitAssetRequest]) (*connect.Response[pb.ReserveBitAssetResponse], error) {
+func (h *Handler) ReserveBitAsset(ctx context.Context, req *pb.ReserveBitAssetRequest) (*pb.ReserveBitAssetResponse, error) {
 	var txid string
-	if err := h.proxy.Client.Call(ctx, "reserve_bitasset", []any{req.Msg.Name}, &txid); err != nil {
+	if err := h.proxy.Client.Call(ctx, "reserve_bitasset", []any{req.Name}, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ReserveBitAssetResponse{Txid: txid}), nil
+	return &pb.ReserveBitAssetResponse{Txid: txid}, nil
 }
 
-func (h *Handler) TransferBitAsset(ctx context.Context, req *connect.Request[pb.TransferBitAssetRequest]) (*connect.Response[pb.TransferBitAssetResponse], error) {
+func (h *Handler) TransferBitAsset(ctx context.Context, req *pb.TransferBitAssetRequest) (*pb.TransferBitAssetResponse, error) {
 	var txid string
 	// BitAssets transfer_bitasset accepts [dest, asset_id, amount, fee_sats, memo]
-	params := []any{req.Msg.Dest, req.Msg.AssetId, req.Msg.Amount, req.Msg.FeeSats, nil}
+	params := []any{req.Dest, req.AssetId, req.Amount, req.FeeSats, nil}
 	if err := h.proxy.Client.Call(ctx, "transfer_bitasset", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferBitAssetResponse{Txid: txid}), nil
+	return &pb.TransferBitAssetResponse{Txid: txid}, nil
 }
 
-func (h *Handler) GetNewEncryptionKey(ctx context.Context, req *connect.Request[pb.GetNewEncryptionKeyRequest]) (*connect.Response[pb.GetNewEncryptionKeyResponse], error) {
+func (h *Handler) GetNewEncryptionKey(ctx context.Context, req *pb.GetNewEncryptionKeyRequest) (*pb.GetNewEncryptionKeyResponse, error) {
 	var key string
 	if err := h.proxy.Client.Call(ctx, "get_new_encryption_key", nil, &key); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewEncryptionKeyResponse{Key: key}), nil
+	return &pb.GetNewEncryptionKeyResponse{Key: key}, nil
 }
 
-func (h *Handler) GetNewVerifyingKey(ctx context.Context, req *connect.Request[pb.GetNewVerifyingKeyRequest]) (*connect.Response[pb.GetNewVerifyingKeyResponse], error) {
+func (h *Handler) GetNewVerifyingKey(ctx context.Context, req *pb.GetNewVerifyingKeyRequest) (*pb.GetNewVerifyingKeyResponse, error) {
 	var key string
 	if err := h.proxy.Client.Call(ctx, "get_new_verifying_key", nil, &key); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewVerifyingKeyResponse{Key: key}), nil
+	return &pb.GetNewVerifyingKeyResponse{Key: key}, nil
 }
 
-func (h *Handler) DecryptMsg(ctx context.Context, req *connect.Request[pb.DecryptMsgRequest]) (*connect.Response[pb.DecryptMsgResponse], error) {
+func (h *Handler) DecryptMsg(ctx context.Context, req *pb.DecryptMsgRequest) (*pb.DecryptMsgResponse, error) {
 	var plaintext string
-	params := []any{req.Msg.EncryptionPubkey, req.Msg.Ciphertext}
+	params := []any{req.EncryptionPubkey, req.Ciphertext}
 	if err := h.proxy.Client.Call(ctx, "decrypt_msg", params, &plaintext); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.DecryptMsgResponse{Plaintext: plaintext}), nil
+	return &pb.DecryptMsgResponse{Plaintext: plaintext}, nil
 }
 
-func (h *Handler) EncryptMsg(ctx context.Context, req *connect.Request[pb.EncryptMsgRequest]) (*connect.Response[pb.EncryptMsgResponse], error) {
+func (h *Handler) EncryptMsg(ctx context.Context, req *pb.EncryptMsgRequest) (*pb.EncryptMsgResponse, error) {
 	var ciphertext string
-	params := []any{req.Msg.EncryptionPubkey, req.Msg.Msg}
+	params := []any{req.EncryptionPubkey, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "encrypt_msg", params, &ciphertext); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.EncryptMsgResponse{Ciphertext: ciphertext}), nil
+	return &pb.EncryptMsgResponse{Ciphertext: ciphertext}, nil
 }
 
-func (h *Handler) SignArbitraryMsg(ctx context.Context, req *connect.Request[pb.SignArbitraryMsgRequest]) (*connect.Response[pb.SignArbitraryMsgResponse], error) {
+func (h *Handler) SignArbitraryMsg(ctx context.Context, req *pb.SignArbitraryMsgRequest) (*pb.SignArbitraryMsgResponse, error) {
 	var signature string
-	params := []any{req.Msg.VerifyingKey, req.Msg.Msg}
+	params := []any{req.VerifyingKey, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "sign_arbitrary_msg", params, &signature); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SignArbitraryMsgResponse{Signature: signature}), nil
+	return &pb.SignArbitraryMsgResponse{Signature: signature}, nil
 }
 
-func (h *Handler) SignArbitraryMsgAsAddr(ctx context.Context, req *connect.Request[pb.SignArbitraryMsgAsAddrRequest]) (*connect.Response[pb.SignArbitraryMsgAsAddrResponse], error) {
+func (h *Handler) SignArbitraryMsgAsAddr(ctx context.Context, req *pb.SignArbitraryMsgAsAddrRequest) (*pb.SignArbitraryMsgAsAddrResponse, error) {
 	var result struct {
 		VerifyingKey string `json:"verifying_key"`
 		Signature    string `json:"signature"`
 	}
-	params := []any{req.Msg.Address, req.Msg.Msg}
+	params := []any{req.Address, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "sign_arbitrary_msg_as_addr", params, &result); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SignArbitraryMsgAsAddrResponse{
+	return &pb.SignArbitraryMsgAsAddrResponse{
 		VerifyingKey: result.VerifyingKey,
 		Signature:    result.Signature,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) VerifySignature(ctx context.Context, req *connect.Request[pb.VerifySignatureRequest]) (*connect.Response[pb.VerifySignatureResponse], error) {
+func (h *Handler) VerifySignature(ctx context.Context, req *pb.VerifySignatureRequest) (*pb.VerifySignatureResponse, error) {
 	var valid bool
 	// The sign_arbitrary_msg methods sign with the arbitrary dst.
-	params := []any{req.Msg.Signature, req.Msg.VerifyingKey, "arbitrary", req.Msg.Msg}
+	params := []any{req.Signature, req.VerifyingKey, "arbitrary", req.Msg}
 	if err := h.proxy.Client.Call(ctx, "verify_signature", params, &valid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VerifySignatureResponse{Valid: valid}), nil
+	return &pb.VerifySignatureResponse{Valid: valid}, nil
 }
 
-func (h *Handler) GetWalletAddresses(ctx context.Context, req *connect.Request[pb.GetWalletAddressesRequest]) (*connect.Response[pb.GetWalletAddressesResponse], error) {
+func (h *Handler) GetWalletAddresses(ctx context.Context, req *pb.GetWalletAddressesRequest) (*pb.GetWalletAddressesResponse, error) {
 	var addresses []string
 	if err := h.proxy.Client.Call(ctx, "get_wallet_addresses", nil, &addresses); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletAddressesResponse{Addresses: addresses}), nil
+	return &pb.GetWalletAddressesResponse{Addresses: addresses}, nil
 }
 
-func (h *Handler) MyUnconfirmedUtxos(ctx context.Context, req *connect.Request[pb.MyUnconfirmedUtxosRequest]) (*connect.Response[pb.MyUnconfirmedUtxosResponse], error) {
+func (h *Handler) MyUnconfirmedUtxos(ctx context.Context, req *pb.MyUnconfirmedUtxosRequest) (*pb.MyUnconfirmedUtxosResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "my_unconfirmed_utxos", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MyUnconfirmedUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.MyUnconfirmedUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) OpenapiSchema(ctx context.Context, req *connect.Request[pb.OpenapiSchemaRequest]) (*connect.Response[pb.OpenapiSchemaResponse], error) {
+func (h *Handler) OpenapiSchema(ctx context.Context, req *pb.OpenapiSchemaRequest) (*pb.OpenapiSchemaResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "openapi_schema", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.OpenapiSchemaResponse{SchemaJson: string(raw)}), nil
+	return &pb.OpenapiSchemaResponse{SchemaJson: string(raw)}, nil
 }
 
 // --- AMM methods ---
 
-func (h *Handler) AmmBurn(ctx context.Context, req *connect.Request[pb.AmmBurnRequest]) (*connect.Response[pb.AmmBurnResponse], error) {
+func (h *Handler) AmmBurn(ctx context.Context, req *pb.AmmBurnRequest) (*pb.AmmBurnResponse, error) {
 	var txid string
-	params := []any{req.Msg.Asset0, req.Msg.Asset1, req.Msg.LpTokenAmount}
+	params := []any{req.Asset0, req.Asset1, req.LpTokenAmount}
 	if err := h.proxy.Client.Call(ctx, "amm_burn", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.AmmBurnResponse{Txid: txid}), nil
+	return &pb.AmmBurnResponse{Txid: txid}, nil
 }
 
-func (h *Handler) AmmMint(ctx context.Context, req *connect.Request[pb.AmmMintRequest]) (*connect.Response[pb.AmmMintResponse], error) {
+func (h *Handler) AmmMint(ctx context.Context, req *pb.AmmMintRequest) (*pb.AmmMintResponse, error) {
 	var txid string
-	params := []any{req.Msg.Asset0, req.Msg.Asset1, req.Msg.Amount0, req.Msg.Amount1}
+	params := []any{req.Asset0, req.Asset1, req.Amount0, req.Amount1}
 	if err := h.proxy.Client.Call(ctx, "amm_mint", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.AmmMintResponse{Txid: txid}), nil
+	return &pb.AmmMintResponse{Txid: txid}, nil
 }
 
-func (h *Handler) AmmSwap(ctx context.Context, req *connect.Request[pb.AmmSwapRequest]) (*connect.Response[pb.AmmSwapResponse], error) {
+func (h *Handler) AmmSwap(ctx context.Context, req *pb.AmmSwapRequest) (*pb.AmmSwapResponse, error) {
 	var amountReceive int64
-	params := []any{req.Msg.AssetSpend, req.Msg.AssetReceive, req.Msg.AmountSpend}
+	params := []any{req.AssetSpend, req.AssetReceive, req.AmountSpend}
 	if err := h.proxy.Client.Call(ctx, "amm_swap", params, &amountReceive); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.AmmSwapResponse{AmountReceive: amountReceive}), nil
+	return &pb.AmmSwapResponse{AmountReceive: amountReceive}, nil
 }
 
-func (h *Handler) GetAmmPoolState(ctx context.Context, req *connect.Request[pb.GetAmmPoolStateRequest]) (*connect.Response[pb.GetAmmPoolStateResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_amm_pool_state", []any{req.Msg.Asset0, req.Msg.Asset1})
+func (h *Handler) GetAmmPoolState(ctx context.Context, req *pb.GetAmmPoolStateRequest) (*pb.GetAmmPoolStateResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_amm_pool_state", []any{req.Asset0, req.Asset1})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetAmmPoolStateResponse{PoolStateJson: string(raw)}), nil
+	return &pb.GetAmmPoolStateResponse{PoolStateJson: string(raw)}, nil
 }
 
-func (h *Handler) GetAmmPrice(ctx context.Context, req *connect.Request[pb.GetAmmPriceRequest]) (*connect.Response[pb.GetAmmPriceResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_amm_price", []any{req.Msg.Base, req.Msg.Quote})
+func (h *Handler) GetAmmPrice(ctx context.Context, req *pb.GetAmmPriceRequest) (*pb.GetAmmPriceResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_amm_price", []any{req.Base, req.Quote})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetAmmPriceResponse{PriceJson: string(raw)}), nil
+	return &pb.GetAmmPriceResponse{PriceJson: string(raw)}, nil
 }
 
 // --- Dutch Auction methods ---
 
-func (h *Handler) DutchAuctionBid(ctx context.Context, req *connect.Request[pb.DutchAuctionBidRequest]) (*connect.Response[pb.DutchAuctionBidResponse], error) {
+func (h *Handler) DutchAuctionBid(ctx context.Context, req *pb.DutchAuctionBidRequest) (*pb.DutchAuctionBidResponse, error) {
 	var baseAmount int64
-	params := []any{req.Msg.DutchAuctionId, req.Msg.BidSize}
+	params := []any{req.DutchAuctionId, req.BidSize}
 	if err := h.proxy.Client.Call(ctx, "dutch_auction_bid", params, &baseAmount); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.DutchAuctionBidResponse{BaseAmount: baseAmount}), nil
+	return &pb.DutchAuctionBidResponse{BaseAmount: baseAmount}, nil
 }
 
-func (h *Handler) DutchAuctionCollect(ctx context.Context, req *connect.Request[pb.DutchAuctionCollectRequest]) (*connect.Response[pb.DutchAuctionCollectResponse], error) {
+func (h *Handler) DutchAuctionCollect(ctx context.Context, req *pb.DutchAuctionCollectRequest) (*pb.DutchAuctionCollectResponse, error) {
 	var result []int64
-	if err := h.proxy.Client.Call(ctx, "dutch_auction_collect", []any{req.Msg.DutchAuctionId}, &result); err != nil {
+	if err := h.proxy.Client.Call(ctx, "dutch_auction_collect", []any{req.DutchAuctionId}, &result); err != nil {
 		return nil, err
 	}
 	resp := &pb.DutchAuctionCollectResponse{}
@@ -456,30 +454,30 @@ func (h *Handler) DutchAuctionCollect(ctx context.Context, req *connect.Request[
 	if len(result) >= 2 {
 		resp.QuoteAmount = result[1]
 	}
-	return connect.NewResponse(resp), nil
+	return resp, nil
 }
 
-func (h *Handler) DutchAuctionCreate(ctx context.Context, req *connect.Request[pb.DutchAuctionCreateRequest]) (*connect.Response[pb.DutchAuctionCreateResponse], error) {
+func (h *Handler) DutchAuctionCreate(ctx context.Context, req *pb.DutchAuctionCreateRequest) (*pb.DutchAuctionCreateResponse, error) {
 	var txid string
 	params := []any{
-		req.Msg.StartBlock,
-		req.Msg.Duration,
-		req.Msg.BaseAsset,
-		req.Msg.BaseAmount,
-		req.Msg.QuoteAsset,
-		req.Msg.InitialPrice,
-		req.Msg.FinalPrice,
+		req.StartBlock,
+		req.Duration,
+		req.BaseAsset,
+		req.BaseAmount,
+		req.QuoteAsset,
+		req.InitialPrice,
+		req.FinalPrice,
 	}
 	if err := h.proxy.Client.Call(ctx, "dutch_auction_create", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.DutchAuctionCreateResponse{Txid: txid}), nil
+	return &pb.DutchAuctionCreateResponse{Txid: txid}, nil
 }
 
-func (h *Handler) DutchAuctions(ctx context.Context, req *connect.Request[pb.DutchAuctionsRequest]) (*connect.Response[pb.DutchAuctionsResponse], error) {
+func (h *Handler) DutchAuctions(ctx context.Context, req *pb.DutchAuctionsRequest) (*pb.DutchAuctionsResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "dutch_auctions", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.DutchAuctionsResponse{AuctionsJson: string(raw)}), nil
+	return &pb.DutchAuctionsResponse{AuctionsJson: string(raw)}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/bitassets/message_test.go b/sidechain-orchestrator/sidechain/bitassets/message_test.go
new file mode 100644
index 0000000000..31355f4a4f
--- /dev/null
+++ b/sidechain-orchestrator/sidechain/bitassets/message_test.go
@@ -0,0 +1,21 @@
+package bitassets
+
+import (
+	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitassets/v1"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestHandlerSendsTheMessage(t *testing.T) {
+	proxy, params := paramsNode(t, `null`)
+	h := NewHandler(proxy)
+	_, err := h.EncryptMsg(t.Context(), &pb.EncryptMsgRequest{EncryptionPubkey: "key", Msg: "the message"})
+	require.NoError(t, err)
+	require.Equal(t, []any{"key", "the message"}, *params)
+	_, err = h.SignArbitraryMsg(t.Context(), &pb.SignArbitraryMsgRequest{VerifyingKey: "key", Msg: "the message"})
+	require.NoError(t, err)
+	require.Equal(t, []any{"key", "the message"}, *params)
+	_, err = h.SignArbitraryMsgAsAddr(t.Context(), &pb.SignArbitraryMsgAsAddrRequest{Address: "address", Msg: "the message"})
+	require.NoError(t, err)
+	require.Equal(t, []any{"address", "the message"}, *params)
+}
diff --git a/sidechain-orchestrator/sidechain/bitassets/transfer_bitasset_test.go b/sidechain-orchestrator/sidechain/bitassets/transfer_bitasset_test.go
index 28fb5b5c4c..6ef375fa55 100644
--- a/sidechain-orchestrator/sidechain/bitassets/transfer_bitasset_test.go
+++ b/sidechain-orchestrator/sidechain/bitassets/transfer_bitasset_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -45,14 +44,14 @@ func TestTransferBitAssetSendsDestBeforeAssetID(t *testing.T) {
 	proxy, params := paramsNode(t, `"e3b0c44298fc1c149afbf4c8996fb924"`)
 
 	resp, err := NewHandler(proxy).TransferBitAsset(context.Background(),
-		connect.NewRequest(&pb.TransferBitAssetRequest{
+		&pb.TransferBitAssetRequest{
 			AssetId: "d228dfbdab4f8a9eb5eb4962ab38f4364b0b8b3035ce41eafd91ff672a6c6076",
 			Dest:    "3w3mR6SMpc3irb7etdJbDu5rLyLv",
 			Amount:  7000000,
 			FeeSats: 1000,
-		}))
+		})
 	require.NoError(t, err)
-	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb924", resp.Msg.Txid)
+	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb924", resp.Txid)
 
 	assert.Equal(t, []any{
 		"3w3mR6SMpc3irb7etdJbDu5rLyLv",
@@ -68,13 +67,13 @@ func TestVerifySignatureSendsSignatureFirst(t *testing.T) {
 	proxy, params := paramsNode(t, `true`)
 
 	resp, err := NewHandler(proxy).VerifySignature(context.Background(),
-		connect.NewRequest(&pb.VerifySignatureRequest{
+		&pb.VerifySignatureRequest{
 			Msg:          "the message",
 			Signature:    "0xsig",
 			VerifyingKey: "ba-svk1key",
-		}))
+		})
 	require.NoError(t, err)
-	assert.True(t, resp.Msg.Valid)
+	assert.True(t, resp.Valid)
 
 	assert.Equal(t, []any{"0xsig", "ba-svk1key", "arbitrary", "the message"}, *params)
 }
diff --git a/sidechain-orchestrator/sidechain/bitassets/wealth_method_test.go b/sidechain-orchestrator/sidechain/bitassets/wealth_method_test.go
index f129bcf860..2368421115 100644
--- a/sidechain-orchestrator/sidechain/bitassets/wealth_method_test.go
+++ b/sidechain-orchestrator/sidechain/bitassets/wealth_method_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -47,8 +46,8 @@ func TestSidechainWealthCallsSidechainWealth(t *testing.T) {
 	proxy, seen := wealthNode(t, "10603007000")
 
 	resp, err := NewHandler(proxy).GetSidechainWealth(context.Background(),
-		connect.NewRequest(&pb.GetSidechainWealthRequest{}))
+		&pb.GetSidechainWealthRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, int64(10603007000), resp.Msg.Sats)
+	assert.Equal(t, int64(10603007000), resp.Sats)
 	assert.Equal(t, []string{"sidechain_wealth"}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain/bitnames/handler.go b/sidechain-orchestrator/sidechain/bitnames/handler.go
index 847ee1f75f..480ead6c08 100644
--- a/sidechain-orchestrator/sidechain/bitnames/handler.go
+++ b/sidechain-orchestrator/sidechain/bitnames/handler.go
@@ -7,7 +7,7 @@ import (
 	"fmt"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitnames/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitnames/v1/bitnamesv1connect"
@@ -35,54 +35,54 @@ func (h *Handler) WalletBalance(ctx context.Context) (total, available int64, er
 
 // --- Common Node methods ---
 
-func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *Handler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	total, available, err := h.WalletBalance(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		TotalSats:     total,
 		AvailableSats: available,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, req *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, req *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.proxy.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, req *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, req *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.proxy.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
 
-func (h *Handler) GetNewAddress(ctx context.Context, req *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *Handler) GetNewAddress(ctx context.Context, req *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	address, err := h.proxy.GetNewAddress(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewAddressResponse{Address: address}), nil
+	return &pb.GetNewAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) Withdraw(ctx context.Context, req *connect.Request[pb.WithdrawRequest]) (*connect.Response[pb.WithdrawResponse], error) {
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.SideFeeSats, req.Msg.MainFeeSats}
+func (h *Handler) Withdraw(ctx context.Context, req *pb.WithdrawRequest) (*pb.WithdrawResponse, error) {
+	params := []any{req.Address, req.AmountSats, req.SideFeeSats, req.MainFeeSats}
 	var txid string
 	if err := h.proxy.Client.Call(ctx, "create_withdrawal", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.WithdrawResponse{Txid: txid}), nil
+	return &pb.WithdrawResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.TransferRequest]) (*connect.Response[pb.TransferResponse], error) {
+func (h *Handler) Transfer(ctx context.Context, req *pb.TransferRequest) (*pb.TransferResponse, error) {
 	// create_transfer takes a 4th memo parameter here.
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats}
-	if req.Msg.Memo != nil {
-		params = append(params, *req.Msg.Memo)
+	params := []any{req.Address, req.AmountSats, req.FeeSats}
+	if req.Memo != nil {
+		params = append(params, *req.Memo)
 	} else {
 		params = append(params, nil)
 	}
@@ -90,157 +90,157 @@ func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.Transfer
 	if err := h.proxy.Client.Call(ctx, "create_transfer", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferResponse{Txid: txid}), nil
+	return &pb.TransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Mine(ctx context.Context, req *connect.Request[pb.MineRequest]) (*connect.Response[pb.MineResponse], error) {
-	raw, err := h.proxy.Mine(ctx, req.Msg.FeeSats)
+func (h *Handler) Mine(ctx context.Context, req *pb.MineRequest) (*pb.MineResponse, error) {
+	raw, err := h.proxy.Mine(ctx, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MineResponse{BmmResultJson: string(raw)}), nil
+	return &pb.MineResponse{BmmResultJson: string(raw)}, nil
 }
 
-func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[pb.GetPendingWithdrawalBundleRequest]) (*connect.Response[pb.GetPendingWithdrawalBundleResponse], error) {
+func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *pb.GetPendingWithdrawalBundleRequest) (*pb.GetPendingWithdrawalBundleResponse, error) {
 	raw, err := h.proxy.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}), nil
+	return &pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.GetWalletUtxosRequest]) (*connect.Response[pb.GetWalletUtxosResponse], error) {
+func (h *Handler) GetWalletUtxos(ctx context.Context, req *pb.GetWalletUtxosRequest) (*pb.GetWalletUtxosResponse, error) {
 	raw, err := h.proxy.GetWalletUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.GetWalletUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, req *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, req *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	raw, err := h.proxy.ListUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.ListUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[pb.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[pb.GetLatestFailedWithdrawalBundleHeightResponse], error) {
+func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *pb.GetLatestFailedWithdrawalBundleHeightRequest) (*pb.GetLatestFailedWithdrawalBundleHeightResponse, error) {
 	height, err := h.proxy.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}), nil
+	return &pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}, nil
 }
 
-func (h *Handler) CallRaw(ctx context.Context, req *connect.Request[pb.CallRawRequest]) (*connect.Response[pb.CallRawResponse], error) {
+func (h *Handler) CallRaw(ctx context.Context, req *pb.CallRawRequest) (*pb.CallRawResponse, error) {
 	var params any
-	if req.Msg.ParamsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.ParamsJson), &params); err != nil {
+	if req.ParamsJson != "" {
+		if err := json.Unmarshal([]byte(req.ParamsJson), &params); err != nil {
 			return nil, fmt.Errorf("unmarshal params: %w", err)
 		}
 	}
-	raw, err := h.proxy.CallRaw(ctx, req.Msg.Method, params)
+	raw, err := h.proxy.CallRaw(ctx, req.Method, params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CallRawResponse{ResultJson: string(raw)}), nil
+	return &pb.CallRawResponse{ResultJson: string(raw)}, nil
 }
 
 // --- BitNames-specific methods ---
 
-func (h *Handler) GetSidechainWealth(ctx context.Context, req *connect.Request[pb.GetSidechainWealthRequest]) (*connect.Response[pb.GetSidechainWealthResponse], error) {
+func (h *Handler) GetSidechainWealth(ctx context.Context, req *pb.GetSidechainWealthRequest) (*pb.GetSidechainWealthResponse, error) {
 	var sats int64
 	if err := h.proxy.Client.Call(ctx, "sidechain_wealth", nil, &sats); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainWealthResponse{Sats: sats}), nil
+	return &pb.GetSidechainWealthResponse{Sats: sats}, nil
 }
 
-func (h *Handler) CreateDeposit(ctx context.Context, req *connect.Request[pb.CreateDepositRequest]) (*connect.Response[pb.CreateDepositResponse], error) {
+func (h *Handler) CreateDeposit(ctx context.Context, req *pb.CreateDepositRequest) (*pb.CreateDepositResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.ValueSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.ValueSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_deposit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CreateDepositResponse{Txid: txid}), nil
+	return &pb.CreateDepositResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ConnectPeer(ctx context.Context, req *connect.Request[pb.ConnectPeerRequest]) (*connect.Response[pb.ConnectPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ConnectPeer(ctx context.Context, req *pb.ConnectPeerRequest) (*pb.ConnectPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ConnectPeerResponse{}), nil
+	return &pb.ConnectPeerResponse{}, nil
 }
 
-func (h *Handler) ListPeers(ctx context.Context, req *connect.Request[pb.ListPeersRequest]) (*connect.Response[pb.ListPeersResponse], error) {
+func (h *Handler) ListPeers(ctx context.Context, req *pb.ListPeersRequest) (*pb.ListPeersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_peers", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListPeersResponse{PeersJson: string(raw)}), nil
+	return &pb.ListPeersResponse{PeersJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBlock(ctx context.Context, req *connect.Request[pb.GetBlockRequest]) (*connect.Response[pb.GetBlockResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Msg.Hash})
+func (h *Handler) GetBlock(ctx context.Context, req *pb.GetBlockRequest) (*pb.GetBlockResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Hash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockResponse{BlockJson: string(raw)}), nil
+	return &pb.GetBlockResponse{BlockJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestMainchainBlockHashRequest]) (*connect.Response[pb.GetBestMainchainBlockHashResponse], error) {
+func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *pb.GetBestMainchainBlockHashRequest) (*pb.GetBestMainchainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_mainchain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestMainchainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestMainchainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestSidechainBlockHashRequest]) (*connect.Response[pb.GetBestSidechainBlockHashResponse], error) {
+func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *pb.GetBestSidechainBlockHashRequest) (*pb.GetBestSidechainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_sidechain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestSidechainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestSidechainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBmmInclusions(ctx context.Context, req *connect.Request[pb.GetBmmInclusionsRequest]) (*connect.Response[pb.GetBmmInclusionsResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.Msg.BlockHash})
+func (h *Handler) GetBmmInclusions(ctx context.Context, req *pb.GetBmmInclusionsRequest) (*pb.GetBmmInclusionsResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.BlockHash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmInclusionsResponse{Inclusions: string(raw)}), nil
+	return &pb.GetBmmInclusionsResponse{Inclusions: string(raw)}, nil
 }
 
-func (h *Handler) GenerateMnemonic(ctx context.Context, req *connect.Request[pb.GenerateMnemonicRequest]) (*connect.Response[pb.GenerateMnemonicResponse], error) {
+func (h *Handler) GenerateMnemonic(ctx context.Context, req *pb.GenerateMnemonicRequest) (*pb.GenerateMnemonicResponse, error) {
 	var mnemonic string
 	if err := h.proxy.Client.Call(ctx, "generate_mnemonic", nil, &mnemonic); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GenerateMnemonicResponse{Mnemonic: mnemonic}), nil
+	return &pb.GenerateMnemonicResponse{Mnemonic: mnemonic}, nil
 }
 
-func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[pb.SetSeedFromMnemonicRequest]) (*connect.Response[pb.SetSeedFromMnemonicResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Msg.Mnemonic}, nil); err != nil {
+func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *pb.SetSeedFromMnemonicRequest) (*pb.SetSeedFromMnemonicResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Mnemonic}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SetSeedFromMnemonicResponse{}), nil
+	return &pb.SetSeedFromMnemonicResponse{}, nil
 }
 
-func (h *Handler) GetBitNameData(ctx context.Context, req *connect.Request[pb.GetBitNameDataRequest]) (*connect.Response[pb.GetBitNameDataResponse], error) {
+func (h *Handler) GetBitNameData(ctx context.Context, req *pb.GetBitNameDataRequest) (*pb.GetBitNameDataResponse, error) {
 	var details nodeBitnameDetails
-	if err := h.proxy.Client.Call(ctx, "bitname_data", []any{req.Msg.Name}, &details); err != nil {
+	if err := h.proxy.Client.Call(ctx, "bitname_data", []any{req.Name}, &details); err != nil {
 		return nil, err
 	}
 	raw, err := json.Marshal(details.toClient())
 	if err != nil {
 		return nil, fmt.Errorf("marshal bitname data: %w", err)
 	}
-	return connect.NewResponse(&pb.GetBitNameDataResponse{DataJson: string(raw)}), nil
+	return &pb.GetBitNameDataResponse{DataJson: string(raw)}, nil
 }
 
-func (h *Handler) ListBitNames(ctx context.Context, req *connect.Request[pb.ListBitNamesRequest]) (*connect.Response[pb.ListBitNamesResponse], error) {
+func (h *Handler) ListBitNames(ctx context.Context, req *pb.ListBitNamesRequest) (*pb.ListBitNamesResponse, error) {
 	var entries []nodeBitnameEntry
 	if err := h.proxy.Client.Call(ctx, "bitnames", nil, &entries); err != nil {
 		return nil, err
@@ -253,98 +253,98 @@ func (h *Handler) ListBitNames(ctx context.Context, req *connect.Request[pb.List
 	if err != nil {
 		return nil, fmt.Errorf("marshal bitnames: %w", err)
 	}
-	return connect.NewResponse(&pb.ListBitNamesResponse{BitnamesJson: string(raw)}), nil
+	return &pb.ListBitNamesResponse{BitnamesJson: string(raw)}, nil
 }
 
-func (h *Handler) RegisterBitName(ctx context.Context, req *connect.Request[pb.RegisterBitNameRequest]) (*connect.Response[pb.RegisterBitNameResponse], error) {
+func (h *Handler) RegisterBitName(ctx context.Context, req *pb.RegisterBitNameRequest) (*pb.RegisterBitNameResponse, error) {
 	var data any
-	if req.Msg.DataJson != "" {
+	if req.DataJson != "" {
 		var client BitNameData
-		if err := json.Unmarshal([]byte(req.Msg.DataJson), &client); err != nil {
+		if err := json.Unmarshal([]byte(req.DataJson), &client); err != nil {
 			return nil, fmt.Errorf("unmarshal data: %w", err)
 		}
 		node, err := client.toNode()
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 		data = node
 	}
 	var txid string
-	params := []any{req.Msg.PlainName, data}
+	params := []any{req.PlainName, data}
 	if err := h.proxy.Client.Call(ctx, "register_bitname", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RegisterBitNameResponse{Txid: txid}), nil
+	return &pb.RegisterBitNameResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ReserveBitName(ctx context.Context, req *connect.Request[pb.ReserveBitNameRequest]) (*connect.Response[pb.ReserveBitNameResponse], error) {
+func (h *Handler) ReserveBitName(ctx context.Context, req *pb.ReserveBitNameRequest) (*pb.ReserveBitNameResponse, error) {
 	var txid string
-	if err := h.proxy.Client.Call(ctx, "reserve_bitname", []any{req.Msg.Name}, &txid); err != nil {
+	if err := h.proxy.Client.Call(ctx, "reserve_bitname", []any{req.Name}, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ReserveBitNameResponse{Txid: txid}), nil
+	return &pb.ReserveBitNameResponse{Txid: txid}, nil
 }
 
-func (h *Handler) GetNewEncryptionKey(ctx context.Context, req *connect.Request[pb.GetNewEncryptionKeyRequest]) (*connect.Response[pb.GetNewEncryptionKeyResponse], error) {
+func (h *Handler) GetNewEncryptionKey(ctx context.Context, req *pb.GetNewEncryptionKeyRequest) (*pb.GetNewEncryptionKeyResponse, error) {
 	var key string
 	if err := h.proxy.Client.Call(ctx, "get_new_encryption_key", nil, &key); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewEncryptionKeyResponse{Key: key}), nil
+	return &pb.GetNewEncryptionKeyResponse{Key: key}, nil
 }
 
-func (h *Handler) GetNewVerifyingKey(ctx context.Context, req *connect.Request[pb.GetNewVerifyingKeyRequest]) (*connect.Response[pb.GetNewVerifyingKeyResponse], error) {
+func (h *Handler) GetNewVerifyingKey(ctx context.Context, req *pb.GetNewVerifyingKeyRequest) (*pb.GetNewVerifyingKeyResponse, error) {
 	var key string
 	if err := h.proxy.Client.Call(ctx, "get_new_verifying_key", nil, &key); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewVerifyingKeyResponse{Key: key}), nil
+	return &pb.GetNewVerifyingKeyResponse{Key: key}, nil
 }
 
-func (h *Handler) DecryptMsg(ctx context.Context, req *connect.Request[pb.DecryptMsgRequest]) (*connect.Response[pb.DecryptMsgResponse], error) {
+func (h *Handler) DecryptMsg(ctx context.Context, req *pb.DecryptMsgRequest) (*pb.DecryptMsgResponse, error) {
 	var plaintext string
-	params := []any{req.Msg.EncryptionPubkey, req.Msg.Ciphertext, true}
+	params := []any{req.EncryptionPubkey, req.Ciphertext, true}
 	if err := h.proxy.Client.Call(ctx, "decrypt_msg", params, &plaintext); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.DecryptMsgResponse{Plaintext: plaintext}), nil
+	return &pb.DecryptMsgResponse{Plaintext: plaintext}, nil
 }
 
-func (h *Handler) EncryptMsg(ctx context.Context, req *connect.Request[pb.EncryptMsgRequest]) (*connect.Response[pb.EncryptMsgResponse], error) {
+func (h *Handler) EncryptMsg(ctx context.Context, req *pb.EncryptMsgRequest) (*pb.EncryptMsgResponse, error) {
 	var ciphertext string
-	params := []any{req.Msg.EncryptionPubkey, req.Msg.Msg}
+	params := []any{req.EncryptionPubkey, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "encrypt_msg", params, &ciphertext); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.EncryptMsgResponse{Ciphertext: ciphertext}), nil
+	return &pb.EncryptMsgResponse{Ciphertext: ciphertext}, nil
 }
 
 func (h *Handler) GetBitNameOwner(
-	ctx context.Context, req *connect.Request[pb.GetBitNameOwnerRequest],
-) (*connect.Response[pb.GetBitNameOwnerResponse], error) {
-	address, err := BitNameOwner(ctx, h.proxy.Client, req.Msg.Bitname)
+	ctx context.Context, req *pb.GetBitNameOwnerRequest,
+) (*pb.GetBitNameOwnerResponse, error) {
+	address, err := BitNameOwner(ctx, h.proxy.Client, req.Bitname)
 	if errors.Is(err, errBitNameNotFound) {
-		return nil, connect.NewError(connect.CodeNotFound, err)
+		return nil, connect.NewError(connect.CodeNotFound, err.Error()).WithCause(err)
 	}
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBitNameOwnerResponse{Address: address}), nil
+	return &pb.GetBitNameOwnerResponse{Address: address}, nil
 }
 
 // GetPendingPaymail is not available: the node lists no mempool.
 func (h *Handler) GetPendingPaymail(
-	context.Context, *connect.Request[pb.GetPendingPaymailRequest],
-) (*connect.Response[pb.GetPendingPaymailResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("the bitnames node does not list its mempool"))
+	context.Context, *pb.GetPendingPaymailRequest,
+) (*pb.GetPendingPaymailResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, "the bitnames node does not list its mempool")
 }
 
-func (h *Handler) GetPaymail(ctx context.Context, req *connect.Request[pb.GetPaymailRequest]) (*connect.Response[pb.GetPaymailResponse], error) {
+func (h *Handler) GetPaymail(ctx context.Context, req *pb.GetPaymailRequest) (*pb.GetPaymailResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "get_paymail", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPaymailResponse{PaymailJson: string(raw)}), nil
+	return &pb.GetPaymailResponse{PaymailJson: string(raw)}, nil
 }
 
 // dataServerAddress returns the address to read data from. A resolver reads
@@ -363,98 +363,98 @@ func dataServerAddress(data BitNameData) (string, error) {
 	return "", fmt.Errorf("bitname holds no socket address")
 }
 
-func (h *Handler) ResolveCommit(ctx context.Context, req *connect.Request[pb.ResolveCommitRequest]) (*connect.Response[pb.ResolveCommitResponse], error) {
+func (h *Handler) ResolveCommit(ctx context.Context, req *pb.ResolveCommitRequest) (*pb.ResolveCommitResponse, error) {
 	var details nodeBitnameDetails
-	if err := h.proxy.Client.Call(ctx, "bitname_data", []any{req.Msg.Bitname}, &details); err != nil {
+	if err := h.proxy.Client.Call(ctx, "bitname_data", []any{req.Bitname}, &details); err != nil {
 		return nil, err
 	}
 	data := details.toClient()
 
 	if data.Commitment == nil || *data.Commitment == "" {
-		return nil, connect.NewError(connect.CodeFailedPrecondition,
-			fmt.Errorf("bitname %s holds no commitment", req.Msg.Bitname))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition,
+			"bitname %s holds no commitment", req.Bitname)
 	}
 
 	address, err := dataServerAddress(details.nodeBitNameData.toClient())
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+		return nil, connect.NewError(connect.CodeFailedPrecondition, err.Error()).WithCause(err)
 	}
 
 	raw, digest, err := FetchCommitment(ctx, address)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.ResolveCommitResponse{
+	return &pb.ResolveCommitResponse{
 		Commitment: *data.Commitment,
 		DataJson:   string(raw),
 		// Another client may write the digest in upper case hex.
 		Matches: strings.EqualFold(digest, *data.Commitment),
-	}), nil
+	}, nil
 }
 
-func (h *Handler) ReadCommitment(ctx context.Context, req *connect.Request[pb.ReadCommitmentRequest]) (*connect.Response[pb.ReadCommitmentResponse], error) {
-	if req.Msg.Address == "" {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("address is empty"))
+func (h *Handler) ReadCommitment(ctx context.Context, req *pb.ReadCommitmentRequest) (*pb.ReadCommitmentResponse, error) {
+	if req.Address == "" {
+		return nil, connect.Errorf(connect.CodeInvalidArgument, "address is empty")
 	}
 
-	raw, digest, served, err := FetchCommitmentAt(ctx, req.Msg.Address)
+	raw, digest, served, err := FetchCommitmentAt(ctx, req.Address)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeUnavailable, err)
+		return nil, connect.NewError(connect.CodeUnavailable, err.Error()).WithCause(err)
 	}
 
-	return connect.NewResponse(&pb.ReadCommitmentResponse{
+	return &pb.ReadCommitmentResponse{
 		DataJson:     string(raw),
 		Commitment:   digest,
 		SocketAddrV4: served.V4,
 		SocketAddrV6: served.V6,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) SignArbitraryMsg(ctx context.Context, req *connect.Request[pb.SignArbitraryMsgRequest]) (*connect.Response[pb.SignArbitraryMsgResponse], error) {
+func (h *Handler) SignArbitraryMsg(ctx context.Context, req *pb.SignArbitraryMsgRequest) (*pb.SignArbitraryMsgResponse, error) {
 	var signature string
-	params := []any{req.Msg.VerifyingKey, req.Msg.Msg}
+	params := []any{req.VerifyingKey, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "sign_arbitrary_msg", params, &signature); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SignArbitraryMsgResponse{Signature: signature}), nil
+	return &pb.SignArbitraryMsgResponse{Signature: signature}, nil
 }
 
-func (h *Handler) SignArbitraryMsgAsAddr(ctx context.Context, req *connect.Request[pb.SignArbitraryMsgAsAddrRequest]) (*connect.Response[pb.SignArbitraryMsgAsAddrResponse], error) {
+func (h *Handler) SignArbitraryMsgAsAddr(ctx context.Context, req *pb.SignArbitraryMsgAsAddrRequest) (*pb.SignArbitraryMsgAsAddrResponse, error) {
 	var result struct {
 		VerifyingKey string `json:"verifying_key"`
 		Signature    string `json:"signature"`
 	}
-	params := []any{req.Msg.Address, req.Msg.Msg}
+	params := []any{req.Address, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "sign_arbitrary_msg_as_addr", params, &result); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SignArbitraryMsgAsAddrResponse{
+	return &pb.SignArbitraryMsgAsAddrResponse{
 		VerifyingKey: result.VerifyingKey,
 		Signature:    result.Signature,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetWalletAddresses(ctx context.Context, req *connect.Request[pb.GetWalletAddressesRequest]) (*connect.Response[pb.GetWalletAddressesResponse], error) {
+func (h *Handler) GetWalletAddresses(ctx context.Context, req *pb.GetWalletAddressesRequest) (*pb.GetWalletAddressesResponse, error) {
 	var addresses []string
 	if err := h.proxy.Client.Call(ctx, "get_wallet_addresses", nil, &addresses); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletAddressesResponse{Addresses: addresses}), nil
+	return &pb.GetWalletAddressesResponse{Addresses: addresses}, nil
 }
 
-func (h *Handler) MyUtxos(ctx context.Context, req *connect.Request[pb.MyUtxosRequest]) (*connect.Response[pb.MyUtxosResponse], error) {
+func (h *Handler) MyUtxos(ctx context.Context, req *pb.MyUtxosRequest) (*pb.MyUtxosResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "my_utxos", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MyUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.MyUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) OpenapiSchema(ctx context.Context, req *connect.Request[pb.OpenapiSchemaRequest]) (*connect.Response[pb.OpenapiSchemaResponse], error) {
+func (h *Handler) OpenapiSchema(ctx context.Context, req *pb.OpenapiSchemaRequest) (*pb.OpenapiSchemaResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "openapi_schema", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.OpenapiSchemaResponse{SchemaJson: string(raw)}), nil
+	return &pb.OpenapiSchemaResponse{SchemaJson: string(raw)}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/bitnames/handler_test.go b/sidechain-orchestrator/sidechain/bitnames/handler_test.go
index c8396ea0df..e22b558769 100644
--- a/sidechain-orchestrator/sidechain/bitnames/handler_test.go
+++ b/sidechain-orchestrator/sidechain/bitnames/handler_test.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -45,6 +45,6 @@ func TestDataServerAddressErrorsWithNoAddress(t *testing.T) {
 
 func TestGetPendingPaymailIsUnimplemented(t *testing.T) {
 	_, err := NewHandler(sidechain.NewJSONRPCProxy("127.0.0.1", 1)).GetPendingPaymail(
-		context.Background(), connect.NewRequest(&pb.GetPendingPaymailRequest{}))
+		context.Background(), &pb.GetPendingPaymailRequest{})
 	assert.Equal(t, connect.CodeUnimplemented, connect.CodeOf(err))
 }
diff --git a/sidechain-orchestrator/sidechain/bitnames/message_test.go b/sidechain-orchestrator/sidechain/bitnames/message_test.go
new file mode 100644
index 0000000000..0e58d963e7
--- /dev/null
+++ b/sidechain-orchestrator/sidechain/bitnames/message_test.go
@@ -0,0 +1,29 @@
+package bitnames
+
+import (
+	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitnames/v1"
+	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
+	"github.com/stretchr/testify/require"
+	"net"
+	"strconv"
+	"testing"
+)
+
+func TestHandlerSendsTheMessage(t *testing.T) {
+	server, params := recordParams(t, `null`)
+	t.Cleanup(server.Close)
+	host, port, err := net.SplitHostPort(server.Listener.Addr().String())
+	require.NoError(t, err)
+	portNum, err := strconv.Atoi(port)
+	require.NoError(t, err)
+	h := NewHandler(sidechain.NewJSONRPCProxy(host, portNum))
+	_, err = h.EncryptMsg(t.Context(), &pb.EncryptMsgRequest{EncryptionPubkey: "key", Msg: "the message"})
+	require.NoError(t, err)
+	require.JSONEq(t, `["key","the message"]`, string(*params))
+	_, err = h.SignArbitraryMsg(t.Context(), &pb.SignArbitraryMsgRequest{VerifyingKey: "key", Msg: "the message"})
+	require.NoError(t, err)
+	require.JSONEq(t, `["key","the message"]`, string(*params))
+	_, err = h.SignArbitraryMsgAsAddr(t.Context(), &pb.SignArbitraryMsgAsAddrRequest{Address: "address", Msg: "the message"})
+	require.NoError(t, err)
+	require.JSONEq(t, `["address","the message"]`, string(*params))
+}
diff --git a/sidechain-orchestrator/sidechain/bitnames/owner_test.go b/sidechain-orchestrator/sidechain/bitnames/owner_test.go
index 24e300862b..3dc05859d5 100644
--- a/sidechain-orchestrator/sidechain/bitnames/owner_test.go
+++ b/sidechain-orchestrator/sidechain/bitnames/owner_test.go
@@ -5,7 +5,7 @@ import (
 	"encoding/json"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bitnames/v1"
 
 	"github.com/stretchr/testify/assert"
@@ -83,9 +83,7 @@ func TestGetBitNameOwnerDistinguishesLookupErrors(t *testing.T) {
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			proxy, _ := sendMethodNode(t, map[string]string{"list_utxos": test.utxos})
-			_, err := NewHandler(proxy).GetBitNameOwner(context.Background(), connect.NewRequest(
-				&pb.GetBitNameOwnerRequest{Bitname: "unknown"},
-			))
+			_, err := NewHandler(proxy).GetBitNameOwner(context.Background(), &pb.GetBitNameOwnerRequest{Bitname: "unknown"})
 			require.Error(t, err)
 			assert.Equal(t, test.code, connect.CodeOf(err))
 		})
diff --git a/sidechain-orchestrator/sidechain/bitnames/rpc_params_test.go b/sidechain-orchestrator/sidechain/bitnames/rpc_params_test.go
index 84add595d8..dcb7558712 100644
--- a/sidechain-orchestrator/sidechain/bitnames/rpc_params_test.go
+++ b/sidechain-orchestrator/sidechain/bitnames/rpc_params_test.go
@@ -23,11 +23,13 @@ func recordParams(t *testing.T, result string) (*httptest.Server, *json.RawMessa
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		var req struct {
 			Params json.RawMessage `json:"params"`
+			ID     json.RawMessage `json:"id"`
 		}
 		require.NoError(t, json.NewDecoder(r.Body).Decode(&req))
 		seen = req.Params
 		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":"t","result":` + result + `}`))
+		_, err := w.Write([]byte(`{"jsonrpc":"2.0","id":` + string(req.ID) + `,"result":` + result + `}`))
+		require.NoError(t, err)
 	}))
 	return srv, &seen
 }
diff --git a/sidechain-orchestrator/sidechain/bitnames/send_method_test.go b/sidechain-orchestrator/sidechain/bitnames/send_method_test.go
index 22d1c4399f..aeff6d10cb 100644
--- a/sidechain-orchestrator/sidechain/bitnames/send_method_test.go
+++ b/sidechain-orchestrator/sidechain/bitnames/send_method_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -53,11 +52,11 @@ func TestTransferCallsCreateTransfer(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"create_transfer": `"txid1"`})
 
 	resp, err := NewHandler(proxy).Transfer(context.Background(),
-		connect.NewRequest(&pb.TransferRequest{
+		&pb.TransferRequest{
 			Address: "sidechain-address", AmountSats: 50_000_000, FeeSats: 1000,
-		}))
+		})
 	require.NoError(t, err)
-	assert.Equal(t, "txid1", resp.Msg.Txid)
+	assert.Equal(t, "txid1", resp.Txid)
 	assert.Equal(t, []string{`create_transfer ["sidechain-address",50000000,1000,null]`}, *seen)
 }
 
@@ -65,11 +64,11 @@ func TestWithdrawCallsCreateWithdrawal(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"create_withdrawal": `"txid2"`})
 
 	resp, err := NewHandler(proxy).Withdraw(context.Background(),
-		connect.NewRequest(&pb.WithdrawRequest{
+		&pb.WithdrawRequest{
 			Address: "bc1qexample", AmountSats: 10_000, SideFeeSats: 1000, MainFeeSats: 2000,
-		}))
+		})
 	require.NoError(t, err)
-	assert.Equal(t, "txid2", resp.Msg.Txid)
+	assert.Equal(t, "txid2", resp.Txid)
 	assert.Equal(t, []string{`create_withdrawal ["bc1qexample",10000,1000,2000]`}, *seen)
 }
 
@@ -77,8 +76,8 @@ func TestSidechainWealthCallsSidechainWealth(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"sidechain_wealth": `10603007000`})
 
 	resp, err := NewHandler(proxy).GetSidechainWealth(context.Background(),
-		connect.NewRequest(&pb.GetSidechainWealthRequest{}))
+		&pb.GetSidechainWealthRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, int64(10603007000), resp.Msg.Sats)
+	assert.Equal(t, int64(10603007000), resp.Sats)
 	assert.Equal(t, []string{"sidechain_wealth"}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain/coinshift/handler.go b/sidechain-orchestrator/sidechain/coinshift/handler.go
index ccdd3db4f2..ef979beb21 100644
--- a/sidechain-orchestrator/sidechain/coinshift/handler.go
+++ b/sidechain-orchestrator/sidechain/coinshift/handler.go
@@ -6,7 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/coinshift/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/coinshift/v1/coinshiftv1connect"
@@ -34,219 +34,219 @@ func (h *Handler) WalletBalance(ctx context.Context) (total, available int64, er
 
 // --- Common Node methods ---
 
-func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *Handler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	total, available, err := h.WalletBalance(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		TotalSats:     total,
 		AvailableSats: available,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, req *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, req *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.proxy.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, req *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, req *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.proxy.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
 
-func (h *Handler) GetNewAddress(ctx context.Context, req *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *Handler) GetNewAddress(ctx context.Context, req *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	address, err := h.proxy.GetNewAddress(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewAddressResponse{Address: address}), nil
+	return &pb.GetNewAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) Withdraw(ctx context.Context, req *connect.Request[pb.WithdrawRequest]) (*connect.Response[pb.WithdrawResponse], error) {
-	txid, err := h.proxy.Withdraw(ctx, req.Msg.Address, req.Msg.AmountSats, req.Msg.SideFeeSats, req.Msg.MainFeeSats)
+func (h *Handler) Withdraw(ctx context.Context, req *pb.WithdrawRequest) (*pb.WithdrawResponse, error) {
+	txid, err := h.proxy.Withdraw(ctx, req.Address, req.AmountSats, req.SideFeeSats, req.MainFeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.WithdrawResponse{Txid: txid}), nil
+	return &pb.WithdrawResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.TransferRequest]) (*connect.Response[pb.TransferResponse], error) {
-	txid, err := h.proxy.Transfer(ctx, req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats)
+func (h *Handler) Transfer(ctx context.Context, req *pb.TransferRequest) (*pb.TransferResponse, error) {
+	txid, err := h.proxy.Transfer(ctx, req.Address, req.AmountSats, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferResponse{Txid: txid}), nil
+	return &pb.TransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Mine(ctx context.Context, req *connect.Request[pb.MineRequest]) (*connect.Response[pb.MineResponse], error) {
-	raw, err := h.proxy.Mine(ctx, req.Msg.FeeSats)
+func (h *Handler) Mine(ctx context.Context, req *pb.MineRequest) (*pb.MineResponse, error) {
+	raw, err := h.proxy.Mine(ctx, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MineResponse{BmmResultJson: string(raw)}), nil
+	return &pb.MineResponse{BmmResultJson: string(raw)}, nil
 }
 
-func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[pb.GetPendingWithdrawalBundleRequest]) (*connect.Response[pb.GetPendingWithdrawalBundleResponse], error) {
+func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *pb.GetPendingWithdrawalBundleRequest) (*pb.GetPendingWithdrawalBundleResponse, error) {
 	raw, err := h.proxy.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}), nil
+	return &pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.GetWalletUtxosRequest]) (*connect.Response[pb.GetWalletUtxosResponse], error) {
+func (h *Handler) GetWalletUtxos(ctx context.Context, req *pb.GetWalletUtxosRequest) (*pb.GetWalletUtxosResponse, error) {
 	raw, err := h.proxy.GetWalletUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.GetWalletUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, req *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, req *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	raw, err := h.proxy.ListUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.ListUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) RemoveFromMempool(ctx context.Context, req *connect.Request[pb.RemoveFromMempoolRequest]) (*connect.Response[pb.RemoveFromMempoolResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Msg.Txid}, nil); err != nil {
+func (h *Handler) RemoveFromMempool(ctx context.Context, req *pb.RemoveFromMempoolRequest) (*pb.RemoveFromMempoolResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Txid}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RemoveFromMempoolResponse{}), nil
+	return &pb.RemoveFromMempoolResponse{}, nil
 }
 
-func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[pb.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[pb.GetLatestFailedWithdrawalBundleHeightResponse], error) {
+func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *pb.GetLatestFailedWithdrawalBundleHeightRequest) (*pb.GetLatestFailedWithdrawalBundleHeightResponse, error) {
 	height, err := h.proxy.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}), nil
+	return &pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}, nil
 }
 
-func (h *Handler) GenerateMnemonic(ctx context.Context, req *connect.Request[pb.GenerateMnemonicRequest]) (*connect.Response[pb.GenerateMnemonicResponse], error) {
+func (h *Handler) GenerateMnemonic(ctx context.Context, req *pb.GenerateMnemonicRequest) (*pb.GenerateMnemonicResponse, error) {
 	var mnemonic string
 	if err := h.proxy.Client.Call(ctx, "generate_mnemonic", nil, &mnemonic); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GenerateMnemonicResponse{Mnemonic: mnemonic}), nil
+	return &pb.GenerateMnemonicResponse{Mnemonic: mnemonic}, nil
 }
 
-func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[pb.SetSeedFromMnemonicRequest]) (*connect.Response[pb.SetSeedFromMnemonicResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Msg.Mnemonic}, nil); err != nil {
+func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *pb.SetSeedFromMnemonicRequest) (*pb.SetSeedFromMnemonicResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Mnemonic}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SetSeedFromMnemonicResponse{}), nil
+	return &pb.SetSeedFromMnemonicResponse{}, nil
 }
 
-func (h *Handler) CallRaw(ctx context.Context, req *connect.Request[pb.CallRawRequest]) (*connect.Response[pb.CallRawResponse], error) {
+func (h *Handler) CallRaw(ctx context.Context, req *pb.CallRawRequest) (*pb.CallRawResponse, error) {
 	var params any
-	if req.Msg.ParamsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.ParamsJson), &params); err != nil {
+	if req.ParamsJson != "" {
+		if err := json.Unmarshal([]byte(req.ParamsJson), &params); err != nil {
 			return nil, fmt.Errorf("unmarshal params: %w", err)
 		}
 	}
-	raw, err := h.proxy.CallRaw(ctx, req.Msg.Method, params)
+	raw, err := h.proxy.CallRaw(ctx, req.Method, params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CallRawResponse{ResultJson: string(raw)}), nil
+	return &pb.CallRawResponse{ResultJson: string(raw)}, nil
 }
 
 // --- CoinShift-specific methods ---
 
-func (h *Handler) GetSidechainWealth(ctx context.Context, req *connect.Request[pb.GetSidechainWealthRequest]) (*connect.Response[pb.GetSidechainWealthResponse], error) {
+func (h *Handler) GetSidechainWealth(ctx context.Context, req *pb.GetSidechainWealthRequest) (*pb.GetSidechainWealthResponse, error) {
 	var sats int64
 	if err := h.proxy.Client.Call(ctx, "sidechain_wealth", nil, &sats); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainWealthResponse{Sats: sats}), nil
+	return &pb.GetSidechainWealthResponse{Sats: sats}, nil
 }
 
-func (h *Handler) CreateDeposit(ctx context.Context, req *connect.Request[pb.CreateDepositRequest]) (*connect.Response[pb.CreateDepositResponse], error) {
+func (h *Handler) CreateDeposit(ctx context.Context, req *pb.CreateDepositRequest) (*pb.CreateDepositResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.ValueSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.ValueSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_deposit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CreateDepositResponse{Txid: txid}), nil
+	return &pb.CreateDepositResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ConnectPeer(ctx context.Context, req *connect.Request[pb.ConnectPeerRequest]) (*connect.Response[pb.ConnectPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ConnectPeer(ctx context.Context, req *pb.ConnectPeerRequest) (*pb.ConnectPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ConnectPeerResponse{}), nil
+	return &pb.ConnectPeerResponse{}, nil
 }
 
-func (h *Handler) ForgetPeer(ctx context.Context, req *connect.Request[pb.ForgetPeerRequest]) (*connect.Response[pb.ForgetPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "forget_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ForgetPeer(ctx context.Context, req *pb.ForgetPeerRequest) (*pb.ForgetPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "forget_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ForgetPeerResponse{}), nil
+	return &pb.ForgetPeerResponse{}, nil
 }
 
-func (h *Handler) ListPeers(ctx context.Context, req *connect.Request[pb.ListPeersRequest]) (*connect.Response[pb.ListPeersResponse], error) {
+func (h *Handler) ListPeers(ctx context.Context, req *pb.ListPeersRequest) (*pb.ListPeersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_peers", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListPeersResponse{PeersJson: string(raw)}), nil
+	return &pb.ListPeersResponse{PeersJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBlock(ctx context.Context, req *connect.Request[pb.GetBlockRequest]) (*connect.Response[pb.GetBlockResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Msg.Hash})
+func (h *Handler) GetBlock(ctx context.Context, req *pb.GetBlockRequest) (*pb.GetBlockResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Hash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockResponse{BlockJson: string(raw)}), nil
+	return &pb.GetBlockResponse{BlockJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestMainchainBlockHashRequest]) (*connect.Response[pb.GetBestMainchainBlockHashResponse], error) {
+func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *pb.GetBestMainchainBlockHashRequest) (*pb.GetBestMainchainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_mainchain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestMainchainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestMainchainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestSidechainBlockHashRequest]) (*connect.Response[pb.GetBestSidechainBlockHashResponse], error) {
+func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *pb.GetBestSidechainBlockHashRequest) (*pb.GetBestSidechainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_sidechain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestSidechainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestSidechainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBmmInclusions(ctx context.Context, req *connect.Request[pb.GetBmmInclusionsRequest]) (*connect.Response[pb.GetBmmInclusionsResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.Msg.BlockHash})
+func (h *Handler) GetBmmInclusions(ctx context.Context, req *pb.GetBmmInclusionsRequest) (*pb.GetBmmInclusionsResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.BlockHash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmInclusionsResponse{Inclusions: string(raw)}), nil
+	return &pb.GetBmmInclusionsResponse{Inclusions: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletAddresses(ctx context.Context, req *connect.Request[pb.GetWalletAddressesRequest]) (*connect.Response[pb.GetWalletAddressesResponse], error) {
+func (h *Handler) GetWalletAddresses(ctx context.Context, req *pb.GetWalletAddressesRequest) (*pb.GetWalletAddressesResponse, error) {
 	var addresses []string
 	if err := h.proxy.Client.Call(ctx, "get_wallet_addresses", nil, &addresses); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletAddressesResponse{Addresses: addresses}), nil
+	return &pb.GetWalletAddressesResponse{Addresses: addresses}, nil
 }
 
-func (h *Handler) OpenapiSchema(ctx context.Context, req *connect.Request[pb.OpenapiSchemaRequest]) (*connect.Response[pb.OpenapiSchemaResponse], error) {
+func (h *Handler) OpenapiSchema(ctx context.Context, req *pb.OpenapiSchemaRequest) (*pb.OpenapiSchemaResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "openapi_schema", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.OpenapiSchemaResponse{SchemaJson: string(raw)}), nil
+	return &pb.OpenapiSchemaResponse{SchemaJson: string(raw)}, nil
 }
 
 // --- Swap methods ---
@@ -255,22 +255,22 @@ func swapIDParam(hexID string) ([32]byte, error) {
 	var id [32]byte
 	b, err := hex.DecodeString(hexID)
 	if err != nil || len(b) != len(id) {
-		return id, connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("swap_id must be 32 bytes hex, got %q", hexID))
+		return id, connect.Errorf(connect.CodeInvalidArgument,
+			"swap_id must be 32 bytes hex, got %q", hexID)
 	}
 	copy(id[:], b)
 	return id, nil
 }
 
-func (h *Handler) CreateSwap(ctx context.Context, req *connect.Request[pb.CreateSwapRequest]) (*connect.Response[pb.CreateSwapResponse], error) {
+func (h *Handler) CreateSwap(ctx context.Context, req *pb.CreateSwapRequest) (*pb.CreateSwapResponse, error) {
 	params := []any{
-		req.Msg.ParentChain,
-		req.Msg.L1RecipientAddress,
-		req.Msg.L1AmountSats,
-		req.Msg.L2Recipient,
-		req.Msg.L2AmountSats,
-		req.Msg.RequiredConfirmations,
-		req.Msg.FeeSats,
+		req.ParentChain,
+		req.L1RecipientAddress,
+		req.L1AmountSats,
+		req.L2Recipient,
+		req.L2AmountSats,
+		req.RequiredConfirmations,
+		req.FeeSats,
 	}
 	var tuple [2]json.RawMessage
 	if err := h.proxy.Client.Call(ctx, "create_swap", params, &tuple); err != nil {
@@ -284,27 +284,27 @@ func (h *Handler) CreateSwap(ctx context.Context, req *connect.Request[pb.Create
 	if err := json.Unmarshal(tuple[1], &txid); err != nil {
 		return nil, fmt.Errorf("unmarshal txid: %w", err)
 	}
-	return connect.NewResponse(&pb.CreateSwapResponse{
+	return &pb.CreateSwapResponse{
 		SwapId: hex.EncodeToString(swapID[:]),
 		Txid:   txid,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) ClaimSwap(ctx context.Context, req *connect.Request[pb.ClaimSwapRequest]) (*connect.Response[pb.ClaimSwapResponse], error) {
-	swapID, err := swapIDParam(req.Msg.SwapId)
+func (h *Handler) ClaimSwap(ctx context.Context, req *pb.ClaimSwapRequest) (*pb.ClaimSwapResponse, error) {
+	swapID, err := swapIDParam(req.SwapId)
 	if err != nil {
 		return nil, err
 	}
 	var txid string
-	params := []any{swapID, req.Msg.L2ClaimerAddress}
+	params := []any{swapID, req.L2ClaimerAddress}
 	if err := h.proxy.Client.Call(ctx, "claim_swap", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ClaimSwapResponse{Txid: txid}), nil
+	return &pb.ClaimSwapResponse{Txid: txid}, nil
 }
 
-func (h *Handler) GetSwapStatus(ctx context.Context, req *connect.Request[pb.GetSwapStatusRequest]) (*connect.Response[pb.GetSwapStatusResponse], error) {
-	swapID, err := swapIDParam(req.Msg.SwapId)
+func (h *Handler) GetSwapStatus(ctx context.Context, req *pb.GetSwapStatusRequest) (*pb.GetSwapStatusResponse, error) {
+	swapID, err := swapIDParam(req.SwapId)
 	if err != nil {
 		return nil, err
 	}
@@ -312,41 +312,41 @@ func (h *Handler) GetSwapStatus(ctx context.Context, req *connect.Request[pb.Get
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSwapStatusResponse{SwapJson: string(raw)}), nil
+	return &pb.GetSwapStatusResponse{SwapJson: string(raw)}, nil
 }
 
-func (h *Handler) ListSwaps(ctx context.Context, req *connect.Request[pb.ListSwapsRequest]) (*connect.Response[pb.ListSwapsResponse], error) {
+func (h *Handler) ListSwaps(ctx context.Context, req *pb.ListSwapsRequest) (*pb.ListSwapsResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_swaps", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListSwapsResponse{SwapsJson: string(raw)}), nil
+	return &pb.ListSwapsResponse{SwapsJson: string(raw)}, nil
 }
 
-func (h *Handler) ListSwapsByRecipient(ctx context.Context, req *connect.Request[pb.ListSwapsByRecipientRequest]) (*connect.Response[pb.ListSwapsByRecipientResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "list_swaps_by_recipient", []any{req.Msg.Recipient})
+func (h *Handler) ListSwapsByRecipient(ctx context.Context, req *pb.ListSwapsByRecipientRequest) (*pb.ListSwapsByRecipientResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "list_swaps_by_recipient", []any{req.Recipient})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListSwapsByRecipientResponse{SwapsJson: string(raw)}), nil
+	return &pb.ListSwapsByRecipientResponse{SwapsJson: string(raw)}, nil
 }
 
-func (h *Handler) UpdateSwapL1Txid(ctx context.Context, req *connect.Request[pb.UpdateSwapL1TxidRequest]) (*connect.Response[pb.UpdateSwapL1TxidResponse], error) {
-	swapID, err := swapIDParam(req.Msg.SwapId)
+func (h *Handler) UpdateSwapL1Txid(ctx context.Context, req *pb.UpdateSwapL1TxidRequest) (*pb.UpdateSwapL1TxidResponse, error) {
+	swapID, err := swapIDParam(req.SwapId)
 	if err != nil {
 		return nil, err
 	}
-	params := []any{swapID, req.Msg.L1TxidHex, req.Msg.Confirmations}
+	params := []any{swapID, req.L1TxidHex, req.Confirmations}
 	if err := h.proxy.Client.Call(ctx, "update_swap_l1_txid", params, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.UpdateSwapL1TxidResponse{}), nil
+	return &pb.UpdateSwapL1TxidResponse{}, nil
 }
 
-func (h *Handler) ReconstructSwaps(ctx context.Context, req *connect.Request[pb.ReconstructSwapsRequest]) (*connect.Response[pb.ReconstructSwapsResponse], error) {
+func (h *Handler) ReconstructSwaps(ctx context.Context, req *pb.ReconstructSwapsRequest) (*pb.ReconstructSwapsResponse, error) {
 	var count int64
 	if err := h.proxy.Client.Call(ctx, "reconstruct_swaps", nil, &count); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ReconstructSwapsResponse{Count: count}), nil
+	return &pb.ReconstructSwapsResponse{Count: count}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/coinshift/handler_test.go b/sidechain-orchestrator/sidechain/coinshift/handler_test.go
index 2acc230384..818a4feb65 100644
--- a/sidechain-orchestrator/sidechain/coinshift/handler_test.go
+++ b/sidechain-orchestrator/sidechain/coinshift/handler_test.go
@@ -12,7 +12,7 @@ import (
 	"sync"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -77,7 +77,7 @@ func TestCreateSwap(t *testing.T) {
 
 	l2Recipient := "cs1qrecipient"
 	requiredConfirmations := int32(6)
-	resp, err := h.CreateSwap(context.Background(), connect.NewRequest(&pb.CreateSwapRequest{
+	resp, err := h.CreateSwap(context.Background(), &pb.CreateSwapRequest{
 		L2AmountSats:          2_000,
 		L1AmountSats:          1_000,
 		L1RecipientAddress:    "bc1qrecipient",
@@ -85,24 +85,24 @@ func TestCreateSwap(t *testing.T) {
 		L2Recipient:           &l2Recipient,
 		RequiredConfirmations: &requiredConfirmations,
 		FeeSats:               10,
-	}))
+	})
 	require.NoError(t, err)
 
 	call := lastCall()
 	assert.Equal(t, "create_swap", call.method)
 	assert.JSONEq(t, `["Signet","bc1qrecipient",1000,"cs1qrecipient",2000,6,10]`, call.params)
-	assert.Equal(t, testSwapIDHex, resp.Msg.SwapId)
-	assert.Equal(t, "abc123", resp.Msg.Txid)
+	assert.Equal(t, testSwapIDHex, resp.SwapId)
+	assert.Equal(t, "abc123", resp.Txid)
 }
 
 func TestClaimSwapSendsSwapIDBytes(t *testing.T) {
 	h, lastCall := stubNode(t, `"txid"`)
 
 	claimer := "cs1qclaimer"
-	_, err := h.ClaimSwap(context.Background(), connect.NewRequest(&pb.ClaimSwapRequest{
+	_, err := h.ClaimSwap(context.Background(), &pb.ClaimSwapRequest{
 		SwapId:           testSwapIDHex,
 		L2ClaimerAddress: &claimer,
-	}))
+	})
 	require.NoError(t, err)
 
 	call := lastCall()
@@ -113,9 +113,9 @@ func TestClaimSwapSendsSwapIDBytes(t *testing.T) {
 func TestGetSwapStatusSendsSwapIDBytes(t *testing.T) {
 	h, lastCall := stubNode(t, `null`)
 
-	_, err := h.GetSwapStatus(context.Background(), connect.NewRequest(&pb.GetSwapStatusRequest{
+	_, err := h.GetSwapStatus(context.Background(), &pb.GetSwapStatusRequest{
 		SwapId: testSwapIDHex,
-	}))
+	})
 	require.NoError(t, err)
 
 	call := lastCall()
@@ -126,11 +126,11 @@ func TestGetSwapStatusSendsSwapIDBytes(t *testing.T) {
 func TestUpdateSwapL1TxidSendsSwapIDBytes(t *testing.T) {
 	h, lastCall := stubNode(t, `null`)
 
-	_, err := h.UpdateSwapL1Txid(context.Background(), connect.NewRequest(&pb.UpdateSwapL1TxidRequest{
+	_, err := h.UpdateSwapL1Txid(context.Background(), &pb.UpdateSwapL1TxidRequest{
 		SwapId:        testSwapIDHex,
 		L1TxidHex:     "abcd",
 		Confirmations: 3,
-	}))
+	})
 	require.NoError(t, err)
 
 	call := lastCall()
@@ -143,13 +143,13 @@ func TestSwapMethodsRejectInvalidSwapID(t *testing.T) {
 	ctx := context.Background()
 
 	for _, id := range []string{"", "deadbeef", "zz" + strings.Repeat("00", 31)} {
-		_, err := h.ClaimSwap(ctx, connect.NewRequest(&pb.ClaimSwapRequest{SwapId: id}))
+		_, err := h.ClaimSwap(ctx, &pb.ClaimSwapRequest{SwapId: id})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err), id)
 
-		_, err = h.GetSwapStatus(ctx, connect.NewRequest(&pb.GetSwapStatusRequest{SwapId: id}))
+		_, err = h.GetSwapStatus(ctx, &pb.GetSwapStatusRequest{SwapId: id})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err), id)
 
-		_, err = h.UpdateSwapL1Txid(ctx, connect.NewRequest(&pb.UpdateSwapL1TxidRequest{SwapId: id}))
+		_, err = h.UpdateSwapL1Txid(ctx, &pb.UpdateSwapL1TxidRequest{SwapId: id})
 		assert.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err), id)
 	}
 }
diff --git a/sidechain-orchestrator/sidechain/coinshift/wealth_method_test.go b/sidechain-orchestrator/sidechain/coinshift/wealth_method_test.go
index 4d5c19d619..2bea0c1cb1 100644
--- a/sidechain-orchestrator/sidechain/coinshift/wealth_method_test.go
+++ b/sidechain-orchestrator/sidechain/coinshift/wealth_method_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -47,8 +46,8 @@ func TestSidechainWealthCallsSidechainWealth(t *testing.T) {
 	proxy, seen := wealthNode(t, "10603007000")
 
 	resp, err := NewHandler(proxy).GetSidechainWealth(context.Background(),
-		connect.NewRequest(&pb.GetSidechainWealthRequest{}))
+		&pb.GetSidechainWealthRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, int64(10603007000), resp.Msg.Sats)
+	assert.Equal(t, int64(10603007000), resp.Sats)
 	assert.Equal(t, []string{"sidechain_wealth"}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain/photon/handler.go b/sidechain-orchestrator/sidechain/photon/handler.go
index f75e5ed343..fb64578e5d 100644
--- a/sidechain-orchestrator/sidechain/photon/handler.go
+++ b/sidechain-orchestrator/sidechain/photon/handler.go
@@ -5,8 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"connectrpc.com/connect"
-
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/photon/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/photon/v1/photonv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
@@ -33,211 +31,211 @@ func (h *Handler) WalletBalance(ctx context.Context) (total, available int64, er
 
 // --- Common Node methods ---
 
-func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *Handler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	total, available, err := h.WalletBalance(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		TotalSats:     total,
 		AvailableSats: available,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, req *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, req *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.proxy.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, req *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, req *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.proxy.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
 
-func (h *Handler) GetNewAddress(ctx context.Context, req *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *Handler) GetNewAddress(ctx context.Context, req *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	address, err := h.proxy.GetNewAddress(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewAddressResponse{Address: address}), nil
+	return &pb.GetNewAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) Withdraw(ctx context.Context, req *connect.Request[pb.WithdrawRequest]) (*connect.Response[pb.WithdrawResponse], error) {
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.SideFeeSats, req.Msg.MainFeeSats}
+func (h *Handler) Withdraw(ctx context.Context, req *pb.WithdrawRequest) (*pb.WithdrawResponse, error) {
+	params := []any{req.Address, req.AmountSats, req.SideFeeSats, req.MainFeeSats}
 	var txid string
 	if err := h.proxy.Client.Call(ctx, "create_withdrawal", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.WithdrawResponse{Txid: txid}), nil
+	return &pb.WithdrawResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.TransferRequest]) (*connect.Response[pb.TransferResponse], error) {
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats}
+func (h *Handler) Transfer(ctx context.Context, req *pb.TransferRequest) (*pb.TransferResponse, error) {
+	params := []any{req.Address, req.AmountSats, req.FeeSats}
 	var txid string
 	if err := h.proxy.Client.Call(ctx, "create_transfer", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferResponse{Txid: txid}), nil
+	return &pb.TransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Mine(ctx context.Context, req *connect.Request[pb.MineRequest]) (*connect.Response[pb.MineResponse], error) {
-	raw, err := h.proxy.Mine(ctx, req.Msg.FeeSats)
+func (h *Handler) Mine(ctx context.Context, req *pb.MineRequest) (*pb.MineResponse, error) {
+	raw, err := h.proxy.Mine(ctx, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MineResponse{BmmResultJson: string(raw)}), nil
+	return &pb.MineResponse{BmmResultJson: string(raw)}, nil
 }
 
-func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[pb.GetPendingWithdrawalBundleRequest]) (*connect.Response[pb.GetPendingWithdrawalBundleResponse], error) {
+func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *pb.GetPendingWithdrawalBundleRequest) (*pb.GetPendingWithdrawalBundleResponse, error) {
 	raw, err := h.proxy.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}), nil
+	return &pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.GetWalletUtxosRequest]) (*connect.Response[pb.GetWalletUtxosResponse], error) {
+func (h *Handler) GetWalletUtxos(ctx context.Context, req *pb.GetWalletUtxosRequest) (*pb.GetWalletUtxosResponse, error) {
 	raw, err := h.proxy.GetWalletUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.GetWalletUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, req *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, req *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	raw, err := h.proxy.ListUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.ListUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) RemoveFromMempool(ctx context.Context, req *connect.Request[pb.RemoveFromMempoolRequest]) (*connect.Response[pb.RemoveFromMempoolResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Msg.Txid}, nil); err != nil {
+func (h *Handler) RemoveFromMempool(ctx context.Context, req *pb.RemoveFromMempoolRequest) (*pb.RemoveFromMempoolResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Txid}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RemoveFromMempoolResponse{}), nil
+	return &pb.RemoveFromMempoolResponse{}, nil
 }
 
-func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[pb.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[pb.GetLatestFailedWithdrawalBundleHeightResponse], error) {
+func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *pb.GetLatestFailedWithdrawalBundleHeightRequest) (*pb.GetLatestFailedWithdrawalBundleHeightResponse, error) {
 	height, err := h.proxy.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}), nil
+	return &pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}, nil
 }
 
-func (h *Handler) GenerateMnemonic(ctx context.Context, req *connect.Request[pb.GenerateMnemonicRequest]) (*connect.Response[pb.GenerateMnemonicResponse], error) {
+func (h *Handler) GenerateMnemonic(ctx context.Context, req *pb.GenerateMnemonicRequest) (*pb.GenerateMnemonicResponse, error) {
 	var mnemonic string
 	if err := h.proxy.Client.Call(ctx, "generate_mnemonic", nil, &mnemonic); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GenerateMnemonicResponse{Mnemonic: mnemonic}), nil
+	return &pb.GenerateMnemonicResponse{Mnemonic: mnemonic}, nil
 }
 
-func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[pb.SetSeedFromMnemonicRequest]) (*connect.Response[pb.SetSeedFromMnemonicResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Msg.Mnemonic}, nil); err != nil {
+func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *pb.SetSeedFromMnemonicRequest) (*pb.SetSeedFromMnemonicResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Mnemonic}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SetSeedFromMnemonicResponse{}), nil
+	return &pb.SetSeedFromMnemonicResponse{}, nil
 }
 
-func (h *Handler) CallRaw(ctx context.Context, req *connect.Request[pb.CallRawRequest]) (*connect.Response[pb.CallRawResponse], error) {
+func (h *Handler) CallRaw(ctx context.Context, req *pb.CallRawRequest) (*pb.CallRawResponse, error) {
 	var params any
-	if req.Msg.ParamsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.ParamsJson), &params); err != nil {
+	if req.ParamsJson != "" {
+		if err := json.Unmarshal([]byte(req.ParamsJson), &params); err != nil {
 			return nil, fmt.Errorf("unmarshal params: %w", err)
 		}
 	}
-	raw, err := h.proxy.CallRaw(ctx, req.Msg.Method, params)
+	raw, err := h.proxy.CallRaw(ctx, req.Method, params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CallRawResponse{ResultJson: string(raw)}), nil
+	return &pb.CallRawResponse{ResultJson: string(raw)}, nil
 }
 
 // --- Photon-specific methods ---
 
-func (h *Handler) GetSidechainWealth(ctx context.Context, req *connect.Request[pb.GetSidechainWealthRequest]) (*connect.Response[pb.GetSidechainWealthResponse], error) {
+func (h *Handler) GetSidechainWealth(ctx context.Context, req *pb.GetSidechainWealthRequest) (*pb.GetSidechainWealthResponse, error) {
 	var sats int64
 	if err := h.proxy.Client.Call(ctx, "sidechain_wealth", nil, &sats); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainWealthResponse{Sats: sats}), nil
+	return &pb.GetSidechainWealthResponse{Sats: sats}, nil
 }
 
-func (h *Handler) CreateDeposit(ctx context.Context, req *connect.Request[pb.CreateDepositRequest]) (*connect.Response[pb.CreateDepositResponse], error) {
+func (h *Handler) CreateDeposit(ctx context.Context, req *pb.CreateDepositRequest) (*pb.CreateDepositResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.ValueSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.ValueSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_deposit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CreateDepositResponse{Txid: txid}), nil
+	return &pb.CreateDepositResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ConnectPeer(ctx context.Context, req *connect.Request[pb.ConnectPeerRequest]) (*connect.Response[pb.ConnectPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ConnectPeer(ctx context.Context, req *pb.ConnectPeerRequest) (*pb.ConnectPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ConnectPeerResponse{}), nil
+	return &pb.ConnectPeerResponse{}, nil
 }
 
-func (h *Handler) ForgetPeer(ctx context.Context, req *connect.Request[pb.ForgetPeerRequest]) (*connect.Response[pb.ForgetPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "forget_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ForgetPeer(ctx context.Context, req *pb.ForgetPeerRequest) (*pb.ForgetPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "forget_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ForgetPeerResponse{}), nil
+	return &pb.ForgetPeerResponse{}, nil
 }
 
-func (h *Handler) ListPeers(ctx context.Context, req *connect.Request[pb.ListPeersRequest]) (*connect.Response[pb.ListPeersResponse], error) {
+func (h *Handler) ListPeers(ctx context.Context, req *pb.ListPeersRequest) (*pb.ListPeersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_peers", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListPeersResponse{PeersJson: string(raw)}), nil
+	return &pb.ListPeersResponse{PeersJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBlock(ctx context.Context, req *connect.Request[pb.GetBlockRequest]) (*connect.Response[pb.GetBlockResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Msg.Hash})
+func (h *Handler) GetBlock(ctx context.Context, req *pb.GetBlockRequest) (*pb.GetBlockResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Hash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockResponse{BlockJson: string(raw)}), nil
+	return &pb.GetBlockResponse{BlockJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestMainchainBlockHashRequest]) (*connect.Response[pb.GetBestMainchainBlockHashResponse], error) {
+func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *pb.GetBestMainchainBlockHashRequest) (*pb.GetBestMainchainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_mainchain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestMainchainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestMainchainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestSidechainBlockHashRequest]) (*connect.Response[pb.GetBestSidechainBlockHashResponse], error) {
+func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *pb.GetBestSidechainBlockHashRequest) (*pb.GetBestSidechainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_sidechain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestSidechainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestSidechainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBmmInclusions(ctx context.Context, req *connect.Request[pb.GetBmmInclusionsRequest]) (*connect.Response[pb.GetBmmInclusionsResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.Msg.BlockHash})
+func (h *Handler) GetBmmInclusions(ctx context.Context, req *pb.GetBmmInclusionsRequest) (*pb.GetBmmInclusionsResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.BlockHash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmInclusionsResponse{Inclusions: string(raw)}), nil
+	return &pb.GetBmmInclusionsResponse{Inclusions: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletAddresses(ctx context.Context, req *connect.Request[pb.GetWalletAddressesRequest]) (*connect.Response[pb.GetWalletAddressesResponse], error) {
+func (h *Handler) GetWalletAddresses(ctx context.Context, req *pb.GetWalletAddressesRequest) (*pb.GetWalletAddressesResponse, error) {
 	var addresses []string
 	if err := h.proxy.Client.Call(ctx, "get_wallet_addresses", nil, &addresses); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletAddressesResponse{Addresses: addresses}), nil
+	return &pb.GetWalletAddressesResponse{Addresses: addresses}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/photon/send_method_test.go b/sidechain-orchestrator/sidechain/photon/send_method_test.go
index 0279643fd6..b745a06622 100644
--- a/sidechain-orchestrator/sidechain/photon/send_method_test.go
+++ b/sidechain-orchestrator/sidechain/photon/send_method_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -53,11 +52,11 @@ func TestTransferCallsCreateTransfer(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"create_transfer": `"txid1"`})
 
 	resp, err := NewHandler(proxy).Transfer(context.Background(),
-		connect.NewRequest(&pb.TransferRequest{
+		&pb.TransferRequest{
 			Address: "sidechain-address", AmountSats: 50_000_000, FeeSats: 1000,
-		}))
+		})
 	require.NoError(t, err)
-	assert.Equal(t, "txid1", resp.Msg.Txid)
+	assert.Equal(t, "txid1", resp.Txid)
 	assert.Equal(t, []string{`create_transfer ["sidechain-address",50000000,1000]`}, *seen)
 }
 
@@ -65,11 +64,11 @@ func TestWithdrawCallsCreateWithdrawal(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"create_withdrawal": `"txid2"`})
 
 	resp, err := NewHandler(proxy).Withdraw(context.Background(),
-		connect.NewRequest(&pb.WithdrawRequest{
+		&pb.WithdrawRequest{
 			Address: "bc1qexample", AmountSats: 10_000, SideFeeSats: 1000, MainFeeSats: 2000,
-		}))
+		})
 	require.NoError(t, err)
-	assert.Equal(t, "txid2", resp.Msg.Txid)
+	assert.Equal(t, "txid2", resp.Txid)
 	assert.Equal(t, []string{`create_withdrawal ["bc1qexample",10000,1000,2000]`}, *seen)
 }
 
@@ -77,8 +76,8 @@ func TestSidechainWealthCallsSidechainWealth(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"sidechain_wealth": `10603007000`})
 
 	resp, err := NewHandler(proxy).GetSidechainWealth(context.Background(),
-		connect.NewRequest(&pb.GetSidechainWealthRequest{}))
+		&pb.GetSidechainWealthRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, int64(10603007000), resp.Msg.Sats)
+	assert.Equal(t, int64(10603007000), resp.Sats)
 	assert.Equal(t, []string{"sidechain_wealth"}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain/thunder/handler.go b/sidechain-orchestrator/sidechain/thunder/handler.go
index 629df7aa9c..621eb8c9eb 100644
--- a/sidechain-orchestrator/sidechain/thunder/handler.go
+++ b/sidechain-orchestrator/sidechain/thunder/handler.go
@@ -6,7 +6,7 @@ import (
 	"errors"
 	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/thunder/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/thunder/v1/thunderv1connect"
@@ -49,74 +49,74 @@ func (h *Handler) WalletBalance(ctx context.Context) (int64, int64, error) {
 
 // --- Common Node methods ---
 
-func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *Handler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	total, available, err := h.backend.Balance(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		TotalSats:     total,
 		AvailableSats: available,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, req *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, req *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.proxy.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, req *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, req *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.proxy.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
 
-func (h *Handler) GetNewAddress(ctx context.Context, req *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *Handler) GetNewAddress(ctx context.Context, req *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	address, err := h.backend.NewAddress(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewAddressResponse{Address: address}), nil
+	return &pb.GetNewAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) Withdraw(ctx context.Context, req *connect.Request[pb.WithdrawRequest]) (*connect.Response[pb.WithdrawResponse], error) {
-	txid, err := h.backend.Withdraw(ctx, req.Msg.Address,
-		req.Msg.AmountSats, req.Msg.SideFeeSats, req.Msg.MainFeeSats)
+func (h *Handler) Withdraw(ctx context.Context, req *pb.WithdrawRequest) (*pb.WithdrawResponse, error) {
+	txid, err := h.backend.Withdraw(ctx, req.Address,
+		req.AmountSats, req.SideFeeSats, req.MainFeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.WithdrawResponse{Txid: txid}), nil
+	return &pb.WithdrawResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.TransferRequest]) (*connect.Response[pb.TransferResponse], error) {
-	txid, err := h.backend.Transfer(ctx, req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats)
+func (h *Handler) Transfer(ctx context.Context, req *pb.TransferRequest) (*pb.TransferResponse, error) {
+	txid, err := h.backend.Transfer(ctx, req.Address, req.AmountSats, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferResponse{Txid: txid}), nil
+	return &pb.TransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Mine(ctx context.Context, req *connect.Request[pb.MineRequest]) (*connect.Response[pb.MineResponse], error) {
-	raw, err := h.proxy.Mine(ctx, req.Msg.FeeSats)
+func (h *Handler) Mine(ctx context.Context, req *pb.MineRequest) (*pb.MineResponse, error) {
+	raw, err := h.proxy.Mine(ctx, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MineResponse{BmmResultJson: string(raw)}), nil
+	return &pb.MineResponse{BmmResultJson: string(raw)}, nil
 }
 
-func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[pb.GetPendingWithdrawalBundleRequest]) (*connect.Response[pb.GetPendingWithdrawalBundleResponse], error) {
+func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *pb.GetPendingWithdrawalBundleRequest) (*pb.GetPendingWithdrawalBundleResponse, error) {
 	raw, err := h.proxy.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}), nil
+	return &pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.GetWalletUtxosRequest]) (*connect.Response[pb.GetWalletUtxosResponse], error) {
+func (h *Handler) GetWalletUtxos(ctx context.Context, req *pb.GetWalletUtxosRequest) (*pb.GetWalletUtxosResponse, error) {
 	raw, err := h.backend.UTXOs(ctx)
 	if err != nil {
 		return nil, err
@@ -125,150 +125,150 @@ func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.Ge
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.GetWalletUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, req *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, req *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	raw, err := h.proxy.ListUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.ListUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[pb.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[pb.GetLatestFailedWithdrawalBundleHeightResponse], error) {
+func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *pb.GetLatestFailedWithdrawalBundleHeightRequest) (*pb.GetLatestFailedWithdrawalBundleHeightResponse, error) {
 	height, err := h.proxy.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}), nil
+	return &pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}, nil
 }
 
-func (h *Handler) CallRaw(ctx context.Context, req *connect.Request[pb.CallRawRequest]) (*connect.Response[pb.CallRawResponse], error) {
+func (h *Handler) CallRaw(ctx context.Context, req *pb.CallRawRequest) (*pb.CallRawResponse, error) {
 	var params any
-	if req.Msg.ParamsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.ParamsJson), &params); err != nil {
+	if req.ParamsJson != "" {
+		if err := json.Unmarshal([]byte(req.ParamsJson), &params); err != nil {
 			return nil, fmt.Errorf("unmarshal params: %w", err)
 		}
 	}
-	raw, err := h.proxy.CallRaw(ctx, req.Msg.Method, params)
+	raw, err := h.proxy.CallRaw(ctx, req.Method, params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CallRawResponse{ResultJson: string(raw)}), nil
+	return &pb.CallRawResponse{ResultJson: string(raw)}, nil
 }
 
 // --- Thunder-specific methods ---
 
-func (h *Handler) GetSidechainWealth(ctx context.Context, req *connect.Request[pb.GetSidechainWealthRequest]) (*connect.Response[pb.GetSidechainWealthResponse], error) {
+func (h *Handler) GetSidechainWealth(ctx context.Context, req *pb.GetSidechainWealthRequest) (*pb.GetSidechainWealthResponse, error) {
 	var sats int64
 	if err := h.proxy.Client.Call(ctx, "sidechain_wealth", nil, &sats); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainWealthResponse{Sats: sats}), nil
+	return &pb.GetSidechainWealthResponse{Sats: sats}, nil
 }
 
-func (h *Handler) CreateDeposit(ctx context.Context, req *connect.Request[pb.CreateDepositRequest]) (*connect.Response[pb.CreateDepositResponse], error) {
+func (h *Handler) CreateDeposit(ctx context.Context, req *pb.CreateDepositRequest) (*pb.CreateDepositResponse, error) {
 	var txid string
 	params := map[string]any{
-		"address":    req.Msg.Address,
-		"value_sats": req.Msg.ValueSats,
-		"fee_sats":   req.Msg.FeeSats,
+		"address":    req.Address,
+		"value_sats": req.ValueSats,
+		"fee_sats":   req.FeeSats,
 	}
 	if err := h.proxy.Client.Call(ctx, "create_deposit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CreateDepositResponse{Txid: txid}), nil
+	return &pb.CreateDepositResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ConnectPeer(ctx context.Context, req *connect.Request[pb.ConnectPeerRequest]) (*connect.Response[pb.ConnectPeerResponse], error) {
+func (h *Handler) ConnectPeer(ctx context.Context, req *pb.ConnectPeerRequest) (*pb.ConnectPeerResponse, error) {
 	// The node takes positional params. A bare string reads as neither, and it
 	// answers "Invalid params".
-	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Msg.Address}, nil); err != nil {
+	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ConnectPeerResponse{}), nil
+	return &pb.ConnectPeerResponse{}, nil
 }
 
-func (h *Handler) ListPeers(ctx context.Context, req *connect.Request[pb.ListPeersRequest]) (*connect.Response[pb.ListPeersResponse], error) {
+func (h *Handler) ListPeers(ctx context.Context, req *pb.ListPeersRequest) (*pb.ListPeersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_peers", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListPeersResponse{PeersJson: string(raw)}), nil
+	return &pb.ListPeersResponse{PeersJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBlock(ctx context.Context, req *connect.Request[pb.GetBlockRequest]) (*connect.Response[pb.GetBlockResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Msg.Hash})
+func (h *Handler) GetBlock(ctx context.Context, req *pb.GetBlockRequest) (*pb.GetBlockResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Hash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockResponse{BlockJson: string(raw)}), nil
+	return &pb.GetBlockResponse{BlockJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestMainchainBlockHashRequest]) (*connect.Response[pb.GetBestMainchainBlockHashResponse], error) {
+func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *pb.GetBestMainchainBlockHashRequest) (*pb.GetBestMainchainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_mainchain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestMainchainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestMainchainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestSidechainBlockHashRequest]) (*connect.Response[pb.GetBestSidechainBlockHashResponse], error) {
+func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *pb.GetBestSidechainBlockHashRequest) (*pb.GetBestSidechainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_sidechain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestSidechainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestSidechainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBmmInclusions(ctx context.Context, req *connect.Request[pb.GetBmmInclusionsRequest]) (*connect.Response[pb.GetBmmInclusionsResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.Msg.BlockHash})
+func (h *Handler) GetBmmInclusions(ctx context.Context, req *pb.GetBmmInclusionsRequest) (*pb.GetBmmInclusionsResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.BlockHash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmInclusionsResponse{Inclusions: string(raw)}), nil
+	return &pb.GetBmmInclusionsResponse{Inclusions: string(raw)}, nil
 }
 
-func (h *Handler) RemoveFromMempool(ctx context.Context, req *connect.Request[pb.RemoveFromMempoolRequest]) (*connect.Response[pb.RemoveFromMempoolResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Msg.Txid}, nil); err != nil {
+func (h *Handler) RemoveFromMempool(ctx context.Context, req *pb.RemoveFromMempoolRequest) (*pb.RemoveFromMempoolResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Txid}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RemoveFromMempoolResponse{}), nil
+	return &pb.RemoveFromMempoolResponse{}, nil
 }
 
-func (h *Handler) GenerateMnemonic(ctx context.Context, req *connect.Request[pb.GenerateMnemonicRequest]) (*connect.Response[pb.GenerateMnemonicResponse], error) {
+func (h *Handler) GenerateMnemonic(ctx context.Context, req *pb.GenerateMnemonicRequest) (*pb.GenerateMnemonicResponse, error) {
 	var mnemonic string
 	if err := h.proxy.Client.Call(ctx, "generate_mnemonic", nil, &mnemonic); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GenerateMnemonicResponse{Mnemonic: mnemonic}), nil
+	return &pb.GenerateMnemonicResponse{Mnemonic: mnemonic}, nil
 }
 
-func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[pb.SetSeedFromMnemonicRequest]) (*connect.Response[pb.SetSeedFromMnemonicResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Msg.Mnemonic}, nil); err != nil {
+func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *pb.SetSeedFromMnemonicRequest) (*pb.SetSeedFromMnemonicResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Mnemonic}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SetSeedFromMnemonicResponse{}), nil
+	return &pb.SetSeedFromMnemonicResponse{}, nil
 }
 
 // ListWalletTransactions returns history from the node or the explicit index URL.
 func (h *Handler) ListWalletTransactions(
-	ctx context.Context, req *connect.Request[pb.ListWalletTransactionsRequest],
-) (*connect.Response[pb.ListWalletTransactionsResponse], error) {
+	ctx context.Context, req *pb.ListWalletTransactionsRequest,
+) (*pb.ListWalletTransactionsResponse, error) {
 	addresses, err := h.addresses.Addresses(ctx)
 	if err != nil {
 		return nil, connect.NewError(connect.CodeUnavailable,
-			fmt.Errorf("read wallet addresses: %w", err))
+			fmt.Errorf("read wallet addresses: %w", err).Error())
 	}
 	if len(addresses) == 0 {
-		return connect.NewResponse(&pb.ListWalletTransactionsResponse{}), nil
+		return &pb.ListWalletTransactionsResponse{}, nil
 	}
 
 	entries, err := h.history.History(ctx, addresses)
 	if err != nil {
 		return nil, connect.NewError(connect.CodeUnavailable,
-			fmt.Errorf("read wallet history: %w", err))
+			fmt.Errorf("read wallet history: %w", err).Error())
 	}
 
 	// An index with no blocks yet has no tip, and a wallet on a new chain
@@ -276,7 +276,7 @@ func (h *Handler) ListWalletTransactions(
 	tip, err := h.history.TipHeight(ctx)
 	if err != nil && !errors.Is(err, sidechainesplora.ErrEmptyIndex) {
 		return nil, connect.NewError(connect.CodeUnavailable,
-			fmt.Errorf("read the chain tip: %w", err))
+			fmt.Errorf("read the chain tip: %w", err).Error())
 	}
 
 	out := make([]*pb.SidechainWalletTransaction, 0, len(entries))
@@ -291,8 +291,8 @@ func (h *Handler) ListWalletTransactions(
 			Vout:        entry.Vout,
 		})
 	}
-	return connect.NewResponse(&pb.ListWalletTransactionsResponse{
+	return &pb.ListWalletTransactionsResponse{
 		Transactions: out,
 		TipHeight:    tip,
-	}), nil
+	}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/thunder/handler_history_test.go b/sidechain-orchestrator/sidechain/thunder/handler_history_test.go
index 0c657b375b..70f98129b8 100644
--- a/sidechain-orchestrator/sidechain/thunder/handler_history_test.go
+++ b/sidechain-orchestrator/sidechain/thunder/handler_history_test.go
@@ -8,8 +8,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
-
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/thunder/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
 )
@@ -19,7 +17,7 @@ import (
 func TestListTransactionsReportsAnUnreachableNode(t *testing.T) {
 	h := NewHandlerWithIndex(sidechain.NewJSONRPCProxy("127.0.0.1", 1), "")
 	_, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err == nil {
 		t.Fatal("want an error from an unreachable node, got none")
 	}
@@ -64,22 +62,22 @@ func TestListTransactionsReadsTheIndex(t *testing.T) {
 	h := NewHandlerWithIndex(sidechain.NewJSONRPCProxy(host, port), index.URL)
 
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list transactions: %v", err)
 	}
-	if len(resp.Msg.Transactions) != 1 {
-		t.Fatalf("got %d transactions, want 1", len(resp.Msg.Transactions))
+	if len(resp.Transactions) != 1 {
+		t.Fatalf("got %d transactions, want 1", len(resp.Transactions))
 	}
-	got := resp.Msg.Transactions[0]
+	got := resp.Transactions[0]
 	if got.Txid != "aa" || got.ValueSats != 7000 || got.FeeSats != 120 {
 		t.Errorf("transaction = %+v", got)
 	}
 	if got.BlockHeight != 5 || !got.Confirmed {
 		t.Errorf("status = height %d confirmed %v", got.BlockHeight, got.Confirmed)
 	}
-	if resp.Msg.TipHeight != 12 {
-		t.Errorf("tip height = %d, want 12", resp.Msg.TipHeight)
+	if resp.TipHeight != 12 {
+		t.Errorf("tip height = %d, want 12", resp.TipHeight)
 	}
 }
 
diff --git a/sidechain-orchestrator/sidechain/thunder/handler_node_test.go b/sidechain-orchestrator/sidechain/thunder/handler_node_test.go
index 9b37a300d6..738e321449 100644
--- a/sidechain-orchestrator/sidechain/thunder/handler_node_test.go
+++ b/sidechain-orchestrator/sidechain/thunder/handler_node_test.go
@@ -7,7 +7,7 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -35,11 +35,11 @@ func TestWalletCallsUseNodeWithIndex(t *testing.T) {
 			result: `{"total_sats":7000,"available_sats":6000}`, request: "balance",
 			want: [2]int64{7000, 6000},
 			call: func(h *Handler) (any, error) {
-				resp, err := h.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
+				resp, err := h.GetBalance(ctx, &pb.GetBalanceRequest{})
 				if err != nil {
 					return nil, err
 				}
-				return [2]int64{resp.Msg.TotalSats, resp.Msg.AvailableSats}, nil
+				return [2]int64{resp.TotalSats, resp.AvailableSats}, nil
 			},
 		},
 		{
@@ -55,48 +55,48 @@ func TestWalletCallsUseNodeWithIndex(t *testing.T) {
 			name: "address", method: "get_new_address",
 			result: `"node-address"`, request: "get_new_address", want: "node-address",
 			call: func(h *Handler) (any, error) {
-				resp, err := h.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+				resp, err := h.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 				if err != nil {
 					return nil, err
 				}
-				return resp.Msg.Address, nil
+				return resp.Address, nil
 			},
 		},
 		{
 			name: "transfer", method: "create_transfer",
 			result: `"transfer-id"`, request: `create_transfer ["alice",5000,100]`, want: "transfer-id",
 			call: func(h *Handler) (any, error) {
-				resp, err := h.Transfer(ctx, connect.NewRequest(&pb.TransferRequest{
+				resp, err := h.Transfer(ctx, &pb.TransferRequest{
 					Address: "alice", AmountSats: 5000, FeeSats: 100,
-				}))
+				})
 				if err != nil {
 					return nil, err
 				}
-				return resp.Msg.Txid, nil
+				return resp.Txid, nil
 			},
 		},
 		{
 			name: "withdrawal", method: "create_withdrawal",
 			result: `"withdrawal-id"`, request: `create_withdrawal ["main-address",5000,100,200]`, want: "withdrawal-id",
 			call: func(h *Handler) (any, error) {
-				resp, err := h.Withdraw(ctx, connect.NewRequest(&pb.WithdrawRequest{
+				resp, err := h.Withdraw(ctx, &pb.WithdrawRequest{
 					Address: "main-address", AmountSats: 5000, SideFeeSats: 100, MainFeeSats: 200,
-				}))
+				})
 				if err != nil {
 					return nil, err
 				}
-				return resp.Msg.Txid, nil
+				return resp.Txid, nil
 			},
 		},
 		{
 			name: "UTXOs", method: "get_wallet_utxos",
 			result: `[]`, request: "get_wallet_utxos", want: "[]",
 			call: func(h *Handler) (any, error) {
-				resp, err := h.GetWalletUtxos(ctx, connect.NewRequest(&pb.GetWalletUtxosRequest{}))
+				resp, err := h.GetWalletUtxos(ctx, &pb.GetWalletUtxosRequest{})
 				if err != nil {
 					return nil, err
 				}
-				return resp.Msg.UtxosJson, nil
+				return resp.UtxosJson, nil
 			},
 		},
 	}
@@ -137,12 +137,12 @@ func TestWalletUTXOsKeepMempoolWithIndex(t *testing.T) {
 		]}}]`,
 	})
 	h := NewHandlerWithIndex(proxy, "http://127.0.0.1:1")
-	resp, err := h.GetWalletUtxos(context.Background(), connect.NewRequest(&pb.GetWalletUtxosRequest{}))
+	resp, err := h.GetWalletUtxos(context.Background(), &pb.GetWalletUtxosRequest{})
 	require.NoError(t, err)
 	assert.JSONEq(t, `[
 		{"outpoint":{"Regular":{"txid":"old","vout":0}},"output":{"address":"mine","content":{"Value":2000}}},
 		{"outpoint":{"Regular":{"txid":"pending","vout":0}},"output":{"address":"mine","content":{"Value":10000}},"confirmed":false}
-	]`, resp.Msg.UtxosJson)
+	]`, resp.UtxosJson)
 	assert.Equal(t, []string{"get_wallet_utxos", "get_wallet_addresses", "list_mempool"}, *seen)
 }
 
@@ -155,9 +155,9 @@ func TestWalletUTXOsAskNoBlockTemplate(t *testing.T) {
 		"get_wallet_utxos":     confirmed,
 		"get_wallet_addresses": `["mine"]`,
 	})
-	resp, err := NewHandler(proxy).GetWalletUtxos(context.Background(), connect.NewRequest(&pb.GetWalletUtxosRequest{}))
+	resp, err := NewHandler(proxy).GetWalletUtxos(context.Background(), &pb.GetWalletUtxosRequest{})
 	require.NoError(t, err)
-	assert.JSONEq(t, confirmed, resp.Msg.UtxosJson)
+	assert.JSONEq(t, confirmed, resp.UtxosJson)
 	assert.Equal(t, []string{"get_wallet_utxos", "get_wallet_addresses", "list_mempool"}, *seen)
 }
 
@@ -168,7 +168,7 @@ func TestListTransactionsReportsIndexError(t *testing.T) {
 	}))
 	defer index.Close()
 	_, err := NewHandlerWithIndex(proxy, index.URL).ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	require.ErrorContains(t, err, "503")
 	assert.Equal(t, connect.CodeUnavailable, connect.CodeOf(err))
 	assert.Equal(t, []string{"get_wallet_addresses"}, *seen)
@@ -190,13 +190,13 @@ func TestListTransactionsReadsEmptyIndex(t *testing.T) {
 	}))
 	defer index.Close()
 	resp, err := NewHandlerWithIndex(proxy, index.URL).ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	require.NoError(t, err)
-	assert.Zero(t, resp.Msg.TipHeight)
-	require.Len(t, resp.Msg.Transactions, 1)
-	assert.Equal(t, "pending", resp.Msg.Transactions[0].Txid)
-	assert.Equal(t, int64(100), resp.Msg.Transactions[0].ValueSats)
-	assert.False(t, resp.Msg.Transactions[0].Confirmed)
+	assert.Zero(t, resp.TipHeight)
+	require.Len(t, resp.Transactions, 1)
+	assert.Equal(t, "pending", resp.Transactions[0].Txid)
+	assert.Equal(t, int64(100), resp.Transactions[0].ValueSats)
+	assert.False(t, resp.Transactions[0].Confirmed)
 	assert.Equal(t, []string{"get_wallet_addresses"}, *seen)
 }
 
@@ -204,8 +204,8 @@ func TestListTransactionsReadsEmptyIndex(t *testing.T) {
 func TestGetBmmInclusionsReadsTheList(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"get_bmm_inclusions": `["main-a","main-b"]`})
 	resp, err := NewHandler(proxy).GetBmmInclusions(context.Background(),
-		connect.NewRequest(&pb.GetBmmInclusionsRequest{BlockHash: "side"}))
+		&pb.GetBmmInclusionsRequest{BlockHash: "side"})
 	require.NoError(t, err)
-	assert.JSONEq(t, `["main-a","main-b"]`, resp.Msg.Inclusions)
+	assert.JSONEq(t, `["main-a","main-b"]`, resp.Inclusions)
 	assert.Equal(t, []string{`get_bmm_inclusions ["side"]`}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain/thunder/history_test.go b/sidechain-orchestrator/sidechain/thunder/history_test.go
index 52321fd872..2c39426ccb 100644
--- a/sidechain-orchestrator/sidechain/thunder/history_test.go
+++ b/sidechain-orchestrator/sidechain/thunder/history_test.go
@@ -7,8 +7,6 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"connectrpc.com/connect"
-
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/thunder/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
 )
@@ -53,13 +51,13 @@ func TestLocalHistoryFromTheNode(t *testing.T) {
 
 	h := NewHandlerWithIndex(proxy, "")
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 
 	got := map[string]int64{}
-	for _, tx := range resp.Msg.Transactions {
+	for _, tx := range resp.Transactions {
 		got[tx.Txid] = tx.ValueSats
 	}
 	// aa funded 7000 and still holds it. bb funded 3000, and cc took it away.
@@ -93,13 +91,13 @@ func TestLocalHistoryCountsAWithdrawalAsMoneyLeaving(t *testing.T) {
 
 	h := NewHandlerWithIndex(proxy, "")
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 
 	got := map[string]int64{}
-	for _, tx := range resp.Msg.Transactions {
+	for _, tx := range resp.Transactions {
 		got[tx.Txid] = tx.ValueSats
 	}
 	// 10000 in, 4900 back as change. The payout, the mainchain fee and the
@@ -124,12 +122,12 @@ func TestLocalHistoryRecordsABundleSpend(t *testing.T) {
 
 	h := NewHandlerWithIndex(proxy, "")
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 	got := map[string]int64{}
-	for _, tx := range resp.Msg.Transactions {
+	for _, tx := range resp.Transactions {
 		got[tx.Txid] = tx.ValueSats
 	}
 	if got["m6"] != -9000 {
@@ -142,12 +140,12 @@ func TestLocalHistoryWithNoAddresses(t *testing.T) {
 	proxy := nodeWith(t, map[string]string{"get_wallet_addresses": `[]`})
 	h := NewHandlerWithIndex(proxy, "")
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
-	if len(resp.Msg.Transactions) != 0 {
-		t.Errorf("got %d transactions, want none", len(resp.Msg.Transactions))
+	if len(resp.Transactions) != 0 {
+		t.Errorf("got %d transactions, want none", len(resp.Transactions))
 	}
 }
 
@@ -164,14 +162,14 @@ func TestLocalHistorySplitsADepositOutpoint(t *testing.T) {
 
 	h := NewHandlerWithIndex(proxy, "")
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
-	if len(resp.Msg.Transactions) != 1 {
-		t.Fatalf("got %d transactions, want 1", len(resp.Msg.Transactions))
+	if len(resp.Transactions) != 1 {
+		t.Fatalf("got %d transactions, want 1", len(resp.Transactions))
 	}
-	got := resp.Msg.Transactions[0]
+	got := resp.Transactions[0]
 	if got.Txid != mainTxid {
 		t.Errorf("txid = %q, want the mainchain txid alone", got.Txid)
 	}
@@ -192,11 +190,11 @@ func TestLocalHistoryKeepsTheOutputIndex(t *testing.T) {
 
 	h := NewHandlerWithIndex(proxy, "")
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
-	if got := resp.Msg.Transactions[0]; got.Vout != 1 {
+	if got := resp.Transactions[0]; got.Vout != 1 {
 		t.Errorf("vout = %d, want 1", got.Vout)
 	}
 }
@@ -221,14 +219,14 @@ func TestLocalHistoryNamesACoinbaseOutpoint(t *testing.T) {
 
 			h := NewHandlerWithIndex(proxy, "")
 			resp, err := h.ListWalletTransactions(context.Background(),
-				connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+				&pb.ListWalletTransactionsRequest{})
 			if err != nil {
 				t.Fatalf("list: %v", err)
 			}
-			if len(resp.Msg.Transactions) != 1 {
-				t.Fatalf("got %d transactions, want 1", len(resp.Msg.Transactions))
+			if len(resp.Transactions) != 1 {
+				t.Fatalf("got %d transactions, want 1", len(resp.Transactions))
 			}
-			got := resp.Msg.Transactions[0]
+			got := resp.Transactions[0]
 			if got.Txid != tc.want {
 				t.Errorf("txid = %q, want %q", got.Txid, tc.want)
 			}
@@ -243,12 +241,12 @@ func historyOf(t *testing.T, results map[string]string) map[string]*pb.Sidechain
 	t.Helper()
 	h := NewHandlerWithIndex(nodeWith(t, results), "")
 	resp, err := h.ListWalletTransactions(context.Background(),
-		connect.NewRequest(&pb.ListWalletTransactionsRequest{}))
+		&pb.ListWalletTransactionsRequest{})
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 	got := map[string]*pb.SidechainWalletTransaction{}
-	for _, tx := range resp.Msg.Transactions {
+	for _, tx := range resp.Transactions {
 		got[tx.Txid] = tx
 	}
 	return got
diff --git a/sidechain-orchestrator/sidechain/thunder/send_method_test.go b/sidechain-orchestrator/sidechain/thunder/send_method_test.go
index 1abc1764b6..4de9268eb3 100644
--- a/sidechain-orchestrator/sidechain/thunder/send_method_test.go
+++ b/sidechain-orchestrator/sidechain/thunder/send_method_test.go
@@ -7,7 +7,6 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -52,11 +51,11 @@ func TestTransferCallsCreateTransfer(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"create_transfer": `"txid1"`})
 
 	resp, err := NewHandler(proxy).Transfer(context.Background(),
-		connect.NewRequest(&pb.TransferRequest{
+		&pb.TransferRequest{
 			Address: "ocPdhEToXd9myNCN8si5mGxdaRQ", AmountSats: 50_000_000, FeeSats: 1000,
-		}))
+		})
 	require.NoError(t, err)
-	assert.Equal(t, "txid1", resp.Msg.Txid)
+	assert.Equal(t, "txid1", resp.Txid)
 	assert.Equal(t, []string{`create_transfer ["ocPdhEToXd9myNCN8si5mGxdaRQ",50000000,1000]`}, *seen)
 }
 
@@ -64,11 +63,11 @@ func TestWithdrawCallsCreateWithdrawal(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"create_withdrawal": `"txid2"`})
 
 	resp, err := NewHandler(proxy).Withdraw(context.Background(),
-		connect.NewRequest(&pb.WithdrawRequest{
+		&pb.WithdrawRequest{
 			Address: "bc1qexample", AmountSats: 10_000, SideFeeSats: 1000, MainFeeSats: 2000,
-		}))
+		})
 	require.NoError(t, err)
-	assert.Equal(t, "txid2", resp.Msg.Txid)
+	assert.Equal(t, "txid2", resp.Txid)
 	assert.Equal(t, []string{`create_withdrawal ["bc1qexample",10000,1000,2000]`}, *seen)
 }
 
@@ -76,8 +75,8 @@ func TestSidechainWealthCallsSidechainWealth(t *testing.T) {
 	proxy, seen := sendMethodNode(t, map[string]string{"sidechain_wealth": `10603007000`})
 
 	resp, err := NewHandler(proxy).GetSidechainWealth(context.Background(),
-		connect.NewRequest(&pb.GetSidechainWealthRequest{}))
+		&pb.GetSidechainWealthRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, int64(10603007000), resp.Msg.Sats)
+	assert.Equal(t, int64(10603007000), resp.Sats)
 	assert.Equal(t, []string{"sidechain_wealth"}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain/thunder/testdata/openapi_schema.json b/sidechain-orchestrator/sidechain/thunder/testdata/openapi_schema.json
index 4fd1142858..d921b356b0 100644
--- a/sidechain-orchestrator/sidechain/thunder/testdata/openapi_schema.json
+++ b/sidechain-orchestrator/sidechain/thunder/testdata/openapi_schema.json
@@ -197,6 +197,52 @@
         }
       }
     },
+    "create_transfer_many": {
+      "post": {
+        "description": "Create a tx that transfers funds to each address in `dests`,\nwhich maps an address to a value in sats.",
+        "operationId": "create_transfer_many",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "dests": {
+                    "type": "object",
+                    "description": "Destinations of a transfer. Each address takes a value in sats.",
+                    "additionalProperties": {
+                      "type": "integer",
+                      "format": "u-int64",
+                      "minimum": 0
+                    },
+                    "propertyNames": {
+                      "type": "string"
+                    }
+                  },
+                  "fee_sats": {
+                    "type": "integer",
+                    "format": "u-int64",
+                    "minimum": 0
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "create_withdrawal": {
       "post": {
         "description": "Creates a tx that initiates a withdrawal to the specified mainchain\naddress",
diff --git a/sidechain-orchestrator/sidechain/truthcoin/handler.go b/sidechain-orchestrator/sidechain/truthcoin/handler.go
index 4150d8d8f4..033dd403d6 100644
--- a/sidechain-orchestrator/sidechain/truthcoin/handler.go
+++ b/sidechain-orchestrator/sidechain/truthcoin/handler.go
@@ -5,8 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"connectrpc.com/connect"
-
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/truthcoin/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/truthcoin/v1/truthcoinv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
@@ -39,283 +37,283 @@ func (h *Handler) WalletBalance(ctx context.Context) (total, available int64, er
 
 // --- Common Node methods ---
 
-func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *Handler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	total, available, err := h.WalletBalance(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		TotalSats:     total,
 		AvailableSats: available,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, req *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, req *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.proxy.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, req *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, req *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.proxy.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
 
-func (h *Handler) GetNewAddress(ctx context.Context, req *connect.Request[pb.GetNewAddressRequest]) (*connect.Response[pb.GetNewAddressResponse], error) {
+func (h *Handler) GetNewAddress(ctx context.Context, req *pb.GetNewAddressRequest) (*pb.GetNewAddressResponse, error) {
 	address, err := h.proxy.GetNewAddress(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewAddressResponse{Address: address}), nil
+	return &pb.GetNewAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) Withdraw(ctx context.Context, req *connect.Request[pb.WithdrawRequest]) (*connect.Response[pb.WithdrawResponse], error) {
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.SideFeeSats, req.Msg.MainFeeSats}
+func (h *Handler) Withdraw(ctx context.Context, req *pb.WithdrawRequest) (*pb.WithdrawResponse, error) {
+	params := []any{req.Address, req.AmountSats, req.SideFeeSats, req.MainFeeSats}
 	var txid string
 	if err := h.proxy.Client.Call(ctx, "create_withdrawal", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.WithdrawResponse{Txid: txid}), nil
+	return &pb.WithdrawResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.TransferRequest]) (*connect.Response[pb.TransferResponse], error) {
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats}
+func (h *Handler) Transfer(ctx context.Context, req *pb.TransferRequest) (*pb.TransferResponse, error) {
+	params := []any{req.Address, req.AmountSats, req.FeeSats}
 	var txid string
 	if err := h.proxy.Client.Call(ctx, "create_transfer", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferResponse{Txid: txid}), nil
+	return &pb.TransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Mine(ctx context.Context, req *connect.Request[pb.MineRequest]) (*connect.Response[pb.MineResponse], error) {
-	raw, err := h.proxy.Mine(ctx, req.Msg.FeeSats)
+func (h *Handler) Mine(ctx context.Context, req *pb.MineRequest) (*pb.MineResponse, error) {
+	raw, err := h.proxy.Mine(ctx, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MineResponse{BmmResultJson: string(raw)}), nil
+	return &pb.MineResponse{BmmResultJson: string(raw)}, nil
 }
 
-func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[pb.GetPendingWithdrawalBundleRequest]) (*connect.Response[pb.GetPendingWithdrawalBundleResponse], error) {
+func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *pb.GetPendingWithdrawalBundleRequest) (*pb.GetPendingWithdrawalBundleResponse, error) {
 	raw, err := h.proxy.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}), nil
+	return &pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.GetWalletUtxosRequest]) (*connect.Response[pb.GetWalletUtxosResponse], error) {
+func (h *Handler) GetWalletUtxos(ctx context.Context, req *pb.GetWalletUtxosRequest) (*pb.GetWalletUtxosResponse, error) {
 	raw, err := h.proxy.GetWalletUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.GetWalletUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, req *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, req *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	raw, err := h.proxy.ListUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.ListUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) RemoveFromMempool(ctx context.Context, req *connect.Request[pb.RemoveFromMempoolRequest]) (*connect.Response[pb.RemoveFromMempoolResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Msg.Txid}, nil); err != nil {
+func (h *Handler) RemoveFromMempool(ctx context.Context, req *pb.RemoveFromMempoolRequest) (*pb.RemoveFromMempoolResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Txid}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RemoveFromMempoolResponse{}), nil
+	return &pb.RemoveFromMempoolResponse{}, nil
 }
 
-func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[pb.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[pb.GetLatestFailedWithdrawalBundleHeightResponse], error) {
+func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *pb.GetLatestFailedWithdrawalBundleHeightRequest) (*pb.GetLatestFailedWithdrawalBundleHeightResponse, error) {
 	height, err := h.proxy.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}), nil
+	return &pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}, nil
 }
 
-func (h *Handler) GenerateMnemonic(ctx context.Context, req *connect.Request[pb.GenerateMnemonicRequest]) (*connect.Response[pb.GenerateMnemonicResponse], error) {
+func (h *Handler) GenerateMnemonic(ctx context.Context, req *pb.GenerateMnemonicRequest) (*pb.GenerateMnemonicResponse, error) {
 	var mnemonic string
 	if err := h.proxy.Client.Call(ctx, "generate_mnemonic", nil, &mnemonic); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GenerateMnemonicResponse{Mnemonic: mnemonic}), nil
+	return &pb.GenerateMnemonicResponse{Mnemonic: mnemonic}, nil
 }
 
-func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[pb.SetSeedFromMnemonicRequest]) (*connect.Response[pb.SetSeedFromMnemonicResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Msg.Mnemonic}, nil); err != nil {
+func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *pb.SetSeedFromMnemonicRequest) (*pb.SetSeedFromMnemonicResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Mnemonic}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SetSeedFromMnemonicResponse{}), nil
+	return &pb.SetSeedFromMnemonicResponse{}, nil
 }
 
-func (h *Handler) CallRaw(ctx context.Context, req *connect.Request[pb.CallRawRequest]) (*connect.Response[pb.CallRawResponse], error) {
+func (h *Handler) CallRaw(ctx context.Context, req *pb.CallRawRequest) (*pb.CallRawResponse, error) {
 	var params any
-	if req.Msg.ParamsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.ParamsJson), &params); err != nil {
+	if req.ParamsJson != "" {
+		if err := json.Unmarshal([]byte(req.ParamsJson), &params); err != nil {
 			return nil, fmt.Errorf("unmarshal params: %w", err)
 		}
 	}
-	raw, err := h.proxy.CallRaw(ctx, req.Msg.Method, params)
+	raw, err := h.proxy.CallRaw(ctx, req.Method, params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CallRawResponse{ResultJson: string(raw)}), nil
+	return &pb.CallRawResponse{ResultJson: string(raw)}, nil
 }
 
 // --- Truthcoin-specific methods ---
 
-func (h *Handler) GetSidechainWealth(ctx context.Context, req *connect.Request[pb.GetSidechainWealthRequest]) (*connect.Response[pb.GetSidechainWealthResponse], error) {
+func (h *Handler) GetSidechainWealth(ctx context.Context, req *pb.GetSidechainWealthRequest) (*pb.GetSidechainWealthResponse, error) {
 	var sats int64
 	if err := h.proxy.Client.Call(ctx, "sidechain_wealth", nil, &sats); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainWealthResponse{Sats: sats}), nil
+	return &pb.GetSidechainWealthResponse{Sats: sats}, nil
 }
 
-func (h *Handler) CreateDeposit(ctx context.Context, req *connect.Request[pb.CreateDepositRequest]) (*connect.Response[pb.CreateDepositResponse], error) {
+func (h *Handler) CreateDeposit(ctx context.Context, req *pb.CreateDepositRequest) (*pb.CreateDepositResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.ValueSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.ValueSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_deposit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CreateDepositResponse{Txid: txid}), nil
+	return &pb.CreateDepositResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ConnectPeer(ctx context.Context, req *connect.Request[pb.ConnectPeerRequest]) (*connect.Response[pb.ConnectPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ConnectPeer(ctx context.Context, req *pb.ConnectPeerRequest) (*pb.ConnectPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ConnectPeerResponse{}), nil
+	return &pb.ConnectPeerResponse{}, nil
 }
 
-func (h *Handler) ListPeers(ctx context.Context, req *connect.Request[pb.ListPeersRequest]) (*connect.Response[pb.ListPeersResponse], error) {
+func (h *Handler) ListPeers(ctx context.Context, req *pb.ListPeersRequest) (*pb.ListPeersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_peers", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListPeersResponse{PeersJson: string(raw)}), nil
+	return &pb.ListPeersResponse{PeersJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBlock(ctx context.Context, req *connect.Request[pb.GetBlockRequest]) (*connect.Response[pb.GetBlockResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Msg.Hash})
+func (h *Handler) GetBlock(ctx context.Context, req *pb.GetBlockRequest) (*pb.GetBlockResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Hash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockResponse{BlockJson: optionalJSON(raw)}), nil
+	return &pb.GetBlockResponse{BlockJson: optionalJSON(raw)}, nil
 }
 
-func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestMainchainBlockHashRequest]) (*connect.Response[pb.GetBestMainchainBlockHashResponse], error) {
+func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *pb.GetBestMainchainBlockHashRequest) (*pb.GetBestMainchainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_mainchain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestMainchainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestMainchainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestSidechainBlockHashRequest]) (*connect.Response[pb.GetBestSidechainBlockHashResponse], error) {
+func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *pb.GetBestSidechainBlockHashRequest) (*pb.GetBestSidechainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_sidechain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestSidechainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestSidechainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBmmInclusions(ctx context.Context, req *connect.Request[pb.GetBmmInclusionsRequest]) (*connect.Response[pb.GetBmmInclusionsResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.Msg.BlockHash})
+func (h *Handler) GetBmmInclusions(ctx context.Context, req *pb.GetBmmInclusionsRequest) (*pb.GetBmmInclusionsResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.BlockHash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmInclusionsResponse{Inclusions: string(raw)}), nil
+	return &pb.GetBmmInclusionsResponse{Inclusions: string(raw)}, nil
 }
 
-func (h *Handler) RefreshWallet(ctx context.Context, req *connect.Request[pb.RefreshWalletRequest]) (*connect.Response[pb.RefreshWalletResponse], error) {
+func (h *Handler) RefreshWallet(ctx context.Context, req *pb.RefreshWalletRequest) (*pb.RefreshWalletResponse, error) {
 	if err := h.proxy.Client.Call(ctx, "refresh_wallet", nil, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RefreshWalletResponse{}), nil
+	return &pb.RefreshWalletResponse{}, nil
 }
 
-func (h *Handler) GetTransaction(ctx context.Context, req *connect.Request[pb.GetTransactionRequest]) (*connect.Response[pb.GetTransactionResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_transaction", []any{req.Msg.Txid})
+func (h *Handler) GetTransaction(ctx context.Context, req *pb.GetTransactionRequest) (*pb.GetTransactionResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_transaction", []any{req.Txid})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetTransactionResponse{TransactionJson: string(raw)}), nil
+	return &pb.GetTransactionResponse{TransactionJson: string(raw)}, nil
 }
 
-func (h *Handler) GetTransactionInfo(ctx context.Context, req *connect.Request[pb.GetTransactionInfoRequest]) (*connect.Response[pb.GetTransactionInfoResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_transaction_info", []any{req.Msg.Txid})
+func (h *Handler) GetTransactionInfo(ctx context.Context, req *pb.GetTransactionInfoRequest) (*pb.GetTransactionInfoResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_transaction_info", []any{req.Txid})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetTransactionInfoResponse{TransactionInfoJson: string(raw)}), nil
+	return &pb.GetTransactionInfoResponse{TransactionInfoJson: string(raw)}, nil
 }
 
-func (h *Handler) GetWalletAddresses(ctx context.Context, req *connect.Request[pb.GetWalletAddressesRequest]) (*connect.Response[pb.GetWalletAddressesResponse], error) {
+func (h *Handler) GetWalletAddresses(ctx context.Context, req *pb.GetWalletAddressesRequest) (*pb.GetWalletAddressesResponse, error) {
 	var addresses []string
 	if err := h.proxy.Client.Call(ctx, "get_wallet_addresses", nil, &addresses); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetWalletAddressesResponse{Addresses: addresses}), nil
+	return &pb.GetWalletAddressesResponse{Addresses: addresses}, nil
 }
 
-func (h *Handler) MyUtxos(ctx context.Context, req *connect.Request[pb.MyUtxosRequest]) (*connect.Response[pb.MyUtxosResponse], error) {
+func (h *Handler) MyUtxos(ctx context.Context, req *pb.MyUtxosRequest) (*pb.MyUtxosResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "get_wallet_utxos", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MyUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.MyUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) MyUnconfirmedUtxos(ctx context.Context, req *connect.Request[pb.MyUnconfirmedUtxosRequest]) (*connect.Response[pb.MyUnconfirmedUtxosResponse], error) {
+func (h *Handler) MyUnconfirmedUtxos(ctx context.Context, req *pb.MyUnconfirmedUtxosRequest) (*pb.MyUnconfirmedUtxosResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "my_unconfirmed_utxos", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MyUnconfirmedUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.MyUnconfirmedUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
 // --- Prediction Markets ---
 
-func (h *Handler) CalculateInitialLiquidity(ctx context.Context, req *connect.Request[pb.CalculateInitialLiquidityRequest]) (*connect.Response[pb.CalculateInitialLiquidityResponse], error) {
-	request := map[string]any{"beta": req.Msg.Beta}
-	if req.Msg.NumOutcomes != nil {
-		request["num_outcomes"] = *req.Msg.NumOutcomes
+func (h *Handler) CalculateInitialLiquidity(ctx context.Context, req *pb.CalculateInitialLiquidityRequest) (*pb.CalculateInitialLiquidityResponse, error) {
+	request := map[string]any{"beta": req.Beta}
+	if req.NumOutcomes != nil {
+		request["num_outcomes"] = *req.NumOutcomes
 	}
-	if req.Msg.Dimensions != nil {
-		request["dimensions"] = *req.Msg.Dimensions
+	if req.Dimensions != nil {
+		request["dimensions"] = *req.Dimensions
 	}
 	raw, err := h.proxy.Client.CallRaw(ctx, "calculate_initial_liquidity", []any{request})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CalculateInitialLiquidityResponse{ResultJson: string(raw)}), nil
+	return &pb.CalculateInitialLiquidityResponse{ResultJson: string(raw)}, nil
 }
 
-func (h *Handler) MarketCreate(ctx context.Context, req *connect.Request[pb.MarketCreateRequest]) (*connect.Response[pb.MarketCreateResponse], error) {
+func (h *Handler) MarketCreate(ctx context.Context, req *pb.MarketCreateRequest) (*pb.MarketCreateResponse, error) {
 	var dimensions []any
-	if err := json.Unmarshal([]byte(req.Msg.Dimensions), &dimensions); err != nil {
+	if err := json.Unmarshal([]byte(req.Dimensions), &dimensions); err != nil {
 		return nil, fmt.Errorf("unmarshal dimensions: %w", err)
 	}
 	request := map[string]any{
-		"title":       req.Msg.Title,
-		"description": req.Msg.Description,
+		"title":       req.Title,
+		"description": req.Description,
 		"dimensions":  dimensions,
-		"tx_fee_sats": req.Msg.FeeSats,
+		"tx_fee_sats": req.FeeSats,
 	}
-	if req.Msg.Beta != nil {
-		request["beta"] = *req.Msg.Beta
+	if req.Beta != nil {
+		request["beta"] = *req.Beta
 	}
-	if req.Msg.TradingFee != nil {
-		request["trading_fee"] = *req.Msg.TradingFee
+	if req.TradingFee != nil {
+		request["trading_fee"] = *req.TradingFee
 	}
-	if req.Msg.InitialLiquidity != nil {
-		request["initial_liquidity"] = *req.Msg.InitialLiquidity
+	if req.InitialLiquidity != nil {
+		request["initial_liquidity"] = *req.InitialLiquidity
 	}
 	var result struct {
 		Txid string `json:"txid"`
@@ -323,83 +321,83 @@ func (h *Handler) MarketCreate(ctx context.Context, req *connect.Request[pb.Mark
 	if err := h.proxy.Client.Call(ctx, "market_create", []any{request}, &result); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MarketCreateResponse{Txid: result.Txid}), nil
+	return &pb.MarketCreateResponse{Txid: result.Txid}, nil
 }
 
-func (h *Handler) MarketList(ctx context.Context, req *connect.Request[pb.MarketListRequest]) (*connect.Response[pb.MarketListResponse], error) {
+func (h *Handler) MarketList(ctx context.Context, req *pb.MarketListRequest) (*pb.MarketListResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "market_list", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MarketListResponse{MarketsJson: string(raw)}), nil
+	return &pb.MarketListResponse{MarketsJson: string(raw)}, nil
 }
 
-func (h *Handler) MarketGet(ctx context.Context, req *connect.Request[pb.MarketGetRequest]) (*connect.Response[pb.MarketGetResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "market_get", []any{req.Msg.MarketId})
+func (h *Handler) MarketGet(ctx context.Context, req *pb.MarketGetRequest) (*pb.MarketGetResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "market_get", []any{req.MarketId})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MarketGetResponse{MarketJson: optionalJSON(raw)}), nil
+	return &pb.MarketGetResponse{MarketJson: optionalJSON(raw)}, nil
 }
 
-func (h *Handler) MarketBuy(ctx context.Context, req *connect.Request[pb.MarketBuyRequest]) (*connect.Response[pb.MarketBuyResponse], error) {
+func (h *Handler) MarketBuy(ctx context.Context, req *pb.MarketBuyRequest) (*pb.MarketBuyResponse, error) {
 	request := map[string]any{
-		"market_id":     req.Msg.MarketId,
-		"outcome_index": req.Msg.OutcomeIndex,
-		"shares_amount": int64(req.Msg.SharesAmount),
+		"market_id":     req.MarketId,
+		"outcome_index": req.OutcomeIndex,
+		"shares_amount": int64(req.SharesAmount),
 	}
-	if req.Msg.DryRun != nil {
-		request["dry_run"] = *req.Msg.DryRun
+	if req.DryRun != nil {
+		request["dry_run"] = *req.DryRun
 	}
-	if req.Msg.MaxCost != nil {
-		request["max_cost"] = *req.Msg.MaxCost
+	if req.MaxCost != nil {
+		request["max_cost"] = *req.MaxCost
 	}
 	raw, err := h.proxy.Client.CallRaw(ctx, "market_buy", []any{request})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MarketBuyResponse{ResultJson: string(raw)}), nil
+	return &pb.MarketBuyResponse{ResultJson: string(raw)}, nil
 }
 
-func (h *Handler) MarketSell(ctx context.Context, req *connect.Request[pb.MarketSellRequest]) (*connect.Response[pb.MarketSellResponse], error) {
+func (h *Handler) MarketSell(ctx context.Context, req *pb.MarketSellRequest) (*pb.MarketSellResponse, error) {
 	request := map[string]any{
-		"market_id":      req.Msg.MarketId,
-		"outcome_index":  req.Msg.OutcomeIndex,
-		"shares_amount":  req.Msg.SharesAmount,
-		"seller_address": req.Msg.SellerAddress,
+		"market_id":      req.MarketId,
+		"outcome_index":  req.OutcomeIndex,
+		"shares_amount":  req.SharesAmount,
+		"seller_address": req.SellerAddress,
 	}
-	if req.Msg.DryRun != nil {
-		request["dry_run"] = *req.Msg.DryRun
+	if req.DryRun != nil {
+		request["dry_run"] = *req.DryRun
 	}
-	if req.Msg.MinProceeds != nil {
-		request["min_proceeds"] = *req.Msg.MinProceeds
+	if req.MinProceeds != nil {
+		request["min_proceeds"] = *req.MinProceeds
 	}
 	raw, err := h.proxy.Client.CallRaw(ctx, "market_sell", []any{request})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MarketSellResponse{ResultJson: string(raw)}), nil
+	return &pb.MarketSellResponse{ResultJson: string(raw)}, nil
 }
 
-func (h *Handler) MarketPositions(ctx context.Context, req *connect.Request[pb.MarketPositionsRequest]) (*connect.Response[pb.MarketPositionsResponse], error) {
-	params := []any{req.Msg.Address, req.Msg.MarketId}
+func (h *Handler) MarketPositions(ctx context.Context, req *pb.MarketPositionsRequest) (*pb.MarketPositionsResponse, error) {
+	params := []any{req.Address, req.MarketId}
 	raw, err := h.proxy.Client.CallRaw(ctx, "market_positions", params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MarketPositionsResponse{PositionsJson: string(raw)}), nil
+	return &pb.MarketPositionsResponse{PositionsJson: string(raw)}, nil
 }
 
-func (h *Handler) MarketAmplifyBeta(ctx context.Context, req *connect.Request[pb.MarketAmplifyBetaRequest]) (*connect.Response[pb.MarketAmplifyBetaResponse], error) {
+func (h *Handler) MarketAmplifyBeta(ctx context.Context, req *pb.MarketAmplifyBetaRequest) (*pb.MarketAmplifyBetaResponse, error) {
 	request := map[string]any{
-		"market_id":   req.Msg.MarketId,
-		"amount_sats": req.Msg.AmountSats,
+		"market_id":   req.MarketId,
+		"amount_sats": req.AmountSats,
 	}
 	var txid string
 	if err := h.proxy.Client.Call(ctx, "market_amplify_beta", []any{request}, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MarketAmplifyBetaResponse{Txid: txid}), nil
+	return &pb.MarketAmplifyBetaResponse{Txid: txid}, nil
 }
 
 // --- Slots ---
@@ -414,32 +412,32 @@ func (h *Handler) claimDecisions(ctx context.Context, claim map[string]any) (str
 	return result.Txid, nil
 }
 
-func (h *Handler) SlotStatus(ctx context.Context, req *connect.Request[pb.SlotStatusRequest]) (*connect.Response[pb.SlotStatusResponse], error) {
+func (h *Handler) SlotStatus(ctx context.Context, req *pb.SlotStatusRequest) (*pb.SlotStatusResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "decision_status", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SlotStatusResponse{StatusJson: string(raw)}), nil
+	return &pb.SlotStatusResponse{StatusJson: string(raw)}, nil
 }
 
-func (h *Handler) SlotList(ctx context.Context, req *connect.Request[pb.SlotListRequest]) (*connect.Response[pb.SlotListResponse], error) {
+func (h *Handler) SlotList(ctx context.Context, req *pb.SlotListRequest) (*pb.SlotListResponse, error) {
 	filter := map[string]any{
-		"period": req.Msg.Period,
-		"status": req.Msg.Status,
+		"period": req.Period,
+		"status": req.Status,
 	}
 	raw, err := h.proxy.Client.CallRaw(ctx, "decision_list", []any{filter})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SlotListResponse{SlotsJson: string(raw)}), nil
+	return &pb.SlotListResponse{SlotsJson: string(raw)}, nil
 }
 
-func (h *Handler) SlotGet(ctx context.Context, req *connect.Request[pb.SlotGetRequest]) (*connect.Response[pb.SlotGetResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "decision_get", []any{req.Msg.SlotId})
+func (h *Handler) SlotGet(ctx context.Context, req *pb.SlotGetRequest) (*pb.SlotGetResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "decision_get", []any{req.SlotId})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SlotGetResponse{SlotJson: optionalJSON(raw)}), nil
+	return &pb.SlotGetResponse{SlotJson: optionalJSON(raw)}, nil
 }
 
 // optionalJSON maps the JSON null a node returns for a missing item to "",
@@ -451,124 +449,124 @@ func optionalJSON(raw json.RawMessage) string {
 	return string(raw)
 }
 
-func (h *Handler) SlotClaim(ctx context.Context, req *connect.Request[pb.SlotClaimRequest]) (*connect.Response[pb.SlotClaimResponse], error) {
+func (h *Handler) SlotClaim(ctx context.Context, req *pb.SlotClaimRequest) (*pb.SlotClaimResponse, error) {
 	decisionType := "binary"
-	if req.Msg.GetIsScaled() {
+	if req.GetIsScaled() {
 		decisionType = "scaled"
 	}
 	txid, err := h.claimDecisions(ctx, map[string]any{
 		"decision_type": decisionType,
 		"decisions": []any{map[string]any{
-			"period_index": req.Msg.PeriodIndex,
-			"header":       req.Msg.Question,
+			"period_index": req.PeriodIndex,
+			"header":       req.Question,
 		}},
-		"min":         req.Msg.Min,
-		"max":         req.Msg.Max,
-		"tx_fee_sats": req.Msg.FeeSats,
+		"min":         req.Min,
+		"max":         req.Max,
+		"tx_fee_sats": req.FeeSats,
 	})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SlotClaimResponse{Txid: txid}), nil
+	return &pb.SlotClaimResponse{Txid: txid}, nil
 }
 
-func (h *Handler) SlotClaimCategory(ctx context.Context, req *connect.Request[pb.SlotClaimCategoryRequest]) (*connect.Response[pb.SlotClaimCategoryResponse], error) {
+func (h *Handler) SlotClaimCategory(ctx context.Context, req *pb.SlotClaimCategoryRequest) (*pb.SlotClaimCategoryResponse, error) {
 	decisions := []any{}
-	if req.Msg.SlotsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.SlotsJson), &decisions); err != nil {
+	if req.SlotsJson != "" {
+		if err := json.Unmarshal([]byte(req.SlotsJson), &decisions); err != nil {
 			return nil, fmt.Errorf("unmarshal slots: %w", err)
 		}
 	}
 	txid, err := h.claimDecisions(ctx, map[string]any{
 		"decision_type": "category",
 		"decisions":     decisions,
-		"tx_fee_sats":   req.Msg.FeeSats,
+		"tx_fee_sats":   req.FeeSats,
 	})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SlotClaimCategoryResponse{Txid: txid}), nil
+	return &pb.SlotClaimCategoryResponse{Txid: txid}, nil
 }
 
 // --- Voting ---
 
-func (h *Handler) GetVoterAddress(ctx context.Context, req *connect.Request[pb.GetVoterAddressRequest]) (*connect.Response[pb.GetVoterAddressResponse], error) {
+func (h *Handler) GetVoterAddress(ctx context.Context, req *pb.GetVoterAddressRequest) (*pb.GetVoterAddressResponse, error) {
 	var address string
 	if err := h.proxy.Client.Call(ctx, "get_voter_address", nil, &address); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetVoterAddressResponse{Address: address}), nil
+	return &pb.GetVoterAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) VoteVoter(ctx context.Context, req *connect.Request[pb.VoteVoterRequest]) (*connect.Response[pb.VoteVoterResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "vote_voter", []any{req.Msg.Address})
+func (h *Handler) VoteVoter(ctx context.Context, req *pb.VoteVoterRequest) (*pb.VoteVoterResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "vote_voter", []any{req.Address})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VoteVoterResponse{VoterJson: optionalJSON(raw)}), nil
+	return &pb.VoteVoterResponse{VoterJson: optionalJSON(raw)}, nil
 }
 
-func (h *Handler) VoteVoters(ctx context.Context, req *connect.Request[pb.VoteVotersRequest]) (*connect.Response[pb.VoteVotersResponse], error) {
+func (h *Handler) VoteVoters(ctx context.Context, req *pb.VoteVotersRequest) (*pb.VoteVotersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "vote_voters", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VoteVotersResponse{VotersJson: string(raw)}), nil
+	return &pb.VoteVotersResponse{VotersJson: string(raw)}, nil
 }
 
-func (h *Handler) VoteSubmit(ctx context.Context, req *connect.Request[pb.VoteSubmitRequest]) (*connect.Response[pb.VoteSubmitResponse], error) {
+func (h *Handler) VoteSubmit(ctx context.Context, req *pb.VoteSubmitRequest) (*pb.VoteSubmitResponse, error) {
 	var votes any
-	if req.Msg.VotesJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.VotesJson), &votes); err != nil {
+	if req.VotesJson != "" {
+		if err := json.Unmarshal([]byte(req.VotesJson), &votes); err != nil {
 			return nil, fmt.Errorf("unmarshal votes: %w", err)
 		}
 	}
 	var txid string
-	params := []any{votes, req.Msg.FeeSats}
+	params := []any{votes, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "vote_submit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VoteSubmitResponse{Txid: txid}), nil
+	return &pb.VoteSubmitResponse{Txid: txid}, nil
 }
 
-func (h *Handler) VoteList(ctx context.Context, req *connect.Request[pb.VoteListRequest]) (*connect.Response[pb.VoteListResponse], error) {
+func (h *Handler) VoteList(ctx context.Context, req *pb.VoteListRequest) (*pb.VoteListResponse, error) {
 	filter := map[string]any{
-		"voter":       req.Msg.Voter,
-		"decision_id": req.Msg.DecisionId,
-		"period_id":   req.Msg.PeriodId,
+		"voter":       req.Voter,
+		"decision_id": req.DecisionId,
+		"period_id":   req.PeriodId,
 	}
 	raw, err := h.proxy.Client.CallRaw(ctx, "vote_list", []any{filter})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VoteListResponse{VotesJson: string(raw)}), nil
+	return &pb.VoteListResponse{VotesJson: string(raw)}, nil
 }
 
-func (h *Handler) VotePeriod(ctx context.Context, req *connect.Request[pb.VotePeriodRequest]) (*connect.Response[pb.VotePeriodResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "vote_period", []any{req.Msg.PeriodId})
+func (h *Handler) VotePeriod(ctx context.Context, req *pb.VotePeriodRequest) (*pb.VotePeriodResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "vote_period", []any{req.PeriodId})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VotePeriodResponse{PeriodJson: optionalJSON(raw)}), nil
+	return &pb.VotePeriodResponse{PeriodJson: optionalJSON(raw)}, nil
 }
 
 // --- Votecoin ---
 
-func (h *Handler) VotecoinTransfer(ctx context.Context, req *connect.Request[pb.VotecoinTransferRequest]) (*connect.Response[pb.VotecoinTransferResponse], error) {
+func (h *Handler) VotecoinTransfer(ctx context.Context, req *pb.VotecoinTransferRequest) (*pb.VotecoinTransferResponse, error) {
 	var txid string
-	params := []any{req.Msg.Dest, votecoinAmount(req.Msg.VotecoinAmount, req.Msg.Amount), req.Msg.FeeSats} //nolint:staticcheck // old clients send Amount
+	params := []any{req.Dest, votecoinAmount(req.VotecoinAmount, req.Amount), req.FeeSats} //nolint:staticcheck // old clients send Amount
 	if err := h.proxy.Client.Call(ctx, "transfer_votecoin", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VotecoinTransferResponse{Txid: txid}), nil
+	return &pb.VotecoinTransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) VotecoinBalance(ctx context.Context, req *connect.Request[pb.VotecoinBalanceRequest]) (*connect.Response[pb.VotecoinBalanceResponse], error) {
+func (h *Handler) VotecoinBalance(ctx context.Context, req *pb.VotecoinBalanceRequest) (*pb.VotecoinBalanceResponse, error) {
 	var balance float64
-	if err := h.proxy.Client.Call(ctx, "votecoin_balance", []any{req.Msg.Address}, &balance); err != nil {
+	if err := h.proxy.Client.Call(ctx, "votecoin_balance", []any{req.Address}, &balance); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VotecoinBalanceResponse{Balance: int64(balance), VotecoinBalance: balance}), nil //nolint:staticcheck // old clients read Balance
+	return &pb.VotecoinBalanceResponse{Balance: int64(balance), VotecoinBalance: balance}, nil //nolint:staticcheck // old clients read Balance
 }
 
 // votecoinAmount reads the deprecated whole-unit amount when an old client
@@ -580,80 +578,80 @@ func votecoinAmount(amount *float64, deprecatedAmount int64) float64 {
 	return float64(deprecatedAmount)
 }
 
-func (h *Handler) TransferVotecoin(ctx context.Context, req *connect.Request[pb.TransferVotecoinRequest]) (*connect.Response[pb.TransferVotecoinResponse], error) {
+func (h *Handler) TransferVotecoin(ctx context.Context, req *pb.TransferVotecoinRequest) (*pb.TransferVotecoinResponse, error) {
 	var txid string
-	params := []any{req.Msg.Dest, votecoinAmount(req.Msg.VotecoinAmount, req.Msg.Amount), req.Msg.FeeSats} //nolint:staticcheck // old clients send Amount
+	params := []any{req.Dest, votecoinAmount(req.VotecoinAmount, req.Amount), req.FeeSats} //nolint:staticcheck // old clients send Amount
 	if err := h.proxy.Client.Call(ctx, "transfer_votecoin", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferVotecoinResponse{Txid: txid}), nil
+	return &pb.TransferVotecoinResponse{Txid: txid}, nil
 }
 
 // --- Crypto utilities ---
 
-func (h *Handler) GetNewEncryptionKey(ctx context.Context, req *connect.Request[pb.GetNewEncryptionKeyRequest]) (*connect.Response[pb.GetNewEncryptionKeyResponse], error) {
+func (h *Handler) GetNewEncryptionKey(ctx context.Context, req *pb.GetNewEncryptionKeyRequest) (*pb.GetNewEncryptionKeyResponse, error) {
 	var key string
 	if err := h.proxy.Client.Call(ctx, "get_new_encryption_key", nil, &key); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewEncryptionKeyResponse{Key: key}), nil
+	return &pb.GetNewEncryptionKeyResponse{Key: key}, nil
 }
 
-func (h *Handler) GetNewVerifyingKey(ctx context.Context, req *connect.Request[pb.GetNewVerifyingKeyRequest]) (*connect.Response[pb.GetNewVerifyingKeyResponse], error) {
+func (h *Handler) GetNewVerifyingKey(ctx context.Context, req *pb.GetNewVerifyingKeyRequest) (*pb.GetNewVerifyingKeyResponse, error) {
 	var key string
 	if err := h.proxy.Client.Call(ctx, "get_new_verifying_key", nil, &key); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewVerifyingKeyResponse{Key: key}), nil
+	return &pb.GetNewVerifyingKeyResponse{Key: key}, nil
 }
 
-func (h *Handler) EncryptMsg(ctx context.Context, req *connect.Request[pb.EncryptMsgRequest]) (*connect.Response[pb.EncryptMsgResponse], error) {
+func (h *Handler) EncryptMsg(ctx context.Context, req *pb.EncryptMsgRequest) (*pb.EncryptMsgResponse, error) {
 	var ciphertext string
-	params := []any{req.Msg.EncryptionPubkey, req.Msg.Msg}
+	params := []any{req.EncryptionPubkey, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "encrypt_msg", params, &ciphertext); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.EncryptMsgResponse{Ciphertext: ciphertext}), nil
+	return &pb.EncryptMsgResponse{Ciphertext: ciphertext}, nil
 }
 
-func (h *Handler) DecryptMsg(ctx context.Context, req *connect.Request[pb.DecryptMsgRequest]) (*connect.Response[pb.DecryptMsgResponse], error) {
+func (h *Handler) DecryptMsg(ctx context.Context, req *pb.DecryptMsgRequest) (*pb.DecryptMsgResponse, error) {
 	var plaintext string
-	params := []any{req.Msg.EncryptionPubkey, req.Msg.Ciphertext}
+	params := []any{req.EncryptionPubkey, req.Ciphertext}
 	if err := h.proxy.Client.Call(ctx, "decrypt_msg", params, &plaintext); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.DecryptMsgResponse{Plaintext: plaintext}), nil
+	return &pb.DecryptMsgResponse{Plaintext: plaintext}, nil
 }
 
-func (h *Handler) SignArbitraryMsg(ctx context.Context, req *connect.Request[pb.SignArbitraryMsgRequest]) (*connect.Response[pb.SignArbitraryMsgResponse], error) {
+func (h *Handler) SignArbitraryMsg(ctx context.Context, req *pb.SignArbitraryMsgRequest) (*pb.SignArbitraryMsgResponse, error) {
 	var signature string
-	params := []any{req.Msg.VerifyingKey, req.Msg.Msg}
+	params := []any{req.VerifyingKey, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "sign_arbitrary_msg", params, &signature); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SignArbitraryMsgResponse{Signature: signature}), nil
+	return &pb.SignArbitraryMsgResponse{Signature: signature}, nil
 }
 
-func (h *Handler) SignArbitraryMsgAsAddr(ctx context.Context, req *connect.Request[pb.SignArbitraryMsgAsAddrRequest]) (*connect.Response[pb.SignArbitraryMsgAsAddrResponse], error) {
+func (h *Handler) SignArbitraryMsgAsAddr(ctx context.Context, req *pb.SignArbitraryMsgAsAddrRequest) (*pb.SignArbitraryMsgAsAddrResponse, error) {
 	var result struct {
 		VerifyingKey string `json:"verifying_key"`
 		Signature    string `json:"signature"`
 	}
-	params := []any{req.Msg.Address, req.Msg.Msg}
+	params := []any{req.Address, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "sign_arbitrary_msg_as_addr", params, &result); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SignArbitraryMsgAsAddrResponse{
+	return &pb.SignArbitraryMsgAsAddrResponse{
 		VerifyingKey: result.VerifyingKey,
 		Signature:    result.Signature,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) VerifySignature(ctx context.Context, req *connect.Request[pb.VerifySignatureRequest]) (*connect.Response[pb.VerifySignatureResponse], error) {
+func (h *Handler) VerifySignature(ctx context.Context, req *pb.VerifySignatureRequest) (*pb.VerifySignatureResponse, error) {
 	var valid bool
-	params := []any{req.Msg.Signature, req.Msg.VerifyingKey, req.Msg.Dst, req.Msg.Msg}
+	params := []any{req.Signature, req.VerifyingKey, req.Dst, req.Msg}
 	if err := h.proxy.Client.Call(ctx, "verify_signature", params, &valid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.VerifySignatureResponse{Valid: valid}), nil
+	return &pb.VerifySignatureResponse{Valid: valid}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/truthcoin/handler_test.go b/sidechain-orchestrator/sidechain/truthcoin/handler_test.go
index b2c661de86..be5eaeb0d0 100644
--- a/sidechain-orchestrator/sidechain/truthcoin/handler_test.go
+++ b/sidechain-orchestrator/sidechain/truthcoin/handler_test.go
@@ -9,7 +9,6 @@ import (
 	"strconv"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -52,7 +51,7 @@ func TestMarketCreateSendsRequestObject(t *testing.T) {
 
 	beta := 7.0
 	tradingFee := 0.005
-	resp, err := h.MarketCreate(context.Background(), connect.NewRequest(&pb.MarketCreateRequest{
+	resp, err := h.MarketCreate(context.Background(), &pb.MarketCreateRequest{
 		Title:       "Will it rain?",
 		Description: "weather market",
 		Dimensions:  `[{"type":"existing","id":"deadbeef"}]`,
@@ -60,9 +59,9 @@ func TestMarketCreateSendsRequestObject(t *testing.T) {
 		Beta:        &beta,
 		TradingFee:  &tradingFee,
 		Tags:        []string{"weather"},
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "txid123", resp.Msg.Txid)
+	assert.Equal(t, "txid123", resp.Txid)
 
 	require.Len(t, *params, 1)
 	assert.JSONEq(t, `[{
@@ -78,12 +77,12 @@ func TestMarketCreateSendsRequestObject(t *testing.T) {
 func TestMarketCreateRejectsNonJSONDimensions(t *testing.T) {
 	h, _ := capturingRPC(t, `{"txid":"txid123","market_id":"market1","claimed_decisions":[]}`)
 
-	_, err := h.MarketCreate(context.Background(), connect.NewRequest(&pb.MarketCreateRequest{
+	_, err := h.MarketCreate(context.Background(), &pb.MarketCreateRequest{
 		Title:       "Will it rain?",
 		Description: "weather market",
 		Dimensions:  "[deadbeef]",
 		FeeSats:     1000,
-	}))
+	})
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "unmarshal dimensions")
 }
@@ -94,14 +93,14 @@ func TestMarketBuySendsRequestObject(t *testing.T) {
 	dryRun := true
 	feeSats := int64(1000)
 	maxCost := int64(5000)
-	_, err := h.MarketBuy(context.Background(), connect.NewRequest(&pb.MarketBuyRequest{
+	_, err := h.MarketBuy(context.Background(), &pb.MarketBuyRequest{
 		MarketId:     "market1",
 		OutcomeIndex: 2,
 		SharesAmount: 7,
 		DryRun:       &dryRun,
 		FeeSats:      &feeSats,
 		MaxCost:      &maxCost,
-	}))
+	})
 	require.NoError(t, err)
 
 	require.Len(t, *params, 1)
@@ -120,15 +119,15 @@ func TestCalculateInitialLiquiditySendsRequestObject(t *testing.T) {
 
 	numOutcomes := int32(2)
 	dimensions := "[slot1]"
-	_, err := h.CalculateInitialLiquidity(context.Background(), connect.NewRequest(&pb.CalculateInitialLiquidityRequest{
+	_, err := h.CalculateInitialLiquidity(context.Background(), &pb.CalculateInitialLiquidityRequest{
 		Beta:        7,
 		NumOutcomes: &numOutcomes,
-	}))
+	})
 	require.NoError(t, err)
-	_, err = h.CalculateInitialLiquidity(context.Background(), connect.NewRequest(&pb.CalculateInitialLiquidityRequest{
+	_, err = h.CalculateInitialLiquidity(context.Background(), &pb.CalculateInitialLiquidityRequest{
 		Beta:       7,
 		Dimensions: &dimensions,
-	}))
+	})
 	require.NoError(t, err)
 
 	require.Len(t, *params, 2)
@@ -142,7 +141,7 @@ func TestMarketSellSendsRequestObject(t *testing.T) {
 	dryRun := false
 	feeSats := int64(1000)
 	minProceeds := int64(50)
-	_, err := h.MarketSell(context.Background(), connect.NewRequest(&pb.MarketSellRequest{
+	_, err := h.MarketSell(context.Background(), &pb.MarketSellRequest{
 		MarketId:      "market1",
 		OutcomeIndex:  2,
 		SharesAmount:  7,
@@ -150,7 +149,7 @@ func TestMarketSellSendsRequestObject(t *testing.T) {
 		DryRun:        &dryRun,
 		FeeSats:       &feeSats,
 		MinProceeds:   &minProceeds,
-	}))
+	})
 	require.NoError(t, err)
 
 	require.Len(t, *params, 1)
@@ -168,14 +167,14 @@ func TestMarketSellSendsRequestObject(t *testing.T) {
 func TestVerifySignatureSendsSignatureFirst(t *testing.T) {
 	h, params := capturingRPC(t, `true`)
 
-	resp, err := h.VerifySignature(context.Background(), connect.NewRequest(&pb.VerifySignatureRequest{
+	resp, err := h.VerifySignature(context.Background(), &pb.VerifySignatureRequest{
 		Msg:          "the message",
 		Signature:    "0xsig",
 		VerifyingKey: "ba-svk1key",
 		Dst:          "arbitrary",
-	}))
+	})
 	require.NoError(t, err)
-	assert.True(t, resp.Msg.Valid)
+	assert.True(t, resp.Valid)
 
 	require.Len(t, *params, 1)
 	assert.JSONEq(t, `["0xsig","ba-svk1key","arbitrary","the message"]`, string((*params)[0]))
@@ -185,12 +184,12 @@ func TestCalculateInitialLiquidityReturnsNodeResult(t *testing.T) {
 	h, params := capturingRPC(t, `{"beta":7.0,"num_outcomes":2,"initial_liquidity_sats":5,"min_treasury_sats":5,"market_config":"1 dimensions","outcome_breakdown":"binary(2) = 2 outcomes"}`)
 
 	dimensions := "[870000]"
-	resp, err := h.CalculateInitialLiquidity(context.Background(), connect.NewRequest(&pb.CalculateInitialLiquidityRequest{
+	resp, err := h.CalculateInitialLiquidity(context.Background(), &pb.CalculateInitialLiquidityRequest{
 		Beta:       7,
 		Dimensions: &dimensions,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Contains(t, resp.Msg.ResultJson, `"initial_liquidity_sats":5`)
+	assert.Contains(t, resp.ResultJson, `"initial_liquidity_sats":5`)
 
 	require.Len(t, *params, 1)
 	assert.JSONEq(t, `[{"beta": 7.0, "dimensions": "[870000]"}]`, string((*params)[0]))
@@ -200,10 +199,10 @@ func TestCalculateInitialLiquiditySendsOutcomeCount(t *testing.T) {
 	h, params := capturingRPC(t, `{"beta":7.0,"num_outcomes":3,"initial_liquidity_sats":8,"min_treasury_sats":8,"market_config":"","outcome_breakdown":""}`)
 
 	numOutcomes := int32(3)
-	_, err := h.CalculateInitialLiquidity(context.Background(), connect.NewRequest(&pb.CalculateInitialLiquidityRequest{
+	_, err := h.CalculateInitialLiquidity(context.Background(), &pb.CalculateInitialLiquidityRequest{
 		Beta:        7,
 		NumOutcomes: &numOutcomes,
-	}))
+	})
 	require.NoError(t, err)
 
 	require.Len(t, *params, 1)
@@ -214,15 +213,15 @@ func TestCalculateInitialLiquiditySendsOutcomeCount(t *testing.T) {
 func TestVotecoinBalanceReadsFraction(t *testing.T) {
 	h, _ := capturingRPC(t, `0.25`)
 
-	resp, err := h.VotecoinBalance(context.Background(), connect.NewRequest(&pb.VotecoinBalanceRequest{Address: "3dWL5oSH54rxzXbU5RVi7bBkeuWd"}))
+	resp, err := h.VotecoinBalance(context.Background(), &pb.VotecoinBalanceRequest{Address: "3dWL5oSH54rxzXbU5RVi7bBkeuWd"})
 	require.NoError(t, err)
-	assert.Equal(t, 0.25, resp.Msg.VotecoinBalance)
+	assert.Equal(t, 0.25, resp.VotecoinBalance)
 }
 
 func TestMarketGetUnknownMarketIsEmpty(t *testing.T) {
 	h, _ := capturingRPC(t, `null`)
 
-	resp, err := h.MarketGet(context.Background(), connect.NewRequest(&pb.MarketGetRequest{MarketId: "9f843b33f009"}))
+	resp, err := h.MarketGet(context.Background(), &pb.MarketGetRequest{MarketId: "9f843b33f009"})
 	require.NoError(t, err)
-	assert.Empty(t, resp.Msg.MarketJson)
+	assert.Empty(t, resp.MarketJson)
 }
diff --git a/sidechain-orchestrator/sidechain/truthcoin/message_test.go b/sidechain-orchestrator/sidechain/truthcoin/message_test.go
new file mode 100644
index 0000000000..681e3b0a9d
--- /dev/null
+++ b/sidechain-orchestrator/sidechain/truthcoin/message_test.go
@@ -0,0 +1,20 @@
+package truthcoin
+
+import (
+	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/truthcoin/v1"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestHandlerSendsTheMessage(t *testing.T) {
+	h, params := capturingRPC(t, `null`)
+	_, err := h.EncryptMsg(t.Context(), &pb.EncryptMsgRequest{EncryptionPubkey: "key", Msg: "the message"})
+	require.NoError(t, err)
+	require.JSONEq(t, `["key","the message"]`, string((*params)[0]))
+	_, err = h.SignArbitraryMsg(t.Context(), &pb.SignArbitraryMsgRequest{VerifyingKey: "key", Msg: "the message"})
+	require.NoError(t, err)
+	require.JSONEq(t, `["key","the message"]`, string((*params)[1]))
+	_, err = h.SignArbitraryMsgAsAddr(t.Context(), &pb.SignArbitraryMsgAsAddrRequest{Address: "address", Msg: "the message"})
+	require.NoError(t, err)
+	require.JSONEq(t, `["address","the message"]`, string((*params)[2]))
+}
diff --git a/sidechain-orchestrator/sidechain/truthcoin/voting_handler_test.go b/sidechain-orchestrator/sidechain/truthcoin/voting_handler_test.go
index eff5fcd1e3..15b73ae8ec 100644
--- a/sidechain-orchestrator/sidechain/truthcoin/voting_handler_test.go
+++ b/sidechain-orchestrator/sidechain/truthcoin/voting_handler_test.go
@@ -10,7 +10,6 @@ import (
 	"strconv"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -71,11 +70,11 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "SlotStatus",
 			result: `{"is_testing_mode":true,"blocks_per_period":10,"current_period":3,"current_period_name":"P3"}`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.SlotStatus(ctx, connect.NewRequest(&pb.SlotStatusRequest{}))
+				resp, err := h.SlotStatus(ctx, &pb.SlotStatusRequest{})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.StatusJson, nil
+				return resp.StatusJson, nil
 			},
 			wantMethod: "decision_status",
 			wantParams: ``,
@@ -85,11 +84,11 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "SlotList",
 			result: `[]`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.SlotList(ctx, connect.NewRequest(&pb.SlotListRequest{Period: &period, Status: &status}))
+				resp, err := h.SlotList(ctx, &pb.SlotListRequest{Period: &period, Status: &status})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.SlotsJson, nil
+				return resp.SlotsJson, nil
 			},
 			wantMethod: "decision_list",
 			wantParams: `[{"period":3,"status":"Claimed"}]`,
@@ -99,11 +98,11 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "SlotGet",
 			result: `null`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.SlotGet(ctx, connect.NewRequest(&pb.SlotGetRequest{SlotId: "002a0001"}))
+				resp, err := h.SlotGet(ctx, &pb.SlotGetRequest{SlotId: "002a0001"})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.SlotJson, nil
+				return resp.SlotJson, nil
 			},
 			wantMethod: "decision_get",
 			wantParams: `["002a0001"]`,
@@ -113,18 +112,18 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "SlotClaim",
 			result: `{"txid":"claimtx","decision_ids":["002a0001"],"listing_fee_paid_sats":100}`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.SlotClaim(ctx, connect.NewRequest(&pb.SlotClaimRequest{
+				resp, err := h.SlotClaim(ctx, &pb.SlotClaimRequest{
 					FeeSats:     1000,
 					PeriodIndex: 3,
 					Question:    "Inflation?",
 					IsScaled:    &isScaled,
 					Min:         &minValue,
 					Max:         &maxValue,
-				}))
+				})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.Txid, nil
+				return resp.Txid, nil
 			},
 			wantMethod: "decision_claim",
 			wantParams: `[{"decision_type":"scaled","decisions":[{"period_index":3,"header":"Inflation?"}],"min":0,"max":100,"tx_fee_sats":1000}]`,
@@ -134,14 +133,14 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "SlotClaimCategory",
 			result: `{"txid":"cattx","decision_ids":[],"listing_fee_paid_sats":0}`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.SlotClaimCategory(ctx, connect.NewRequest(&pb.SlotClaimCategoryRequest{
+				resp, err := h.SlotClaimCategory(ctx, &pb.SlotClaimCategoryRequest{
 					SlotsJson: `[{"period_index":3,"header":"Winner?","option_labels":["A","B"]}]`,
 					FeeSats:   1000,
-				}))
+				})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.Txid, nil
+				return resp.Txid, nil
 			},
 			wantMethod: "decision_claim",
 			wantParams: `[{"decision_type":"category","decisions":[{"period_index":3,"header":"Winner?","option_labels":["A","B"]}],"tx_fee_sats":1000}]`,
@@ -151,14 +150,14 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "VoteSubmit",
 			result: `"votetx"`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.VoteSubmit(ctx, connect.NewRequest(&pb.VoteSubmitRequest{
+				resp, err := h.VoteSubmit(ctx, &pb.VoteSubmitRequest{
 					VotesJson: `[{"decision_id":"002a0001","vote_value":1.0}]`,
 					FeeSats:   1000,
-				}))
+				})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.Txid, nil
+				return resp.Txid, nil
 			},
 			wantMethod: "vote_submit",
 			wantParams: `[[{"decision_id":"002a0001","vote_value":1.0}],1000]`,
@@ -168,11 +167,11 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "VoteList",
 			result: `[]`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.VoteList(ctx, connect.NewRequest(&pb.VoteListRequest{Voter: &voter, PeriodId: &period}))
+				resp, err := h.VoteList(ctx, &pb.VoteListRequest{Voter: &voter, PeriodId: &period})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.VotesJson, nil
+				return resp.VotesJson, nil
 			},
 			wantMethod: "vote_list",
 			wantParams: `[{"voter":"tNvoter","decision_id":null,"period_id":3}]`,
@@ -182,11 +181,11 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "MyUtxos",
 			result: `[]`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.MyUtxos(ctx, connect.NewRequest(&pb.MyUtxosRequest{}))
+				resp, err := h.MyUtxos(ctx, &pb.MyUtxosRequest{})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.UtxosJson, nil
+				return resp.UtxosJson, nil
 			},
 			wantMethod: "get_wallet_utxos",
 			wantParams: ``,
@@ -196,15 +195,15 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 			name:   "VotecoinTransfer",
 			result: `"vctx"`,
 			call: func(ctx context.Context, h *Handler) (string, error) {
-				resp, err := h.VotecoinTransfer(ctx, connect.NewRequest(&pb.VotecoinTransferRequest{
+				resp, err := h.VotecoinTransfer(ctx, &pb.VotecoinTransferRequest{
 					Dest:    "tNdest",
 					Amount:  5, //nolint:staticcheck // old clients send Amount
 					FeeSats: 1000,
-				}))
+				})
 				if err != nil {
 					return "", err
 				}
-				return resp.Msg.Txid, nil
+				return resp.Txid, nil
 			},
 			wantMethod: "transfer_votecoin",
 			wantParams: `["tNdest",5,1000]`,
@@ -237,25 +236,25 @@ func TestVotingHandlersCallNodeMethods(t *testing.T) {
 func TestVotingHandlersMapNullToEmpty(t *testing.T) {
 	calls := map[string]func(context.Context, *Handler) (string, error){
 		"SlotGet": func(ctx context.Context, h *Handler) (string, error) {
-			resp, err := h.SlotGet(ctx, connect.NewRequest(&pb.SlotGetRequest{SlotId: "004008"}))
+			resp, err := h.SlotGet(ctx, &pb.SlotGetRequest{SlotId: "004008"})
 			if err != nil {
 				return "", err
 			}
-			return resp.Msg.SlotJson, nil
+			return resp.SlotJson, nil
 		},
 		"VoteVoter": func(ctx context.Context, h *Handler) (string, error) {
-			resp, err := h.VoteVoter(ctx, connect.NewRequest(&pb.VoteVoterRequest{Address: "tNvoter"}))
+			resp, err := h.VoteVoter(ctx, &pb.VoteVoterRequest{Address: "tNvoter"})
 			if err != nil {
 				return "", err
 			}
-			return resp.Msg.VoterJson, nil
+			return resp.VoterJson, nil
 		},
 		"VotePeriod": func(ctx context.Context, h *Handler) (string, error) {
-			resp, err := h.VotePeriod(ctx, connect.NewRequest(&pb.VotePeriodRequest{}))
+			resp, err := h.VotePeriod(ctx, &pb.VotePeriodRequest{})
 			if err != nil {
 				return "", err
 			}
-			return resp.Msg.PeriodJson, nil
+			return resp.PeriodJson, nil
 		},
 	}
 	for name, call := range calls {
diff --git a/sidechain-orchestrator/sidechain/truthcoin/wallet_rpc_test.go b/sidechain-orchestrator/sidechain/truthcoin/wallet_rpc_test.go
index f417142e57..25faee1cbb 100644
--- a/sidechain-orchestrator/sidechain/truthcoin/wallet_rpc_test.go
+++ b/sidechain-orchestrator/sidechain/truthcoin/wallet_rpc_test.go
@@ -9,7 +9,6 @@ import (
 	"strconv"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -61,17 +60,17 @@ func recordingHandler(t *testing.T, result string) (*Handler, *[]recordedCall) {
 func TestHandlerSendsTheCreateMethods(t *testing.T) {
 	h, calls := recordingHandler(t, `"txid1"`)
 
-	transfer, err := h.Transfer(context.Background(), connect.NewRequest(&pb.TransferRequest{
+	transfer, err := h.Transfer(context.Background(), &pb.TransferRequest{
 		Address: "dest", AmountSats: 5000, FeeSats: 100,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "txid1", transfer.Msg.Txid)
+	assert.Equal(t, "txid1", transfer.Txid)
 
-	withdraw, err := h.Withdraw(context.Background(), connect.NewRequest(&pb.WithdrawRequest{
+	withdraw, err := h.Withdraw(context.Background(), &pb.WithdrawRequest{
 		Address: "bc1qmain", AmountSats: 7000, SideFeeSats: 100, MainFeeSats: 200,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "txid1", withdraw.Msg.Txid)
+	assert.Equal(t, "txid1", withdraw.Txid)
 
 	require.Len(t, *calls, 2)
 	assert.Equal(t, "create_transfer", (*calls)[0].Method)
@@ -101,13 +100,13 @@ func TestVotecoinTransferSendsNoMemo(t *testing.T) {
 	h, calls := recordingHandler(t, `"txid1"`)
 	memo := "hello"
 
-	_, err := h.VotecoinTransfer(context.Background(), connect.NewRequest(&pb.VotecoinTransferRequest{
+	_, err := h.VotecoinTransfer(context.Background(), &pb.VotecoinTransferRequest{
 		Dest: "dest", Amount: 3, FeeSats: 100, Memo: &memo, //nolint:staticcheck // old clients send Amount
-	}))
+	})
 	require.NoError(t, err)
-	_, err = h.TransferVotecoin(context.Background(), connect.NewRequest(&pb.TransferVotecoinRequest{
+	_, err = h.TransferVotecoin(context.Background(), &pb.TransferVotecoinRequest{
 		Dest: "dest", Amount: 3, FeeSats: 100, Memo: &memo, //nolint:staticcheck // old clients send Amount
-	}))
+	})
 	require.NoError(t, err)
 
 	require.Len(t, *calls, 2)
@@ -122,13 +121,13 @@ func TestVotecoinTransferSendsTheFractionalAmount(t *testing.T) {
 	h, calls := recordingHandler(t, `"txid1"`)
 	amount := 0.25
 
-	_, err := h.VotecoinTransfer(context.Background(), connect.NewRequest(&pb.VotecoinTransferRequest{
+	_, err := h.VotecoinTransfer(context.Background(), &pb.VotecoinTransferRequest{
 		Dest: "dest", VotecoinAmount: &amount, FeeSats: 100,
-	}))
+	})
 	require.NoError(t, err)
-	_, err = h.TransferVotecoin(context.Background(), connect.NewRequest(&pb.TransferVotecoinRequest{
+	_, err = h.TransferVotecoin(context.Background(), &pb.TransferVotecoinRequest{
 		Dest: "dest", VotecoinAmount: &amount, FeeSats: 100,
-	}))
+	})
 	require.NoError(t, err)
 
 	require.Len(t, *calls, 2)
@@ -142,10 +141,10 @@ func TestVotecoinTransferSendsTheFractionalAmount(t *testing.T) {
 func TestVotecoinBalanceReadsAFraction(t *testing.T) {
 	h, _ := recordingHandler(t, `0.75`)
 
-	resp, err := h.VotecoinBalance(context.Background(), connect.NewRequest(&pb.VotecoinBalanceRequest{Address: "voter"}))
+	resp, err := h.VotecoinBalance(context.Background(), &pb.VotecoinBalanceRequest{Address: "voter"})
 	require.NoError(t, err)
-	assert.InDelta(t, 0.75, resp.Msg.VotecoinBalance, 0)
-	assert.Equal(t, int64(0), resp.Msg.Balance) //nolint:staticcheck // old clients read Balance
+	assert.InDelta(t, 0.75, resp.VotecoinBalance, 0)
+	assert.Equal(t, int64(0), resp.Balance) //nolint:staticcheck // old clients read Balance
 }
 
 // get_bmm_inclusions answers a list of mainchain block hashes.
@@ -153,9 +152,9 @@ func TestGetBmmInclusionsReadsAList(t *testing.T) {
 	const inclusions = `["000000000000000007677bb6ca40424eb40afe6979f52f98579ba7ed1ddbac79"]`
 	h, _ := recordingHandler(t, inclusions)
 
-	resp, err := h.GetBmmInclusions(context.Background(), connect.NewRequest(&pb.GetBmmInclusionsRequest{BlockHash: "aa"}))
+	resp, err := h.GetBmmInclusions(context.Background(), &pb.GetBmmInclusionsRequest{BlockHash: "aa"})
 	require.NoError(t, err)
-	assert.JSONEq(t, inclusions, resp.Msg.Inclusions)
+	assert.JSONEq(t, inclusions, resp.Inclusions)
 
 	host, port, _ := callRecorder(t, inclusions)
 	hashes, err := NewClient(host, port, "").GetBMMInclusions(context.Background(), "aa")
@@ -167,18 +166,18 @@ func TestGetBmmInclusionsReadsAList(t *testing.T) {
 func TestGetBlockMapsAMissingBlockToEmpty(t *testing.T) {
 	h, _ := recordingHandler(t, `null`)
 
-	resp, err := h.GetBlock(context.Background(), connect.NewRequest(&pb.GetBlockRequest{Hash: "aa"}))
+	resp, err := h.GetBlock(context.Background(), &pb.GetBlockRequest{Hash: "aa"})
 	require.NoError(t, err)
-	assert.Empty(t, resp.Msg.BlockJson)
+	assert.Empty(t, resp.BlockJson)
 }
 
 // get_voter_address answers the base58 address of wallet index 0.
 func TestGetVoterAddressReadsTheAddress(t *testing.T) {
 	h, calls := recordingHandler(t, `"Xc3D7ZjNez3ReowLm1yz1zSvYe1"`)
 
-	resp, err := h.GetVoterAddress(context.Background(), connect.NewRequest(&pb.GetVoterAddressRequest{}))
+	resp, err := h.GetVoterAddress(context.Background(), &pb.GetVoterAddressRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, "Xc3D7ZjNez3ReowLm1yz1zSvYe1", resp.Msg.Address)
+	assert.Equal(t, "Xc3D7ZjNez3ReowLm1yz1zSvYe1", resp.Address)
 
 	require.Len(t, *calls, 1)
 	assert.Equal(t, "get_voter_address", (*calls)[0].Method)
@@ -188,11 +187,11 @@ func TestGetVoterAddressReadsTheAddress(t *testing.T) {
 func TestMarketAmplifyBetaSendsTheRequest(t *testing.T) {
 	h, calls := recordingHandler(t, `"txid1"`)
 
-	resp, err := h.MarketAmplifyBeta(context.Background(), connect.NewRequest(&pb.MarketAmplifyBetaRequest{
+	resp, err := h.MarketAmplifyBeta(context.Background(), &pb.MarketAmplifyBetaRequest{
 		MarketId: "5e5ed0d19c4f", AmountSats: 50000,
-	}))
+	})
 	require.NoError(t, err)
-	assert.Equal(t, "txid1", resp.Msg.Txid)
+	assert.Equal(t, "txid1", resp.Txid)
 
 	require.Len(t, *calls, 1)
 	assert.Equal(t, "market_amplify_beta", (*calls)[0].Method)
diff --git a/sidechain-orchestrator/sidechain/truthcoin/wealth_method_test.go b/sidechain-orchestrator/sidechain/truthcoin/wealth_method_test.go
index 0049960699..37cf82619a 100644
--- a/sidechain-orchestrator/sidechain/truthcoin/wealth_method_test.go
+++ b/sidechain-orchestrator/sidechain/truthcoin/wealth_method_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -47,8 +46,8 @@ func TestSidechainWealthCallsSidechainWealth(t *testing.T) {
 	proxy, seen := wealthNode(t, "10603007000")
 
 	resp, err := NewHandler(proxy).GetSidechainWealth(context.Background(),
-		connect.NewRequest(&pb.GetSidechainWealthRequest{}))
+		&pb.GetSidechainWealthRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, int64(10603007000), resp.Msg.Sats)
+	assert.Equal(t, int64(10603007000), resp.Sats)
 	assert.Equal(t, []string{"sidechain_wealth"}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain/zside/handler.go b/sidechain-orchestrator/sidechain/zside/handler.go
index e5a639a9d4..bd08df9a5d 100644
--- a/sidechain-orchestrator/sidechain/zside/handler.go
+++ b/sidechain-orchestrator/sidechain/zside/handler.go
@@ -6,8 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"connectrpc.com/connect"
-
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/zside/v1"
 	svc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/zside/v1/zsidev1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/sidechain"
@@ -28,7 +26,7 @@ func NewHandler(proxy *sidechain.JSONRPCProxy) *Handler {
 
 // --- Common Node methods ---
 
-func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBalanceRequest]) (*connect.Response[pb.GetBalanceResponse], error) {
+func (h *Handler) GetBalance(ctx context.Context, req *pb.GetBalanceRequest) (*pb.GetBalanceResponse, error) {
 	// ZSide has a custom balance response with shielded and transparent pools
 	var result struct {
 		TotalShieldedSats        int64 `json:"total_shielded_sats"`
@@ -39,68 +37,68 @@ func (h *Handler) GetBalance(ctx context.Context, req *connect.Request[pb.GetBal
 	if err := h.proxy.Client.Call(ctx, "balance", nil, &result); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBalanceResponse{
+	return &pb.GetBalanceResponse{
 		TotalShieldedSats:        result.TotalShieldedSats,
 		TotalTransparentSats:     result.TotalTransparentSats,
 		AvailableShieldedSats:    result.AvailableShieldedSats,
 		AvailableTransparentSats: result.AvailableTransparentSats,
-	}), nil
+	}, nil
 }
 
-func (h *Handler) GetBlockCount(ctx context.Context, req *connect.Request[pb.GetBlockCountRequest]) (*connect.Response[pb.GetBlockCountResponse], error) {
+func (h *Handler) GetBlockCount(ctx context.Context, req *pb.GetBlockCountRequest) (*pb.GetBlockCountResponse, error) {
 	count, err := h.proxy.GetBlockCount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockCountResponse{Count: count}), nil
+	return &pb.GetBlockCountResponse{Count: count}, nil
 }
 
-func (h *Handler) Stop(ctx context.Context, req *connect.Request[pb.StopRequest]) (*connect.Response[pb.StopResponse], error) {
+func (h *Handler) Stop(ctx context.Context, req *pb.StopRequest) (*pb.StopResponse, error) {
 	if err := h.proxy.Stop(ctx); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.StopResponse{}), nil
+	return &pb.StopResponse{}, nil
 }
 
-func (h *Handler) Withdraw(ctx context.Context, req *connect.Request[pb.WithdrawRequest]) (*connect.Response[pb.WithdrawResponse], error) {
+func (h *Handler) Withdraw(ctx context.Context, req *pb.WithdrawRequest) (*pb.WithdrawResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.SideFeeSats, req.Msg.MainFeeSats}
+	params := []any{req.Address, req.AmountSats, req.SideFeeSats, req.MainFeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_withdrawal", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.WithdrawResponse{Txid: txid}), nil
+	return &pb.WithdrawResponse{Txid: txid}, nil
 }
 
 // Transfer sends transparent coins, the only kind a plain address holds.
-func (h *Handler) Transfer(ctx context.Context, req *connect.Request[pb.TransferRequest]) (*connect.Response[pb.TransferResponse], error) {
+func (h *Handler) Transfer(ctx context.Context, req *pb.TransferRequest) (*pb.TransferResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.AmountSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_transparent_transfer", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransferResponse{Txid: txid}), nil
+	return &pb.TransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Mine(ctx context.Context, req *connect.Request[pb.MineRequest]) (*connect.Response[pb.MineResponse], error) {
-	raw, err := h.proxy.Mine(ctx, req.Msg.FeeSats)
+func (h *Handler) Mine(ctx context.Context, req *pb.MineRequest) (*pb.MineResponse, error) {
+	raw, err := h.proxy.Mine(ctx, req.FeeSats)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.MineResponse{BmmResultJson: string(raw)}), nil
+	return &pb.MineResponse{BmmResultJson: string(raw)}, nil
 }
 
-func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *connect.Request[pb.GetPendingWithdrawalBundleRequest]) (*connect.Response[pb.GetPendingWithdrawalBundleResponse], error) {
+func (h *Handler) GetPendingWithdrawalBundle(ctx context.Context, req *pb.GetPendingWithdrawalBundleRequest) (*pb.GetPendingWithdrawalBundleResponse, error) {
 	raw, err := h.proxy.GetPendingWithdrawalBundle(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}), nil
+	return &pb.GetPendingWithdrawalBundleResponse{BundleJson: string(raw)}, nil
 }
 
 // GetWalletUtxos lists the wallet coins as the mempool leaves them: a coin an
 // unconfirmed transaction spends drops out, and an unconfirmed coin is marked
 // "confirmed": false.
-func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.GetWalletUtxosRequest]) (*connect.Response[pb.GetWalletUtxosResponse], error) {
+func (h *Handler) GetWalletUtxos(ctx context.Context, req *pb.GetWalletUtxosRequest) (*pb.GetWalletUtxosResponse, error) {
 	var confirmed, unconfirmed []map[string]json.RawMessage
 	if err := h.proxy.Client.Call(ctx, "get_wallet_utxos", nil, &confirmed); err != nil {
 		return nil, err
@@ -148,7 +146,7 @@ func (h *Handler) GetWalletUtxos(ctx context.Context, req *connect.Request[pb.Ge
 	if err != nil {
 		return nil, fmt.Errorf("encode the zSide wallet coins: %w", err)
 	}
-	return connect.NewResponse(&pb.GetWalletUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.GetWalletUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
 // outpointKey is the compact JSON of an outpoint, the same for each listing of
@@ -161,188 +159,188 @@ func outpointKey(outpoint json.RawMessage) (string, error) {
 	return compact.String(), nil
 }
 
-func (h *Handler) ListUtxos(ctx context.Context, req *connect.Request[pb.ListUtxosRequest]) (*connect.Response[pb.ListUtxosResponse], error) {
+func (h *Handler) ListUtxos(ctx context.Context, req *pb.ListUtxosRequest) (*pb.ListUtxosResponse, error) {
 	raw, err := h.proxy.ListUtxos(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListUtxosResponse{UtxosJson: string(raw)}), nil
+	return &pb.ListUtxosResponse{UtxosJson: string(raw)}, nil
 }
 
-func (h *Handler) RemoveFromMempool(ctx context.Context, req *connect.Request[pb.RemoveFromMempoolRequest]) (*connect.Response[pb.RemoveFromMempoolResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Msg.Txid}, nil); err != nil {
+func (h *Handler) RemoveFromMempool(ctx context.Context, req *pb.RemoveFromMempoolRequest) (*pb.RemoveFromMempoolResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "remove_from_mempool", []any{req.Txid}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.RemoveFromMempoolResponse{}), nil
+	return &pb.RemoveFromMempoolResponse{}, nil
 }
 
-func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *connect.Request[pb.GetLatestFailedWithdrawalBundleHeightRequest]) (*connect.Response[pb.GetLatestFailedWithdrawalBundleHeightResponse], error) {
+func (h *Handler) GetLatestFailedWithdrawalBundleHeight(ctx context.Context, req *pb.GetLatestFailedWithdrawalBundleHeightRequest) (*pb.GetLatestFailedWithdrawalBundleHeightResponse, error) {
 	height, err := h.proxy.GetLatestFailedWithdrawalBundleHeight(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}), nil
+	return &pb.GetLatestFailedWithdrawalBundleHeightResponse{Height: height}, nil
 }
 
-func (h *Handler) GenerateMnemonic(ctx context.Context, req *connect.Request[pb.GenerateMnemonicRequest]) (*connect.Response[pb.GenerateMnemonicResponse], error) {
+func (h *Handler) GenerateMnemonic(ctx context.Context, req *pb.GenerateMnemonicRequest) (*pb.GenerateMnemonicResponse, error) {
 	var mnemonic string
 	if err := h.proxy.Client.Call(ctx, "generate_mnemonic", nil, &mnemonic); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GenerateMnemonicResponse{Mnemonic: mnemonic}), nil
+	return &pb.GenerateMnemonicResponse{Mnemonic: mnemonic}, nil
 }
 
-func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *connect.Request[pb.SetSeedFromMnemonicRequest]) (*connect.Response[pb.SetSeedFromMnemonicResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Msg.Mnemonic}, nil); err != nil {
+func (h *Handler) SetSeedFromMnemonic(ctx context.Context, req *pb.SetSeedFromMnemonicRequest) (*pb.SetSeedFromMnemonicResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "set_seed_from_mnemonic", []any{req.Mnemonic}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.SetSeedFromMnemonicResponse{}), nil
+	return &pb.SetSeedFromMnemonicResponse{}, nil
 }
 
-func (h *Handler) CallRaw(ctx context.Context, req *connect.Request[pb.CallRawRequest]) (*connect.Response[pb.CallRawResponse], error) {
+func (h *Handler) CallRaw(ctx context.Context, req *pb.CallRawRequest) (*pb.CallRawResponse, error) {
 	var params any
-	if req.Msg.ParamsJson != "" {
-		if err := json.Unmarshal([]byte(req.Msg.ParamsJson), &params); err != nil {
+	if req.ParamsJson != "" {
+		if err := json.Unmarshal([]byte(req.ParamsJson), &params); err != nil {
 			return nil, fmt.Errorf("unmarshal params: %w", err)
 		}
 	}
-	raw, err := h.proxy.CallRaw(ctx, req.Msg.Method, params)
+	raw, err := h.proxy.CallRaw(ctx, req.Method, params)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CallRawResponse{ResultJson: string(raw)}), nil
+	return &pb.CallRawResponse{ResultJson: string(raw)}, nil
 }
 
 // --- ZSide-specific methods ---
 
-func (h *Handler) GetSidechainWealth(ctx context.Context, req *connect.Request[pb.GetSidechainWealthRequest]) (*connect.Response[pb.GetSidechainWealthResponse], error) {
+func (h *Handler) GetSidechainWealth(ctx context.Context, req *pb.GetSidechainWealthRequest) (*pb.GetSidechainWealthResponse, error) {
 	var sats int64
 	if err := h.proxy.Client.Call(ctx, "sidechain_wealth", nil, &sats); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetSidechainWealthResponse{Sats: sats}), nil
+	return &pb.GetSidechainWealthResponse{Sats: sats}, nil
 }
 
-func (h *Handler) CreateDeposit(ctx context.Context, req *connect.Request[pb.CreateDepositRequest]) (*connect.Response[pb.CreateDepositResponse], error) {
+func (h *Handler) CreateDeposit(ctx context.Context, req *pb.CreateDepositRequest) (*pb.CreateDepositResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.ValueSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.ValueSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_deposit", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.CreateDepositResponse{Txid: txid}), nil
+	return &pb.CreateDepositResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ConnectPeer(ctx context.Context, req *connect.Request[pb.ConnectPeerRequest]) (*connect.Response[pb.ConnectPeerResponse], error) {
-	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Msg.Address}, nil); err != nil {
+func (h *Handler) ConnectPeer(ctx context.Context, req *pb.ConnectPeerRequest) (*pb.ConnectPeerResponse, error) {
+	if err := h.proxy.Client.Call(ctx, "connect_peer", []any{req.Address}, nil); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ConnectPeerResponse{}), nil
+	return &pb.ConnectPeerResponse{}, nil
 }
 
-func (h *Handler) ListPeers(ctx context.Context, req *connect.Request[pb.ListPeersRequest]) (*connect.Response[pb.ListPeersResponse], error) {
+func (h *Handler) ListPeers(ctx context.Context, req *pb.ListPeersRequest) (*pb.ListPeersResponse, error) {
 	raw, err := h.proxy.Client.CallRaw(ctx, "list_peers", nil)
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ListPeersResponse{PeersJson: string(raw)}), nil
+	return &pb.ListPeersResponse{PeersJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBlock(ctx context.Context, req *connect.Request[pb.GetBlockRequest]) (*connect.Response[pb.GetBlockResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Msg.Hash})
+func (h *Handler) GetBlock(ctx context.Context, req *pb.GetBlockRequest) (*pb.GetBlockResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_block", []any{req.Hash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBlockResponse{BlockJson: string(raw)}), nil
+	return &pb.GetBlockResponse{BlockJson: string(raw)}, nil
 }
 
-func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestMainchainBlockHashRequest]) (*connect.Response[pb.GetBestMainchainBlockHashResponse], error) {
+func (h *Handler) GetBestMainchainBlockHash(ctx context.Context, req *pb.GetBestMainchainBlockHashRequest) (*pb.GetBestMainchainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_mainchain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestMainchainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestMainchainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *connect.Request[pb.GetBestSidechainBlockHashRequest]) (*connect.Response[pb.GetBestSidechainBlockHashResponse], error) {
+func (h *Handler) GetBestSidechainBlockHash(ctx context.Context, req *pb.GetBestSidechainBlockHashRequest) (*pb.GetBestSidechainBlockHashResponse, error) {
 	var hash string
 	if err := h.proxy.Client.Call(ctx, "get_best_sidechain_block_hash", nil, &hash); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBestSidechainBlockHashResponse{Hash: hash}), nil
+	return &pb.GetBestSidechainBlockHashResponse{Hash: hash}, nil
 }
 
-func (h *Handler) GetBmmInclusions(ctx context.Context, req *connect.Request[pb.GetBmmInclusionsRequest]) (*connect.Response[pb.GetBmmInclusionsResponse], error) {
-	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.Msg.BlockHash})
+func (h *Handler) GetBmmInclusions(ctx context.Context, req *pb.GetBmmInclusionsRequest) (*pb.GetBmmInclusionsResponse, error) {
+	raw, err := h.proxy.Client.CallRaw(ctx, "get_bmm_inclusions", []any{req.BlockHash})
 	if err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetBmmInclusionsResponse{Inclusions: string(raw)}), nil
+	return &pb.GetBmmInclusionsResponse{Inclusions: string(raw)}, nil
 }
 
-func (h *Handler) GetNewShieldedAddress(ctx context.Context, req *connect.Request[pb.GetNewShieldedAddressRequest]) (*connect.Response[pb.GetNewShieldedAddressResponse], error) {
+func (h *Handler) GetNewShieldedAddress(ctx context.Context, req *pb.GetNewShieldedAddressRequest) (*pb.GetNewShieldedAddressResponse, error) {
 	var address string
 	if err := h.proxy.Client.Call(ctx, "get_new_shielded_address", nil, &address); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewShieldedAddressResponse{Address: address}), nil
+	return &pb.GetNewShieldedAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) GetNewTransparentAddress(ctx context.Context, req *connect.Request[pb.GetNewTransparentAddressRequest]) (*connect.Response[pb.GetNewTransparentAddressResponse], error) {
+func (h *Handler) GetNewTransparentAddress(ctx context.Context, req *pb.GetNewTransparentAddressRequest) (*pb.GetNewTransparentAddressResponse, error) {
 	var address string
 	if err := h.proxy.Client.Call(ctx, "get_new_transparent_address", nil, &address); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetNewTransparentAddressResponse{Address: address}), nil
+	return &pb.GetNewTransparentAddressResponse{Address: address}, nil
 }
 
-func (h *Handler) GetShieldedWalletAddresses(ctx context.Context, req *connect.Request[pb.GetShieldedWalletAddressesRequest]) (*connect.Response[pb.GetShieldedWalletAddressesResponse], error) {
+func (h *Handler) GetShieldedWalletAddresses(ctx context.Context, req *pb.GetShieldedWalletAddressesRequest) (*pb.GetShieldedWalletAddressesResponse, error) {
 	var addresses []string
 	if err := h.proxy.Client.Call(ctx, "get_shielded_wallet_addresses", nil, &addresses); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetShieldedWalletAddressesResponse{Addresses: addresses}), nil
+	return &pb.GetShieldedWalletAddressesResponse{Addresses: addresses}, nil
 }
 
-func (h *Handler) GetTransparentWalletAddresses(ctx context.Context, req *connect.Request[pb.GetTransparentWalletAddressesRequest]) (*connect.Response[pb.GetTransparentWalletAddressesResponse], error) {
+func (h *Handler) GetTransparentWalletAddresses(ctx context.Context, req *pb.GetTransparentWalletAddressesRequest) (*pb.GetTransparentWalletAddressesResponse, error) {
 	var addresses []string
 	if err := h.proxy.Client.Call(ctx, "get_transparent_wallet_addresses", nil, &addresses); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.GetTransparentWalletAddressesResponse{Addresses: addresses}), nil
+	return &pb.GetTransparentWalletAddressesResponse{Addresses: addresses}, nil
 }
 
-func (h *Handler) Shield(ctx context.Context, req *connect.Request[pb.ShieldRequest]) (*connect.Response[pb.ShieldResponse], error) {
+func (h *Handler) Shield(ctx context.Context, req *pb.ShieldRequest) (*pb.ShieldResponse, error) {
 	var txid string
-	params := []any{req.Msg.AmountSats, req.Msg.FeeSats}
+	params := []any{req.AmountSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_shield", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ShieldResponse{Txid: txid}), nil
+	return &pb.ShieldResponse{Txid: txid}, nil
 }
 
-func (h *Handler) Unshield(ctx context.Context, req *connect.Request[pb.UnshieldRequest]) (*connect.Response[pb.UnshieldResponse], error) {
+func (h *Handler) Unshield(ctx context.Context, req *pb.UnshieldRequest) (*pb.UnshieldResponse, error) {
 	var txid string
-	params := []any{req.Msg.AmountSats, req.Msg.FeeSats}
+	params := []any{req.AmountSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_unshield", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.UnshieldResponse{Txid: txid}), nil
+	return &pb.UnshieldResponse{Txid: txid}, nil
 }
 
-func (h *Handler) ShieldedTransfer(ctx context.Context, req *connect.Request[pb.ShieldedTransferRequest]) (*connect.Response[pb.ShieldedTransferResponse], error) {
+func (h *Handler) ShieldedTransfer(ctx context.Context, req *pb.ShieldedTransferRequest) (*pb.ShieldedTransferResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.AmountSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_shielded_transfer", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.ShieldedTransferResponse{Txid: txid}), nil
+	return &pb.ShieldedTransferResponse{Txid: txid}, nil
 }
 
-func (h *Handler) TransparentTransfer(ctx context.Context, req *connect.Request[pb.TransparentTransferRequest]) (*connect.Response[pb.TransparentTransferResponse], error) {
+func (h *Handler) TransparentTransfer(ctx context.Context, req *pb.TransparentTransferRequest) (*pb.TransparentTransferResponse, error) {
 	var txid string
-	params := []any{req.Msg.Address, req.Msg.AmountSats, req.Msg.FeeSats}
+	params := []any{req.Address, req.AmountSats, req.FeeSats}
 	if err := h.proxy.Client.Call(ctx, "create_transparent_transfer", params, &txid); err != nil {
 		return nil, err
 	}
-	return connect.NewResponse(&pb.TransparentTransferResponse{Txid: txid}), nil
+	return &pb.TransparentTransferResponse{Txid: txid}, nil
 }
diff --git a/sidechain-orchestrator/sidechain/zside/handler_test.go b/sidechain-orchestrator/sidechain/zside/handler_test.go
index 54e8e72100..277736ae7a 100644
--- a/sidechain-orchestrator/sidechain/zside/handler_test.go
+++ b/sidechain-orchestrator/sidechain/zside/handler_test.go
@@ -9,7 +9,6 @@ import (
 	"strconv"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -57,7 +56,7 @@ func TestHandlerCallsTheZSideWalletMethods(t *testing.T) {
 		{
 			name: "withdraw",
 			call: func(h *Handler) error {
-				_, err := h.Withdraw(ctx, connect.NewRequest(&pb.WithdrawRequest{Address: "bc1q", AmountSats: 5000, SideFeeSats: 10, MainFeeSats: 20}))
+				_, err := h.Withdraw(ctx, &pb.WithdrawRequest{Address: "bc1q", AmountSats: 5000, SideFeeSats: 10, MainFeeSats: 20})
 				return err
 			},
 			want: recordedCall{Method: "create_withdrawal", Params: []any{"bc1q", 5000.0, 10.0, 20.0}},
@@ -65,7 +64,7 @@ func TestHandlerCallsTheZSideWalletMethods(t *testing.T) {
 		{
 			name: "transfer",
 			call: func(h *Handler) error {
-				_, err := h.Transfer(ctx, connect.NewRequest(&pb.TransferRequest{Address: "t-addr", AmountSats: 700, FeeSats: 3}))
+				_, err := h.Transfer(ctx, &pb.TransferRequest{Address: "t-addr", AmountSats: 700, FeeSats: 3})
 				return err
 			},
 			want: recordedCall{Method: "create_transparent_transfer", Params: []any{"t-addr", 700.0, 3.0}},
@@ -73,7 +72,7 @@ func TestHandlerCallsTheZSideWalletMethods(t *testing.T) {
 		{
 			name: "transparent transfer",
 			call: func(h *Handler) error {
-				_, err := h.TransparentTransfer(ctx, connect.NewRequest(&pb.TransparentTransferRequest{Address: "t-addr", AmountSats: 700, FeeSats: 3}))
+				_, err := h.TransparentTransfer(ctx, &pb.TransparentTransferRequest{Address: "t-addr", AmountSats: 700, FeeSats: 3})
 				return err
 			},
 			want: recordedCall{Method: "create_transparent_transfer", Params: []any{"t-addr", 700.0, 3.0}},
@@ -81,7 +80,7 @@ func TestHandlerCallsTheZSideWalletMethods(t *testing.T) {
 		{
 			name: "shielded transfer",
 			call: func(h *Handler) error {
-				_, err := h.ShieldedTransfer(ctx, connect.NewRequest(&pb.ShieldedTransferRequest{Address: "z-addr", AmountSats: 800, FeeSats: 4}))
+				_, err := h.ShieldedTransfer(ctx, &pb.ShieldedTransferRequest{Address: "z-addr", AmountSats: 800, FeeSats: 4})
 				return err
 			},
 			want: recordedCall{Method: "create_shielded_transfer", Params: []any{"z-addr", 800.0, 4.0}},
@@ -89,7 +88,7 @@ func TestHandlerCallsTheZSideWalletMethods(t *testing.T) {
 		{
 			name: "shield",
 			call: func(h *Handler) error {
-				_, err := h.Shield(ctx, connect.NewRequest(&pb.ShieldRequest{AmountSats: 900, FeeSats: 5}))
+				_, err := h.Shield(ctx, &pb.ShieldRequest{AmountSats: 900, FeeSats: 5})
 				return err
 			},
 			want: recordedCall{Method: "create_shield", Params: []any{900.0, 5.0}},
@@ -97,7 +96,7 @@ func TestHandlerCallsTheZSideWalletMethods(t *testing.T) {
 		{
 			name: "unshield",
 			call: func(h *Handler) error {
-				_, err := h.Unshield(ctx, connect.NewRequest(&pb.UnshieldRequest{AmountSats: 900, FeeSats: 5}))
+				_, err := h.Unshield(ctx, &pb.UnshieldRequest{AmountSats: 900, FeeSats: 5})
 				return err
 			},
 			want: recordedCall{Method: "create_unshield", Params: []any{900.0, 5.0}},
@@ -114,9 +113,9 @@ func TestHandlerCallsTheZSideWalletMethods(t *testing.T) {
 // get_bmm_inclusions answers a list of mainchain block hashes.
 func TestHandlerReturnsTheBmmInclusions(t *testing.T) {
 	handler, calls := recordingHandler(t, []string{"aa", "bb"})
-	resp, err := handler.GetBmmInclusions(context.Background(), connect.NewRequest(&pb.GetBmmInclusionsRequest{BlockHash: "cc"}))
+	resp, err := handler.GetBmmInclusions(context.Background(), &pb.GetBmmInclusionsRequest{BlockHash: "cc"})
 	require.NoError(t, err)
-	assert.JSONEq(t, `["aa","bb"]`, resp.Msg.Inclusions)
+	assert.JSONEq(t, `["aa","bb"]`, resp.Inclusions)
 	assert.Equal(t, []recordedCall{{Method: "get_bmm_inclusions", Params: []any{"cc"}}}, *calls)
 }
 
@@ -139,11 +138,11 @@ func TestHandlerListsCoinsAsTheMempoolLeavesThem(t *testing.T) {
 		}},
 	})
 
-	resp, err := NewHandler(node.JSONRPCProxy).GetWalletUtxos(context.Background(), connect.NewRequest(&pb.GetWalletUtxosRequest{}))
+	resp, err := NewHandler(node.JSONRPCProxy).GetWalletUtxos(context.Background(), &pb.GetWalletUtxosRequest{})
 	require.NoError(t, err)
 
 	var got []map[string]any
-	require.NoError(t, json.Unmarshal([]byte(resp.Msg.UtxosJson), &got))
+	require.NoError(t, json.Unmarshal([]byte(resp.UtxosJson), &got))
 	require.Len(t, got, 2)
 	assert.Equal(t, "t-one", got[0]["output"].(map[string]any)["address"])
 	assert.Nil(t, got[0]["confirmed"])
diff --git a/sidechain-orchestrator/sidechain/zside/schema_snapshot_test.go b/sidechain-orchestrator/sidechain/zside/schema_snapshot_test.go
index ffc81f9b19..ef85b12112 100644
--- a/sidechain-orchestrator/sidechain/zside/schema_snapshot_test.go
+++ b/sidechain-orchestrator/sidechain/zside/schema_snapshot_test.go
@@ -110,8 +110,6 @@ func TestCalledMethodsAreInTheSnapshot(t *testing.T) {
 			continue
 		}
 		request := reflect.New(method.Type.In(2).Elem())
-		msg := request.Elem().FieldByName("Msg")
-		msg.Set(reflect.New(msg.Type().Elem()))
 		out := value.Method(i).Call([]reflect.Value{reflect.ValueOf(ctx), request})
 		require.Nil(t, out[1].Interface(), method.Name)
 	}
diff --git a/sidechain-orchestrator/sidechain/zside/wealth_method_test.go b/sidechain-orchestrator/sidechain/zside/wealth_method_test.go
index 7b443d71b5..671cecf20d 100644
--- a/sidechain-orchestrator/sidechain/zside/wealth_method_test.go
+++ b/sidechain-orchestrator/sidechain/zside/wealth_method_test.go
@@ -9,7 +9,6 @@ import (
 	"strings"
 	"testing"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -47,8 +46,8 @@ func TestSidechainWealthCallsSidechainWealth(t *testing.T) {
 	proxy, seen := wealthNode(t, "10603007000")
 
 	resp, err := NewHandler(proxy).GetSidechainWealth(context.Background(),
-		connect.NewRequest(&pb.GetSidechainWealthRequest{}))
+		&pb.GetSidechainWealthRequest{})
 	require.NoError(t, err)
-	assert.Equal(t, int64(10603007000), resp.Msg.Sats)
+	assert.Equal(t, int64(10603007000), resp.Sats)
 	assert.Equal(t, []string{"sidechain_wealth"}, *seen)
 }
diff --git a/sidechain-orchestrator/sidechain_variant_boot_test.go b/sidechain-orchestrator/sidechain_variant_boot_test.go
index cc0c1780e8..9f4fa94c42 100644
--- a/sidechain-orchestrator/sidechain_variant_boot_test.go
+++ b/sidechain-orchestrator/sidechain_variant_boot_test.go
@@ -122,7 +122,7 @@ func TestSidechainVariant_DownloadAndBoot(t *testing.T) {
 	pid, err := pm.Start(context.Background(), cfg, nil, nil)
 	require.NoError(t, err)
 	require.NotZero(t, pid)
-	t.Cleanup(func() { _ = pm.Stop(context.Background(), cfg.Name, true) })
+	stopOnCleanup(t, pm, cfg.Name)
 
 	// Cmd.Path is the binPath we passed to exec.Command — the kernel
 	// successfully exec'd it, so this assertion catches a Start path that
diff --git a/sidechain-orchestrator/sidechain_variant_test.go b/sidechain-orchestrator/sidechain_variant_test.go
index 5de592fe66..1cdb74a378 100644
--- a/sidechain-orchestrator/sidechain_variant_test.go
+++ b/sidechain-orchestrator/sidechain_variant_test.go
@@ -349,7 +349,7 @@ func TestOrchestrator_ForceBackend_AdoptsProdPidWhenTestSidechainsEnabled(t *tes
 	pid, err := pm.StartWithOptions(context.Background(), cfg, []string{"30"}, nil, ProcessStartOptions{ForceBackend: true})
 	require.NoError(t, err)
 	require.NotZero(t, pid)
-	t.Cleanup(func() { _ = pm.Stop(context.Background(), cfg.Name, true) })
+	stopOnCleanup(t, pm, cfg.Name)
 
 	o := New(dataDir, "signet", bwDir, []BinaryConfig{cfg}, log)
 
@@ -396,7 +396,7 @@ func TestOrchestrator_StopStopsManagedSidechainGUICompanion(t *testing.T) {
 		},
 	)
 	require.NoError(t, err)
-	t.Cleanup(func() { _ = o.process.Stop(context.Background(), guiName, true) })
+	stopOnCleanup(t, o.process, guiName)
 
 	assert.True(t, o.process.IsRunning(guiName))
 	assert.False(t, o.process.IsRunning(cfg.Name), "GUI companion must not occupy the backend daemon slot")
@@ -409,7 +409,7 @@ func TestOrchestrator_StopStopsManagedSidechainGUICompanion(t *testing.T) {
 		ProcessStartOptions{ForceBackend: true},
 	)
 	require.NoError(t, err)
-	t.Cleanup(func() { _ = o.process.Stop(context.Background(), cfg.Name, true) })
+	stopOnCleanup(t, o.process, cfg.Name)
 
 	require.NoError(t, o.Stop(context.Background(), cfg.Name, false))
 	assert.False(t, o.process.IsRunning(guiName), "Stop(sidechain) must stop the managed GUI companion")
@@ -446,7 +446,7 @@ func TestOrchestrator_AdoptsGUICompanionUnderGUISlot(t *testing.T) {
 		},
 	)
 	require.NoError(t, err)
-	t.Cleanup(func() { _ = origin.process.Stop(context.Background(), guiName, true) })
+	stopOnCleanup(t, origin.process, guiName)
 
 	next := New(dataDir, "signet", t.TempDir(), []BinaryConfig{cfg}, log)
 	require.NoError(t, next.AdoptOrphans(context.Background()))
diff --git a/sidechain-orchestrator/testharness/mining.go b/sidechain-orchestrator/testharness/mining.go
index 45f6c5daf1..7e9fa25c93 100644
--- a/sidechain-orchestrator/testharness/mining.go
+++ b/sidechain-orchestrator/testharness/mining.go
@@ -7,7 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 )
 
@@ -17,11 +16,11 @@ func (n *Node) Mine(ctx context.Context, t *testing.T, blocks int) error {
 	t.Helper()
 
 	// Get a new address from the active wallet.
-	resp, err := n.WalletClient.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+	resp, err := n.WalletClient.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 	if err != nil {
 		return fmt.Errorf("get new address for mining: %w", err)
 	}
-	return n.MineToAddress(ctx, blocks, resp.Msg.Address)
+	return n.MineToAddress(ctx, blocks, resp.Address)
 }
 
 // MineToAddress mines blocks to a specific address.
@@ -45,42 +44,42 @@ func (n *Node) FundWallet(t *testing.T) string {
 	defer cancel()
 
 	// Check if wallets already exist.
-	status, err := n.WalletClient.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+	status, err := n.WalletClient.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 	if err != nil {
 		t.Fatalf("testharness[%s]: get wallet status: %v", n.Name, err)
 	}
 
-	if status.Msg.State == pb.WalletState_WALLET_STATE_NO_WALLET {
+	if status.State == pb.WalletState_WALLET_STATE_NO_WALLET {
 		// First wallet = enforcer type (required as slot 0).
-		_, err := n.WalletClient.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		_, err := n.WalletClient.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: n.Name + "-enforcer",
-		}))
+		})
 		if err != nil {
 			t.Fatalf("testharness[%s]: generate enforcer wallet: %v", n.Name, err)
 		}
 	}
 
 	// Second wallet = bitcoinCore type (this one gets a Core wallet).
-	genResp, err := n.WalletClient.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+	genResp, err := n.WalletClient.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 		Name: n.Name + "-core",
-	}))
+	})
 	if err != nil {
 		t.Fatalf("testharness[%s]: generate core wallet: %v", n.Name, err)
 	}
-	t.Logf("testharness[%s]: generated bitcoinCore wallet %s", n.Name, genResp.Msg.WalletId)
+	t.Logf("testharness[%s]: generated bitcoinCore wallet %s", n.Name, genResp.WalletId)
 
 	// Ensure Core wallets synced.
-	_, err = n.WalletClient.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+	_, err = n.WalletClient.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 	if err != nil {
 		t.Fatalf("testharness[%s]: ensure core wallets: %v", n.Name, err)
 	}
 
 	// Get a new address.
-	addrResp, err := n.WalletClient.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+	addrResp, err := n.WalletClient.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 	if err != nil {
 		t.Fatalf("testharness[%s]: get new address: %v", n.Name, err)
 	}
-	addr := addrResp.Msg.Address
+	addr := addrResp.Address
 	t.Logf("testharness[%s]: mining 101 blocks to %s", n.Name, addr)
 
 	// Mine 101 blocks (coinbase maturity).
@@ -114,8 +113,8 @@ func (n *Node) WaitForBalance(t *testing.T) {
 			}
 		default:
 		}
-		resp, err := n.WalletClient.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
-		if err == nil && resp.Msg.ConfirmedSats > 0 {
+		resp, err := n.WalletClient.GetBalance(ctx, &pb.GetBalanceRequest{})
+		if err == nil && resp.ConfirmedSats > 0 {
 			return
 		}
 		time.Sleep(500 * time.Millisecond)
diff --git a/sidechain-orchestrator/testharness/node.go b/sidechain-orchestrator/testharness/node.go
index 6f2bf2bfa9..206208c1cc 100644
--- a/sidechain-orchestrator/testharness/node.go
+++ b/sidechain-orchestrator/testharness/node.go
@@ -15,7 +15,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	rpc "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1/walletmanagerv1connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/localauth"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
@@ -232,12 +233,13 @@ port=%d
 	// 7. Create ConnectRPC client — same pattern as the drivechain-cli.
 	// Uses connect.WithGRPC() which triggers h2c upgrade via the server's
 	// h2c.NewHandler. This works over HTTP/1.1.
-	n.WalletClient = rpc.NewWalletManagerServiceClient(
+	n.WalletClient = rpc.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(
 		http.DefaultClient,
 		fmt.Sprintf("http://127.0.0.1:%d", grpcPort),
-		connect.WithGRPC(),
-		connect.WithInterceptors(localauth.Interceptor(bitwindowDir)),
-	)
+		connecthttp.WithReadMaxBytes(0),
+		connecthttp.WithGRPC(),
+	), localauth.ClientInterceptor(bitwindowDir),
+	))
 
 	nlog.Info().Msg("node ready")
 	return n
diff --git a/sidechain-orchestrator/wallet/cancel.go b/sidechain-orchestrator/wallet/cancel.go
index 9d66babbb9..c5fa7861d6 100644
--- a/sidechain-orchestrator/wallet/cancel.go
+++ b/sidechain-orchestrator/wallet/cancel.go
@@ -1,10 +1,9 @@
 package wallet
 
 import (
-	"errors"
 	"fmt"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 )
 
 const (
@@ -84,11 +83,11 @@ func planCancel(tx cancelTx) (*CancelPlan, string) {
 // than maxFeeSats.
 func (c *CancelPreview) allows(maxFeeSats int64) error {
 	if c.Plan == nil {
-		return connect.NewError(connect.CodeFailedPrecondition, errors.New(c.Reason))
+		return connect.NewError(connect.CodeFailedPrecondition, c.Reason)
 	}
 	if c.Plan.FeeSats > maxFeeSats {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf(
-			"the cancel fee rose to %d sats, over the %d sats you confirmed", c.Plan.FeeSats, maxFeeSats))
+		return connect.Errorf(connect.CodeFailedPrecondition,
+			"the cancel fee rose to %d sats, over the %d sats you confirmed", c.Plan.FeeSats, maxFeeSats)
 	}
 	return nil
 }
diff --git a/sidechain-orchestrator/wallet/consolidation_integration_test.go b/sidechain-orchestrator/wallet/consolidation_integration_test.go
index 7965244b22..63895e3880 100644
--- a/sidechain-orchestrator/wallet/consolidation_integration_test.go
+++ b/sidechain-orchestrator/wallet/consolidation_integration_test.go
@@ -8,7 +8,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/testharness"
 	"github.com/stretchr/testify/assert"
@@ -76,23 +75,23 @@ func sendConsolidation(
 ) (txid string, destination string, totalSats int64) {
 	t.Helper()
 
-	addrResp, err := node.WalletClient.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+	addrResp, err := node.WalletClient.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 	require.NoError(t, err, "get a fresh address for the consolidation")
-	destination = addrResp.Msg.Address
+	destination = addrResp.Address
 
 	for _, utxo := range inputs {
 		totalSats += utxo.AmountSats
 	}
 
-	sendResp, err := node.WalletClient.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+	sendResp, err := node.WalletClient.SendTransaction(ctx, &pb.SendTransactionRequest{
 		Destinations:          map[string]int64{destination: totalSats},
 		FeeRateSatPerVbyte:    1,
 		SubtractFeeFromAmount: true,
 		RequiredInputs:        inputs,
-	}))
+	})
 	require.NoError(t, err, "broadcast the consolidation of %d coins", len(inputs))
 
-	return sendResp.Msg.Txid, destination, totalSats
+	return sendResp.Txid, destination, totalSats
 }
 
 // TestConsolidationIntegration mines 1000 blocks, consolidates half the coins,
@@ -111,11 +110,11 @@ func TestConsolidationIntegration(t *testing.T) {
 	// holds two script kinds and a coin count caps nothing.
 	segwitAddress := node.FundWallet(t)
 
-	taprootResp, err := node.WalletClient.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{
+	taprootResp, err := node.WalletClient.GetNewAddress(ctx, &pb.GetNewAddressRequest{
 		AddressType: pb.AddressType_ADDRESS_TYPE_TAPROOT,
-	}))
+	})
 	require.NoError(t, err, "get a taproot address")
-	taprootAddress := taprootResp.Msg.Address
+	taprootAddress := taprootResp.Address
 	require.NotEqual(t, segwitAddress, taprootAddress)
 
 	mineBlocks(ctx, t, node, taprootAddress, 450)
@@ -127,9 +126,9 @@ func TestConsolidationIntegration(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, 1000, height, "the chain holds 1000 blocks")
 
-	unspentResp, err := node.WalletClient.ListUnspent(ctx, connect.NewRequest(&pb.ListUnspentRequest{}))
+	unspentResp, err := node.WalletClient.ListUnspent(ctx, &pb.ListUnspentRequest{})
 	require.NoError(t, err)
-	coins := unspentResp.Msg.Utxos
+	coins := unspentResp.Utxos
 	require.GreaterOrEqual(t, len(coins), 800, "1000 blocks leave the mature coinbase coins")
 
 	kinds := map[int32]int{}
@@ -186,11 +185,11 @@ func TestConsolidationIntegration(t *testing.T) {
 			{"second half", secondTxid, secondHalf, secondAddress, secondTotalSats},
 		} {
 			t.Run(tc.name, func(t *testing.T) {
-				decoded, err := node.WalletClient.DecodeTransaction(ctx, connect.NewRequest(&pb.DecodeTransactionRequest{
+				decoded, err := node.WalletClient.DecodeTransaction(ctx, &pb.DecodeTransactionRequest{
 					Input: tc.txid,
-				}))
+				})
 				require.NoError(t, err)
-				msg := decoded.Msg
+				msg := decoded
 
 				wanted := make(map[string]bool, len(tc.inputs))
 				for _, utxo := range tc.inputs {
@@ -263,27 +262,27 @@ func TestConsolidationIntegration(t *testing.T) {
 
 		var blockhash string
 		for _, txid := range []string{firstTxid, secondTxid} {
-			details, err := node.WalletClient.GetTransactionDetails(ctx, connect.NewRequest(&pb.GetTransactionDetailsRequest{
+			details, err := node.WalletClient.GetTransactionDetails(ctx, &pb.GetTransactionDetailsRequest{
 				Txid: txid,
-			}))
+			})
 			require.NoError(t, err)
-			require.GreaterOrEqual(t, details.Msg.Confirmations, int32(1), "transaction %s confirms", txid)
-			require.NotEmpty(t, details.Msg.Blockhash)
+			require.GreaterOrEqual(t, details.Confirmations, int32(1), "transaction %s confirms", txid)
+			require.NotEmpty(t, details.Blockhash)
 
 			if blockhash == "" {
-				blockhash = details.Msg.Blockhash
+				blockhash = details.Blockhash
 				continue
 			}
-			require.Equal(t, blockhash, details.Msg.Blockhash, "one block holds both transactions")
+			require.Equal(t, blockhash, details.Blockhash, "one block holds both transactions")
 		}
 	})
 
 	t.Run("the merged coins are gone and two coins take their place", func(t *testing.T) {
-		afterResp, err := node.WalletClient.ListUnspent(ctx, connect.NewRequest(&pb.ListUnspentRequest{}))
+		afterResp, err := node.WalletClient.ListUnspent(ctx, &pb.ListUnspentRequest{})
 		require.NoError(t, err)
 
 		merged := map[string]bool{}
-		for _, coin := range afterResp.Msg.Utxos {
+		for _, coin := range afterResp.Utxos {
 			require.False(t, spent[outpoint(coin.Txid, coin.Vout)],
 				"coin %s:%d went into a consolidation and must be spent", coin.Txid, coin.Vout)
 			if coin.Txid == firstTxid || coin.Txid == secondTxid {
diff --git a/sidechain-orchestrator/wallet/core_backend.go b/sidechain-orchestrator/wallet/core_backend.go
index 7fc0bf5226..ae513b8571 100644
--- a/sidechain-orchestrator/wallet/core_backend.go
+++ b/sidechain-orchestrator/wallet/core_backend.go
@@ -14,7 +14,7 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -853,7 +853,7 @@ func (p *CoreBackend) Send(ctx context.Context, walletID string, req SendRequest
 		return "", errors.New("a Core wallet send takes no excluded inputs")
 	}
 	if req.FixedFeeSats > 0 && req.SubtractFeeFromAmount {
-		return "", connect.NewError(connect.CodeInvalidArgument, ErrCoreMixedFee)
+		return "", connect.NewError(connect.CodeInvalidArgument, ErrCoreMixedFee.Error()).WithCause(ErrCoreMixedFee)
 	}
 	// External inputs carry no signature, so Core cannot size the fee for them.
 	if len(req.ExternalInputs) > 0 && req.FixedFeeSats <= 0 {
@@ -1164,7 +1164,7 @@ func (p *CoreBackend) SignTransaction(ctx context.Context, walletID, rawHex stri
 func (p *CoreBackend) CreatePSBT(ctx context.Context, walletID string, req SendRequest) (string, error) {
 	if len(req.ExternalInputs) > 0 || len(req.ExcludedInputs) > 0 || len(req.RawOutputs) > 0 || req.FixedFeeSats > 0 {
 		return "", connect.NewError(connect.CodeInvalidArgument,
-			errors.New("a Core wallet PSBT takes no external inputs, excluded inputs, raw outputs or fixed fee"))
+			"a Core wallet PSBT takes no external inputs, excluded inputs, raw outputs or fixed fee")
 	}
 	name, err := p.walletName(ctx, walletID)
 	if err != nil {
@@ -1238,7 +1238,7 @@ func (p *CoreBackend) PreviewBumpFee(ctx context.Context, walletID string, req B
 func (p *CoreBackend) previewBumpFee(ctx context.Context, name string, req BumpFeeRequest) (*BumpFeePreview, *RawTransaction, error) {
 	entry, err := p.rpc.GetMempoolEntry(ctx, req.TxID)
 	if err != nil {
-		return nil, nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("transaction %s waits in no mempool: %w", req.TxID, err))
+		return nil, nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("transaction %s waits in no mempool: %w", req.TxID, err).Error())
 	}
 	if entry.Vsize <= 0 {
 		return nil, nil, fmt.Errorf("transaction %s reports no size", req.TxID)
@@ -1379,7 +1379,7 @@ func (p *CoreBackend) BumpFee(ctx context.Context, walletID string, req BumpFeeR
 		return nil, err
 	}
 	if preview.Plan == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New(preview.Reason))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, preview.Reason)
 	}
 	plan := *preview.Plan
 	rate := req.NewFeeRate
@@ -1503,7 +1503,7 @@ func (p *CoreBackend) CancelTransaction(ctx context.Context, walletID, txid stri
 func (p *CoreBackend) previewCancel(ctx context.Context, walletID, name, txid string) (*CancelPreview, error) {
 	entry, err := p.rpc.GetMempoolEntry(ctx, txid)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("transaction %s waits in no mempool: %w", txid, err))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("transaction %s waits in no mempool: %w", txid, err).Error())
 	}
 	if entry.Vsize <= 0 {
 		return nil, fmt.Errorf("transaction %s reports no size", txid)
@@ -1601,7 +1601,7 @@ func (p *CoreBackend) CreateCpfp(ctx context.Context, walletID string, req CpfpR
 		return "", err
 	}
 	if req.TargetRate <= 0 {
-		return "", connect.NewError(connect.CodeInvalidArgument, errors.New("target fee rate must be positive"))
+		return "", connect.NewError(connect.CodeInvalidArgument, "target fee rate must be positive")
 	}
 
 	// minconf 0: the parent we must spend is unconfirmed, so the default
@@ -1615,12 +1615,12 @@ func (p *CoreBackend) CreateCpfp(ctx context.Context, walletID string, req CpfpR
 		return u.TxID == req.ParentTxID && u.Vout == req.ParentVout && u.Spendable
 	})
 	if !ok {
-		return "", connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("outpoint %s:%d is not a spendable wallet UTXO", req.ParentTxID, req.ParentVout))
+		return "", connect.Errorf(connect.CodeInvalidArgument,
+			"outpoint %s:%d is not a spendable wallet UTXO", req.ParentTxID, req.ParentVout)
 	}
 	if parent.Confirmations > 0 {
-		return "", connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("outpoint %s:%d is already confirmed; CPFP only applies to unconfirmed parents", req.ParentTxID, req.ParentVout))
+		return "", connect.Errorf(connect.CodeInvalidArgument,
+			"outpoint %s:%d is already confirmed; CPFP only applies to unconfirmed parents", req.ParentTxID, req.ParentVout)
 	}
 
 	if err := p.svc.checkCpfpParent(ctx, walletID, req); err != nil {
@@ -1634,8 +1634,8 @@ func (p *CoreBackend) CreateCpfp(ctx context.Context, walletID string, req CpfpR
 	parentVsize := entry.Vsize
 	parentFee := int64(math.Round(entry.Fees.Base * 1e8))
 	if parentVsize > 0 && req.TargetRate <= parentFee/parentVsize {
-		return "", connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("target rate %d sat/vB does not exceed parent rate %d sat/vB", req.TargetRate, parentFee/parentVsize))
+		return "", connect.Errorf(connect.CodeInvalidArgument,
+			"target rate %d sat/vB does not exceed parent rate %d sat/vB", req.TargetRate, parentFee/parentVsize)
 	}
 
 	childKind := p.walletScriptKind(walletID)
@@ -1645,7 +1645,7 @@ func (p *CoreBackend) CreateCpfp(ctx context.Context, walletID string, req CpfpR
 	childVsize := int64(11 + inputVsize(parentKind) + outputVsizeForKind(childKind))
 	_, outputSats, err := cpfpChildPlan(req.TargetRate, parentVsize, parentFee, childVsize, parentValueSats)
 	if err != nil {
-		return "", connect.NewError(connect.CodeInvalidArgument, err)
+		return "", connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	childAddr, err := p.NextReceiveAddress(ctx, walletID, childKind)
diff --git a/sidechain-orchestrator/wallet/core_backend_test.go b/sidechain-orchestrator/wallet/core_backend_test.go
index cf83f3c007..4339a560a6 100644
--- a/sidechain-orchestrator/wallet/core_backend_test.go
+++ b/sidechain-orchestrator/wallet/core_backend_test.go
@@ -17,7 +17,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet/bip47"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
diff --git a/sidechain-orchestrator/wallet/core_burn_integration_test.go b/sidechain-orchestrator/wallet/core_burn_integration_test.go
index de95c57b71..dd224e1d25 100644
--- a/sidechain-orchestrator/wallet/core_burn_integration_test.go
+++ b/sidechain-orchestrator/wallet/core_burn_integration_test.go
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/replay"
@@ -42,48 +41,48 @@ func TestCoreWalletBurnIntegration(t *testing.T) {
 
 	t.Run("BurnThroughTheWalletService", func(t *testing.T) {
 		client := node.WalletClient
-		status, err := client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		status, err := client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		walletID := status.Msg.ActiveWalletId
+		walletID := status.ActiveWalletId
 		requireCoreWallet(t, ctx, client, walletID)
 
-		derived, err := client.DeriveAddresses(ctx, connect.NewRequest(&pb.DeriveAddressesRequest{
+		derived, err := client.DeriveAddresses(ctx, &pb.DeriveAddressesRequest{
 			WalletId: walletID, StartIndex: 0, Count: 1,
-		}))
+		})
 		require.NoError(t, err)
-		require.Len(t, derived.Msg.Addresses, 1)
-		first := derived.Msg.Addresses[0]
+		require.Len(t, derived.Addresses, 1)
+		first := derived.Addresses[0]
 		requireCoreReceiveAddress(t, ctx, node.CoreRPC, first)
 		dataScript := addressDataScript(t, first)
 
-		created, err := client.CreatePsbt(ctx, connect.NewRequest(&pb.CreatePsbtRequest{
+		created, err := client.CreatePsbt(ctx, &pb.CreatePsbtRequest{
 			WalletId:     walletID,
 			Destinations: map[string]int64{burnAddress: coreBurnSats},
 			OpReturnHex:  hex.EncodeToString([]byte(first)),
-		}))
+		})
 		require.NoError(t, err)
 
-		preview, err := client.DecodeTransaction(ctx, connect.NewRequest(&pb.DecodeTransactionRequest{
-			WalletId: walletID, Input: created.Msg.PsbtBase64, CheckOwnership: true,
-		}))
+		preview, err := client.DecodeTransaction(ctx, &pb.DecodeTransactionRequest{
+			WalletId: walletID, Input: created.PsbtBase64, CheckOwnership: true,
+		})
 		require.NoError(t, err)
-		requireBurnPreview(t, preview.Msg, burnScript, dataScript)
-		require.Zero(t, preview.Msg.Locktime, "regtest takes no replay locktime")
+		requireBurnPreview(t, preview, burnScript, dataScript)
+		require.Zero(t, preview.Locktime, "regtest takes no replay locktime")
 
-		signed, err := client.SignPsbt(ctx, connect.NewRequest(&pb.SignPsbtRequest{
-			WalletId: walletID, PsbtBase64: created.Msg.PsbtBase64,
-		}))
+		signed, err := client.SignPsbt(ctx, &pb.SignPsbtRequest{
+			WalletId: walletID, PsbtBase64: created.PsbtBase64,
+		})
 		require.NoError(t, err)
-		final, err := client.FinalizePsbt(ctx, connect.NewRequest(&pb.FinalizePsbtRequest{PsbtBase64: signed.Msg.PsbtBase64}))
+		final, err := client.FinalizePsbt(ctx, &pb.FinalizePsbtRequest{PsbtBase64: signed.PsbtBase64})
 		require.NoError(t, err)
-		sent, err := client.BroadcastTransaction(ctx, connect.NewRequest(&pb.BroadcastTransactionRequest{
-			WalletId: walletID, TxHex: final.Msg.RawTxHex,
-		}))
+		sent, err := client.BroadcastTransaction(ctx, &pb.BroadcastTransactionRequest{
+			WalletId: walletID, TxHex: final.RawTxHex,
+		})
 		require.NoError(t, err)
-		require.Equal(t, preview.Msg.Txid, sent.Msg.Txid)
+		require.Equal(t, preview.Txid, sent.Txid)
 
 		require.NoError(t, node.MineToAddress(ctx, 1, first))
-		mined, err := node.CoreRPC.GetRawTransaction(ctx, sent.Msg.Txid)
+		mined, err := node.CoreRPC.GetRawTransaction(ctx, sent.Txid)
 		require.NoError(t, err)
 		require.Positive(t, mined.Confirmations)
 		onChain, err := wallet.DecodeTransaction(mined.Hex, net)
@@ -169,12 +168,12 @@ func addressDataScript(t *testing.T, address string) []byte {
 }
 
 func requireCoreWallet(t *testing.T, ctx context.Context, client interface {
-	ListWallets(context.Context, *connect.Request[pb.ListWalletsRequest]) (*connect.Response[pb.ListWalletsResponse], error)
+	ListWallets(context.Context, *pb.ListWalletsRequest) (*pb.ListWalletsResponse, error)
 }, walletID string) {
 	t.Helper()
-	wallets, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+	wallets, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 	require.NoError(t, err)
-	for _, w := range wallets.Msg.Wallets {
+	for _, w := range wallets.Wallets {
 		if w.Id == walletID {
 			require.Equal(t, pb.WalletType_WALLET_TYPE_BITCOIN_CORE, w.WalletType)
 			return
diff --git a/sidechain-orchestrator/wallet/core_cancel_test.go b/sidechain-orchestrator/wallet/core_cancel_test.go
index a95ce1755c..7d64596bf8 100644
--- a/sidechain-orchestrator/wallet/core_cancel_test.go
+++ b/sidechain-orchestrator/wallet/core_cancel_test.go
@@ -6,7 +6,7 @@ import (
 	"encoding/hex"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/stretchr/testify/assert"
diff --git a/sidechain-orchestrator/wallet/core_psbt_test.go b/sidechain-orchestrator/wallet/core_psbt_test.go
index 6ce51d73f3..9b41869c5a 100644
--- a/sidechain-orchestrator/wallet/core_psbt_test.go
+++ b/sidechain-orchestrator/wallet/core_psbt_test.go
@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
diff --git a/sidechain-orchestrator/wallet/core_receive_integration_test.go b/sidechain-orchestrator/wallet/core_receive_integration_test.go
index 18ad736048..8ae81f65fa 100644
--- a/sidechain-orchestrator/wallet/core_receive_integration_test.go
+++ b/sidechain-orchestrator/wallet/core_receive_integration_test.go
@@ -8,7 +8,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/testharness"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
@@ -32,24 +31,24 @@ func TestCoreReceiveBalancesMatchTheCoins(t *testing.T) {
 	defer cancel()
 	client := node.WalletClient
 
-	status, err := client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+	status, err := client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 	require.NoError(t, err)
-	walletID := status.Msg.ActiveWalletId
+	walletID := status.ActiveWalletId
 	requireCoreWallet(t, ctx, client, walletID)
 
 	checkAgrees := func(t *testing.T, stage string) {
 		t.Helper()
-		unspent, err := client.ListUnspent(ctx, connect.NewRequest(&pb.ListUnspentRequest{WalletId: walletID}))
+		unspent, err := client.ListUnspent(ctx, &pb.ListUnspentRequest{WalletId: walletID})
 		require.NoError(t, err)
-		receive, err := client.ListReceiveAddresses(ctx, connect.NewRequest(&pb.ListReceiveAddressesRequest{WalletId: walletID}))
+		receive, err := client.ListReceiveAddresses(ctx, &pb.ListReceiveAddressesRequest{WalletId: walletID})
 		require.NoError(t, err)
 
 		coins := map[string]int64{}
-		for _, u := range unspent.Msg.Utxos {
+		for _, u := range unspent.Utxos {
 			coins[u.Address] += u.AmountSats
 		}
 		listed := map[string]bool{}
-		for _, a := range receive.Msg.Addresses {
+		for _, a := range receive.Addresses {
 			listed[a.Address] = true
 			require.Equal(t, coins[a.Address], a.AmountSats,
 				"%s: address %s holds %d satoshis in the coin list", stage, a.Address, coins[a.Address])
@@ -81,13 +80,13 @@ func TestCoreLegacyReceiveSkipsTheBip47Key(t *testing.T) {
 	client := node.WalletClient
 
 	const mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
-	gen, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+	gen, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 		Name:           "Legacy",
 		CustomMnemonic: mnemonic,
 		ScriptType:     "legacy",
-	}))
+	})
 	require.NoError(t, err)
-	walletID := gen.Msg.WalletId
+	walletID := gen.WalletId
 	requireCoreWallet(t, ctx, client, walletID)
 	coreName := "wallet_" + walletID[:8]
 
@@ -98,7 +97,7 @@ func TestCoreLegacyReceiveSkipsTheBip47Key(t *testing.T) {
 	// The first read loads the Core wallet, and the backend imports the
 	// notification key in the background. Its address is then the only
 	// unused one Core lists.
-	_, err = client.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{WalletId: walletID}))
+	_, err = client.GetBalance(ctx, &pb.GetBalanceRequest{WalletId: walletID})
 	require.NoError(t, err)
 	require.Eventually(t, func() bool {
 		info, err := node.CoreRPC.GetAddressInfo(ctx, coreName, notification.EncodeAddress())
@@ -109,11 +108,11 @@ func TestCoreLegacyReceiveSkipsTheBip47Key(t *testing.T) {
 	require.NotContains(t, info.ParentDesc, "*")
 
 	for range 3 {
-		resp, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{WalletId: walletID}))
+		resp, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{WalletId: walletID})
 		require.NoError(t, err)
-		require.NotEqual(t, notification.EncodeAddress(), resp.Msg.Address)
-		info, err := node.CoreRPC.GetAddressInfo(ctx, coreName, resp.Msg.Address)
+		require.NotEqual(t, notification.EncodeAddress(), resp.Address)
+		info, err := node.CoreRPC.GetAddressInfo(ctx, coreName, resp.Address)
 		require.NoError(t, err)
-		require.Contains(t, info.ParentDesc, "*", resp.Msg.Address)
+		require.Contains(t, info.ParentDesc, "*", resp.Address)
 	}
 }
diff --git a/sidechain-orchestrator/wallet/cpfp.go b/sidechain-orchestrator/wallet/cpfp.go
index 2336c07c17..1524fca79a 100644
--- a/sidechain-orchestrator/wallet/cpfp.go
+++ b/sidechain-orchestrator/wallet/cpfp.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"math"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 )
 
 // CpfpRequest selects an unconfirmed wallet UTXO (the parent's output that this
@@ -53,7 +53,7 @@ func (s *Service) checkCpfpParent(ctx context.Context, walletID string, req Cpfp
 		return err
 	}
 	if frozen[parent.Key()] {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("outpoint %s is held by a live bmm bid", parent.Key()))
+		return connect.Errorf(connect.CodeFailedPrecondition, "outpoint %s is held by a live bmm bid", parent.Key())
 	}
 	return nil
 }
diff --git a/sidechain-orchestrator/wallet/electrum_backend.go b/sidechain-orchestrator/wallet/electrum_backend.go
index 526a7dfda3..370feafa84 100644
--- a/sidechain-orchestrator/wallet/electrum_backend.go
+++ b/sidechain-orchestrator/wallet/electrum_backend.go
@@ -18,7 +18,7 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
@@ -616,9 +616,9 @@ func (p *ElectrumBackend) NextReceiveAddress(ctx context.Context, walletID strin
 	// Serving a kind the wallet doesn't derive would yield an address it can
 	// neither track nor spend, so reject it rather than silently downgrade.
 	if !lo.Contains(p.receiveKinds(w), target) {
-		return DerivedAddress{}, connect.NewError(
+		return DerivedAddress{}, connect.Errorf(
 			connect.CodeUnimplemented,
-			fmt.Errorf("electrum wallet does not derive %s addresses", target),
+			"electrum wallet does not derive %s addresses", target,
 		)
 	}
 	return p.nextUnused(walletID, target, false)
@@ -1675,7 +1675,7 @@ func (p *ElectrumBackend) PreviewBumpFee(ctx context.Context, walletID string, r
 func (p *ElectrumBackend) previewBumpFee(ctx context.Context, scan *electrumScan, tx EsploraTx, req BumpFeeRequest) (*BumpFeePreview, error) {
 	net := p.params()
 	if tx.Status.Confirmed {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("transaction %s is confirmed", tx.TxID))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "transaction %s is confirmed", tx.TxID)
 	}
 	if tx.Weight <= 0 {
 		return nil, fmt.Errorf("transaction %s reports no weight", tx.TxID)
@@ -1773,7 +1773,7 @@ func (p *ElectrumBackend) BumpFee(ctx context.Context, walletID string, req Bump
 		return nil, err
 	}
 	if scan.watchOnly {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("watch-only electrum wallet cannot sign or send"))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, "watch-only electrum wallet cannot sign or send")
 	}
 	tx, err := p.verifiedTx(ctx, req.TxID)
 	if err != nil {
@@ -1784,7 +1784,7 @@ func (p *ElectrumBackend) BumpFee(ctx context.Context, walletID string, req Bump
 		return nil, err
 	}
 	if preview.Plan == nil {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New(preview.Reason))
+		return nil, connect.NewError(connect.CodeFailedPrecondition, preview.Reason)
 	}
 	plan := *preview.Plan
 
@@ -1911,7 +1911,7 @@ func (p *ElectrumBackend) previewCancel(ctx context.Context, walletID string, sc
 		return nil, err
 	}
 	if tx.Status.Confirmed {
-		return nil, connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("transaction %s is confirmed", txid))
+		return nil, connect.Errorf(connect.CodeFailedPrecondition, "transaction %s is confirmed", txid)
 	}
 	if tx.Weight <= 0 {
 		return nil, fmt.Errorf("transaction %s reports no weight", txid)
@@ -1969,7 +1969,7 @@ func (p *ElectrumBackend) CreateCpfp(ctx context.Context, walletID string, req C
 		return "", err
 	}
 	if req.TargetRate <= 0 {
-		return "", connect.NewError(connect.CodeInvalidArgument, errors.New("target fee rate must be positive"))
+		return "", connect.NewError(connect.CodeInvalidArgument, "target fee rate must be positive")
 	}
 
 	scan, err := p.scanWallet(ctx, walletID)
@@ -1982,12 +1982,12 @@ func (p *ElectrumBackend) CreateCpfp(ctx context.Context, walletID string, req C
 
 	parentUTXO, ok := findUTXO(p.spendableUTXOs(scan), req.ParentTxID, req.ParentVout)
 	if !ok {
-		return "", connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("outpoint %s:%d is not a spendable wallet UTXO", req.ParentTxID, req.ParentVout))
+		return "", connect.Errorf(connect.CodeInvalidArgument,
+			"outpoint %s:%d is not a spendable wallet UTXO", req.ParentTxID, req.ParentVout)
 	}
 	if parentUTXO.confirmed {
-		return "", connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("outpoint %s:%d is already confirmed; CPFP only applies to unconfirmed parents", req.ParentTxID, req.ParentVout))
+		return "", connect.Errorf(connect.CodeInvalidArgument,
+			"outpoint %s:%d is already confirmed; CPFP only applies to unconfirmed parents", req.ParentTxID, req.ParentVout)
 	}
 
 	if err := p.svc.checkCpfpParent(ctx, walletID, req); err != nil {
@@ -2001,8 +2001,8 @@ func (p *ElectrumBackend) CreateCpfp(ctx context.Context, walletID string, req C
 	parentVsize := int64(math.Ceil(float64(parentTx.Weight) / 4))
 	parentFee := parentTx.Fee
 	if parentVsize > 0 && req.TargetRate <= parentFee/parentVsize {
-		return "", connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("target rate %d sat/vB does not exceed parent rate %d sat/vB", req.TargetRate, parentFee/parentVsize))
+		return "", connect.Errorf(connect.CodeInvalidArgument,
+			"target rate %d sat/vB does not exceed parent rate %d sat/vB", req.TargetRate, parentFee/parentVsize)
 	}
 
 	w := p.svc.GetWalletByID(walletID)
@@ -2021,8 +2021,8 @@ func (p *ElectrumBackend) CreateCpfp(ctx context.Context, walletID string, req C
 	childVsize := int64(11 + inVsize + outputVsizeForKind(d.Kind))
 	childFee := packageChildFee(req.TargetRate, parentVsize, parentFee, childVsize, 1)
 	if childFee >= parentUTXO.amountSats {
-		return "", connect.NewError(connect.CodeInvalidArgument,
-			fmt.Errorf("child fee %d sats exceeds parent output value %d sats", childFee, parentUTXO.amountSats))
+		return "", connect.Errorf(connect.CodeInvalidArgument,
+			"child fee %d sats exceeds parent output value %d sats", childFee, parentUTXO.amountSats)
 	}
 
 	childAddr, err := p.nextUnusedAddrFromScan(walletID, scan, w.scriptKind(), false)
@@ -2105,11 +2105,11 @@ func (p *ElectrumBackend) ServerURL() string {
 func (p *ElectrumBackend) SetServerURL(ctx context.Context, url string) (int, error) {
 	sw, ok := p.client.(SwappableChainSource)
 	if !ok {
-		return 0, connect.NewError(connect.CodeUnimplemented, errors.New("this wallet's backend does not support switching servers"))
+		return 0, connect.NewError(connect.CodeUnimplemented, "this wallet's backend does not support switching servers")
 	}
 	normalized, err := normalizeEsploraURL(url)
 	if err != nil {
-		return 0, connect.NewError(connect.CodeInvalidArgument, err)
+		return 0, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	prev := sw.BaseURLs()
@@ -2118,7 +2118,7 @@ func (p *ElectrumBackend) SetServerURL(ctx context.Context, url string) (int, er
 	tip, err := sw.TipHeight(ctx)
 	if err != nil {
 		sw.SetBaseURLs(prev)
-		return 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("server %s unreachable, kept previous server: %w", normalized, err))
+		return 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("server %s unreachable, kept previous server: %w", normalized, err).Error())
 	}
 
 	// The new endpoint serves a different chain view, so every cached scan is
@@ -2147,31 +2147,31 @@ func (p *ElectrumBackend) TorConfig() (bool, string) {
 func (p *ElectrumBackend) SetTorConfig(ctx context.Context, enabled bool, proxyAddr string) (int, error) {
 	sw, ok := p.client.(SwappableChainSource)
 	if !ok {
-		return 0, connect.NewError(connect.CodeUnimplemented, errors.New("this wallet's backend does not support tor routing"))
+		return 0, connect.NewError(connect.CodeUnimplemented, "this wallet's backend does not support tor routing")
 	}
 	if enabled {
 		normalized, err := normalizeProxyAddr(proxyAddr)
 		if err != nil {
-			return 0, connect.NewError(connect.CodeInvalidArgument, err)
+			return 0, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 		proxyAddr = normalized
 	}
 
 	prevEnabled, prevProxy := sw.ProxyConfig()
 	if err := sw.SetProxy(enabled, proxyAddr); err != nil {
-		return 0, connect.NewError(connect.CodeInvalidArgument, err)
+		return 0, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 	}
 
 	tip, err := sw.TipHeight(ctx)
 	if err != nil {
 		_ = sw.SetProxy(prevEnabled, prevProxy)
-		return 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("proxy %s unreachable, kept previous tor config: %w", proxyAddr, err))
+		return 0, connect.NewError(connect.CodeUnavailable, fmt.Errorf("proxy %s unreachable, kept previous tor config: %w", proxyAddr, err).Error())
 	}
 
 	for _, fn := range p.proxyChange {
 		if err := fn(enabled, proxyAddr); err != nil {
 			_ = sw.SetProxy(prevEnabled, prevProxy)
-			return 0, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("apply tor config to side client: %w", err))
+			return 0, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("apply tor config to side client: %w", err).Error())
 		}
 	}
 
diff --git a/sidechain-orchestrator/wallet/electrum_backend_test.go b/sidechain-orchestrator/wallet/electrum_backend_test.go
index 3b098a23de..3e9135a075 100644
--- a/sidechain-orchestrator/wallet/electrum_backend_test.go
+++ b/sidechain-orchestrator/wallet/electrum_backend_test.go
@@ -14,7 +14,7 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
diff --git a/sidechain-orchestrator/wallet/electrum_cancel_test.go b/sidechain-orchestrator/wallet/electrum_cancel_test.go
index 7a9a103b7e..76e2ec6f2b 100644
--- a/sidechain-orchestrator/wallet/electrum_cancel_test.go
+++ b/sidechain-orchestrator/wallet/electrum_cancel_test.go
@@ -6,7 +6,7 @@ import (
 	"encoding/hex"
 	"testing"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/sidechain-orchestrator/wallet/integration_test.go b/sidechain-orchestrator/wallet/integration_test.go
index 065beae31d..0c248150d3 100644
--- a/sidechain-orchestrator/wallet/integration_test.go
+++ b/sidechain-orchestrator/wallet/integration_test.go
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/testharness"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet"
@@ -67,103 +66,103 @@ func TestWalletIntegration(t *testing.T) {
 		client := nodeA.WalletClient
 
 		// Clean slate.
-		_, err := client.DeleteAllWallets(ctx, connect.NewRequest(&pb.DeleteAllWalletsRequest{}))
+		_, err := client.DeleteAllWallets(ctx, &pb.DeleteAllWalletsRequest{})
 		require.NoError(t, err, "DeleteAllWallets")
 
 		// GenerateWallet → verify response.
-		genResp, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		genResp, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "Wallet-A1",
-		}))
+		})
 		require.NoError(t, err)
-		require.NotEmpty(t, genResp.Msg.WalletId)
-		require.NotEmpty(t, genResp.Msg.Mnemonic)
-		walletA1ID := genResp.Msg.WalletId
+		require.NotEmpty(t, genResp.WalletId)
+		require.NotEmpty(t, genResp.Mnemonic)
+		walletA1ID := genResp.WalletId
 		t.Logf("generated wallet A1: %s", walletA1ID)
 
 		// ListWallets → shows up.
-		listResp, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		listResp, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
-		require.Len(t, listResp.Msg.Wallets, 1)
-		require.Equal(t, walletA1ID, listResp.Msg.Wallets[0].Id)
+		require.Len(t, listResp.Wallets, 1)
+		require.Equal(t, walletA1ID, listResp.Wallets[0].Id)
 
-		statusResp, err := client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		statusResp, err := client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		require.Equal(t, pb.WalletState_WALLET_STATE_UNLOCKED, statusResp.Msg.State)
-		require.False(t, statusResp.Msg.Encrypted)
+		require.Equal(t, pb.WalletState_WALLET_STATE_UNLOCKED, statusResp.State)
+		require.False(t, statusResp.Encrypted)
 
 		// Create a second wallet and switch back.
-		genResp2, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		genResp2, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "Wallet-A2",
-		}))
+		})
 		require.NoError(t, err)
-		walletA2ID := genResp2.Msg.WalletId
+		walletA2ID := genResp2.WalletId
 
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: walletA1ID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: walletA1ID})
 		require.NoError(t, err)
 
-		statusResp, err = client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		statusResp, err = client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		require.Equal(t, walletA1ID, statusResp.Msg.ActiveWalletId)
+		require.Equal(t, walletA1ID, statusResp.ActiveWalletId)
 
 		// UpdateWalletMetadata.
-		_, err = client.UpdateWalletMetadata(ctx, connect.NewRequest(&pb.UpdateWalletMetadataRequest{
+		_, err = client.UpdateWalletMetadata(ctx, &pb.UpdateWalletMetadataRequest{
 			WalletId: walletA1ID,
 			Name:     "Wallet-A1-Renamed",
-		}))
+		})
 		require.NoError(t, err)
 
 		// EncryptWallet.
-		_, err = client.EncryptWallet(ctx, connect.NewRequest(&pb.EncryptWalletRequest{Password: "pass1"}))
+		_, err = client.EncryptWallet(ctx, &pb.EncryptWalletRequest{Password: "pass1"})
 		require.NoError(t, err)
 
-		statusResp, err = client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		statusResp, err = client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		require.True(t, statusResp.Msg.Encrypted)
+		require.True(t, statusResp.Encrypted)
 
 		// LockWallet.
-		_, err = client.LockWallet(ctx, connect.NewRequest(&pb.LockWalletRequest{}))
+		_, err = client.LockWallet(ctx, &pb.LockWalletRequest{})
 		require.NoError(t, err)
 
-		statusResp, err = client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		statusResp, err = client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		require.Equal(t, pb.WalletState_WALLET_STATE_LOCKED, statusResp.Msg.State)
+		require.Equal(t, pb.WalletState_WALLET_STATE_LOCKED, statusResp.State)
 
 		// UnlockWallet.
-		_, err = client.UnlockWallet(ctx, connect.NewRequest(&pb.UnlockWalletRequest{Password: "pass1"}))
+		_, err = client.UnlockWallet(ctx, &pb.UnlockWalletRequest{Password: "pass1"})
 		require.NoError(t, err)
 
-		statusResp, err = client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		statusResp, err = client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		require.Equal(t, pb.WalletState_WALLET_STATE_UNLOCKED, statusResp.Msg.State)
+		require.Equal(t, pb.WalletState_WALLET_STATE_UNLOCKED, statusResp.State)
 
 		// ChangePassword.
-		_, err = client.ChangePassword(ctx, connect.NewRequest(&pb.ChangePasswordRequest{
+		_, err = client.ChangePassword(ctx, &pb.ChangePasswordRequest{
 			OldPassword: "pass1",
 			NewPassword: "pass2",
-		}))
+		})
 		require.NoError(t, err)
 
 		// Lock + unlock with new password.
-		_, err = client.LockWallet(ctx, connect.NewRequest(&pb.LockWalletRequest{}))
+		_, err = client.LockWallet(ctx, &pb.LockWalletRequest{})
 		require.NoError(t, err)
-		_, err = client.UnlockWallet(ctx, connect.NewRequest(&pb.UnlockWalletRequest{Password: "pass2"}))
+		_, err = client.UnlockWallet(ctx, &pb.UnlockWalletRequest{Password: "pass2"})
 		require.NoError(t, err)
 
 		// RemoveEncryption.
-		_, err = client.RemoveEncryption(ctx, connect.NewRequest(&pb.RemoveEncryptionRequest{Password: "pass2"}))
+		_, err = client.RemoveEncryption(ctx, &pb.RemoveEncryptionRequest{Password: "pass2"})
 		require.NoError(t, err)
 
-		statusResp, err = client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		statusResp, err = client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		require.False(t, statusResp.Msg.Encrypted)
+		require.False(t, statusResp.Encrypted)
 
 		// DeleteWallet (the second one).
-		_, err = client.DeleteWallet(ctx, connect.NewRequest(&pb.DeleteWalletRequest{WalletId: walletA2ID}))
+		_, err = client.DeleteWallet(ctx, &pb.DeleteWalletRequest{WalletId: walletA2ID})
 		require.NoError(t, err)
 
-		listResp, err = client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		listResp, err = client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
-		require.Len(t, listResp.Msg.Wallets, 1)
+		require.Len(t, listResp.Wallets, 1)
 	})
 
 	// =========================================================================
@@ -175,28 +174,28 @@ func TestWalletIntegration(t *testing.T) {
 		client := nodeA.WalletClient
 
 		// The first wallet from Phase 1 should still be active (type=enforcer).
-		genResp, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		genResp, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "Core-Wallet-A",
-		}))
+		})
 		require.NoError(t, err)
-		_ = genResp.Msg.WalletId
+		_ = genResp.WalletId
 
 		// EnsureCoreWallets → descriptor wallet created in Core.
-		ensureResp, err := client.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+		ensureResp, err := client.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 		require.NoError(t, err)
-		require.Greater(t, ensureResp.Msg.SyncedCount, int32(0))
+		require.Greater(t, ensureResp.SyncedCount, int32(0))
 
 		// Switch to the bitcoinCore wallet.
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{
-			WalletId: genResp.Msg.WalletId,
-		}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{
+			WalletId: genResp.WalletId,
+		})
 		require.NoError(t, err)
 
 		// GetNewAddress → returns bcrt1... address.
-		addrResp, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		addrResp, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
-		require.True(t, strings.HasPrefix(addrResp.Msg.Address, "bcrt1"), "expected bcrt1 prefix, got %s", addrResp.Msg.Address)
-		addr := addrResp.Msg.Address
+		require.True(t, strings.HasPrefix(addrResp.Address, "bcrt1"), "expected bcrt1 prefix, got %s", addrResp.Address)
+		addr := addrResp.Address
 
 		// Mine 101 blocks to that address.
 		err = nodeA.MineToAddress(ctx, 101, addr)
@@ -204,18 +203,18 @@ func TestWalletIntegration(t *testing.T) {
 
 		// GetBalance → verify > 0 (poll on Windows where indexing is slow).
 		nodeA.WaitForBalance(t)
-		balResp, err := client.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
+		balResp, err := client.GetBalance(ctx, &pb.GetBalanceRequest{})
 		require.NoError(t, err)
-		require.Greater(t, balResp.Msg.ConfirmedSats, float64(0), "balance should be positive after mining")
-		t.Logf("balance after mining: %f sats", balResp.Msg.ConfirmedSats)
+		require.Greater(t, balResp.ConfirmedSats, float64(0), "balance should be positive after mining")
+		t.Logf("balance after mining: %f sats", balResp.ConfirmedSats)
 
 		// ListTransactions → verify coinbase txs.
-		txResp, err := client.ListTransactions(ctx, connect.NewRequest(&pb.ListTransactionsRequest{Count: 10}))
+		txResp, err := client.ListTransactions(ctx, &pb.ListTransactionsRequest{Count: 10})
 		require.NoError(t, err)
-		require.NotEmpty(t, txResp.Msg.Transactions)
+		require.NotEmpty(t, txResp.Transactions)
 		// At least one should be immature or generate.
 		found := false
-		for _, tx := range txResp.Msg.Transactions {
+		for _, tx := range txResp.Transactions {
 			if tx.Category == "immature" || tx.Category == "generate" {
 				found = true
 				break
@@ -224,22 +223,22 @@ func TestWalletIntegration(t *testing.T) {
 		require.True(t, found, "expected at least one coinbase transaction")
 
 		// ListUnspent → verify UTXOs exist.
-		utxoResp, err := client.ListUnspent(ctx, connect.NewRequest(&pb.ListUnspentRequest{}))
+		utxoResp, err := client.ListUnspent(ctx, &pb.ListUnspentRequest{})
 		require.NoError(t, err)
-		require.NotEmpty(t, utxoResp.Msg.Utxos)
+		require.NotEmpty(t, utxoResp.Utxos)
 
 		// ListReceiveAddresses → verify.
-		rcvResp, err := client.ListReceiveAddresses(ctx, connect.NewRequest(&pb.ListReceiveAddressesRequest{}))
+		rcvResp, err := client.ListReceiveAddresses(ctx, &pb.ListReceiveAddressesRequest{})
 		require.NoError(t, err)
-		require.NotEmpty(t, rcvResp.Msg.Addresses)
+		require.NotEmpty(t, rcvResp.Addresses)
 
 		// GetTransactionDetails on a coinbase tx.
-		if len(txResp.Msg.Transactions) > 0 {
-			txid := txResp.Msg.Transactions[0].Txid
-			detailResp, err := client.GetTransactionDetails(ctx, connect.NewRequest(&pb.GetTransactionDetailsRequest{Txid: txid}))
+		if len(txResp.Transactions) > 0 {
+			txid := txResp.Transactions[0].Txid
+			detailResp, err := client.GetTransactionDetails(ctx, &pb.GetTransactionDetailsRequest{Txid: txid})
 			require.NoError(t, err)
-			require.NotNil(t, detailResp.Msg.Transaction)
-			require.NotEmpty(t, detailResp.Msg.RawHex)
+			require.NotNil(t, detailResp.Transaction)
+			require.NotEmpty(t, detailResp.RawHex)
 		}
 	})
 
@@ -255,17 +254,17 @@ func TestWalletIntegration(t *testing.T) {
 		_ = addrB
 
 		// Get a fresh address on B.
-		addrBResp, err := nodeB.WalletClient.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		addrBResp, err := nodeB.WalletClient.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
-		addrBRecv := addrBResp.Msg.Address
+		addrBRecv := addrBResp.Address
 
 		// Send 1 BTC from A to B.
-		sendResp, err := nodeA.WalletClient.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+		sendResp, err := nodeA.WalletClient.SendTransaction(ctx, &pb.SendTransactionRequest{
 			Destinations: map[string]int64{addrBRecv: 100_000_000}, // 1 BTC in sats
-		}))
+		})
 		require.NoError(t, err)
-		require.NotEmpty(t, sendResp.Msg.Txid)
-		t.Logf("sent tx: %s", sendResp.Msg.Txid)
+		require.NotEmpty(t, sendResp.Txid)
+		t.Logf("sent tx: %s", sendResp.Txid)
 
 		// Mine 1 block on A.
 		err = nodeA.Mine(ctx, t, 1)
@@ -275,20 +274,20 @@ func TestWalletIntegration(t *testing.T) {
 		nodeA.WaitForSync(t, nodeB)
 
 		// GetBalance on B → verify ~1 BTC (100_000_000 sats).
-		balB, err := nodeB.WalletClient.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
+		balB, err := nodeB.WalletClient.GetBalance(ctx, &pb.GetBalanceRequest{})
 		require.NoError(t, err)
 		// B had mining rewards + 1 BTC received. Just check the received tx shows up.
-		txsB, err := nodeB.WalletClient.ListTransactions(ctx, connect.NewRequest(&pb.ListTransactionsRequest{Count: 200}))
+		txsB, err := nodeB.WalletClient.ListTransactions(ctx, &pb.ListTransactionsRequest{Count: 200})
 		require.NoError(t, err)
 		foundReceive := false
-		for _, tx := range txsB.Msg.Transactions {
+		for _, tx := range txsB.Transactions {
 			if tx.Category == "receive" && tx.AmountSats == 100_000_000 {
 				foundReceive = true
 				break
 			}
 		}
 		require.True(t, foundReceive, "B should have a 1 BTC receive tx")
-		t.Logf("B balance: %f sats (confirmed)", balB.Msg.ConfirmedSats)
+		t.Logf("B balance: %f sats (confirmed)", balB.ConfirmedSats)
 	})
 
 	// =========================================================================
@@ -300,43 +299,43 @@ func TestWalletIntegration(t *testing.T) {
 		client := nodeA.WalletClient
 
 		// Create a second bitcoinCore wallet on A.
-		gen2, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		gen2, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "Second-Core-Wallet",
-		}))
+		})
 		require.NoError(t, err)
-		wallet2ID := gen2.Msg.WalletId
+		wallet2ID := gen2.WalletId
 
 		// EnsureCoreWallets → both exist in Core.
-		_, err = client.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+		_, err = client.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 		require.NoError(t, err)
 
 		// Get address on second wallet.
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: wallet2ID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: wallet2ID})
 		require.NoError(t, err)
 
-		addrResp, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		addrResp, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
-		addr2 := addrResp.Msg.Address
+		addr2 := addrResp.Address
 
 		// Switch back to the wallet Phase 3 funded. Picking "the first Core
 		// wallet" would land on Wallet-A1, which holds nothing.
-		list, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		list, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
 		var coreWalletID string
-		for _, w := range list.Msg.Wallets {
+		for _, w := range list.Wallets {
 			if w.Name == "Core-Wallet-A" {
 				coreWalletID = w.Id
 				break
 			}
 		}
 		require.NotEmpty(t, coreWalletID, "Phase 3 must leave a funded Core-Wallet-A")
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: coreWalletID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: coreWalletID})
 		require.NoError(t, err)
 
 		// Send from first to second.
-		_, err = client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+		_, err = client.SendTransaction(ctx, &pb.SendTransactionRequest{
 			Destinations: map[string]int64{addr2: 50_000_000}, // 0.5 BTC
-		}))
+		})
 		require.NoError(t, err)
 
 		// Mine 1 block.
@@ -344,14 +343,14 @@ func TestWalletIntegration(t *testing.T) {
 		require.NoError(t, err)
 
 		// Check balance on second wallet.
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: wallet2ID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: wallet2ID})
 		require.NoError(t, err)
 
 		nodeA.WaitForBalance(t)
-		balResp, err := client.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
+		balResp, err := client.GetBalance(ctx, &pb.GetBalanceRequest{})
 		require.NoError(t, err)
-		require.Greater(t, balResp.Msg.ConfirmedSats, float64(0), "second wallet should have received funds")
-		t.Logf("second wallet balance: %f sats", balResp.Msg.ConfirmedSats)
+		require.Greater(t, balResp.ConfirmedSats, float64(0), "second wallet should have received funds")
+		t.Logf("second wallet balance: %f sats", balResp.ConfirmedSats)
 	})
 
 	// =========================================================================
@@ -365,64 +364,64 @@ func TestWalletIntegration(t *testing.T) {
 		// Create watch-only wallet from an xpub descriptor.
 		// Generate a fresh keypair so we get a valid tpub for regtest.
 		woXpub := generateTestXpub(t)
-		woResp, err := client.CreateWatchOnlyWallet(ctx, connect.NewRequest(&pb.CreateWatchOnlyWalletRequest{
+		woResp, err := client.CreateWatchOnlyWallet(ctx, &pb.CreateWatchOnlyWalletRequest{
 			Name:             "WatchOnly-Test",
 			XpubOrDescriptor: fmt.Sprintf("wpkh(%s/0/*)", woXpub),
 			GradientJson:     `{"background_svg":""}`,
-		}))
+		})
 		require.NoError(t, err)
-		woID := woResp.Msg.WalletId
+		woID := woResp.WalletId
 
 		// EnsureCoreWallets.
-		_, err = client.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+		_, err = client.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 		require.NoError(t, err)
 
 		// Switch to watch-only.
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: woID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: woID})
 		require.NoError(t, err)
 
 		// Get an address from the watch-only wallet.
-		woAddrResp, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		woAddrResp, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
-		woAddr := woAddrResp.Msg.Address
+		woAddr := woAddrResp.Address
 		require.True(t, strings.HasPrefix(woAddr, "bcrt1"))
 
 		// Switch to funded wallet and send to watch-only address.
-		list, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		list, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
 		var fundedID string
-		for _, w := range list.Msg.Wallets {
+		for _, w := range list.Wallets {
 			if w.Name == "Core-Wallet-A" {
 				fundedID = w.Id
 				break
 			}
 		}
 		require.NotEmpty(t, fundedID)
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: fundedID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: fundedID})
 		require.NoError(t, err)
 
-		_, err = client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+		_, err = client.SendTransaction(ctx, &pb.SendTransactionRequest{
 			Destinations: map[string]int64{woAddr: 10_000_000},
-		}))
+		})
 		require.NoError(t, err)
 
 		err = nodeA.Mine(ctx, t, 1)
 		require.NoError(t, err)
 
 		// Switch to watch-only and check balance.
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: woID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: woID})
 		require.NoError(t, err)
 
 		nodeA.WaitForBalance(t)
-		balResp, err := client.GetBalance(ctx, connect.NewRequest(&pb.GetBalanceRequest{}))
+		balResp, err := client.GetBalance(ctx, &pb.GetBalanceRequest{})
 		require.NoError(t, err)
-		require.Greater(t, balResp.Msg.ConfirmedSats, float64(0), "watch-only should see balance")
-		t.Logf("watch-only balance: %f sats", balResp.Msg.ConfirmedSats)
+		require.Greater(t, balResp.ConfirmedSats, float64(0), "watch-only should see balance")
+		t.Logf("watch-only balance: %f sats", balResp.ConfirmedSats)
 
 		// SendTransaction from watch-only → should FAIL (no private keys).
-		_, err = client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+		_, err = client.SendTransaction(ctx, &pb.SendTransactionRequest{
 			Destinations: map[string]int64{"bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080": 1_000_000},
-		}))
+		})
 		require.Error(t, err, "sending from watch-only wallet should fail")
 		t.Logf("watch-only send correctly failed: %v", err)
 	})
@@ -436,66 +435,66 @@ func TestWalletIntegration(t *testing.T) {
 		client := nodeA.WalletClient
 
 		// Switch to a funded bitcoinCore wallet.
-		list, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+		list, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 		require.NoError(t, err)
 		var fundedID string
-		for _, w := range list.Msg.Wallets {
+		for _, w := range list.Wallets {
 			if w.Name == "Core-Wallet-A" {
 				fundedID = w.Id
 				break
 			}
 		}
 		require.NotEmpty(t, fundedID)
-		_, err = client.SwitchWallet(ctx, connect.NewRequest(&pb.SwitchWalletRequest{WalletId: fundedID}))
+		_, err = client.SwitchWallet(ctx, &pb.SwitchWalletRequest{WalletId: fundedID})
 		require.NoError(t, err)
 
 		// Send a transaction.
-		addrResp, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{}))
+		addrResp, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{})
 		require.NoError(t, err)
 
-		sendResp, err := client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
-			Destinations: map[string]int64{addrResp.Msg.Address: 5_000_000},
-		}))
+		sendResp, err := client.SendTransaction(ctx, &pb.SendTransactionRequest{
+			Destinations: map[string]int64{addrResp.Address: 5_000_000},
+		})
 		require.NoError(t, err)
-		origTxid := sendResp.Msg.Txid
+		origTxid := sendResp.Txid
 
 		// The preview reports the fee, the size and the change output that pays.
-		preview, err := client.PreviewBumpFee(ctx, connect.NewRequest(&pb.PreviewBumpFeeRequest{
+		preview, err := client.PreviewBumpFee(ctx, &pb.PreviewBumpFeeRequest{
 			Txid: origTxid,
-		}))
+		})
 		require.NoError(t, err)
-		require.Empty(t, preview.Msg.Reason)
-		require.NotNil(t, preview.Msg.Plan)
-		require.Positive(t, preview.Msg.OldFeeSats)
-		require.Positive(t, preview.Msg.VsizeVbytes)
-		require.NotEmpty(t, preview.Msg.Outputs)
+		require.Empty(t, preview.Reason)
+		require.NotNil(t, preview.Plan)
+		require.Positive(t, preview.OldFeeSats)
+		require.Positive(t, preview.VsizeVbytes)
+		require.NotEmpty(t, preview.Outputs)
 		var changeOutputs int
-		for _, out := range preview.Msg.Outputs {
+		for _, out := range preview.Outputs {
 			if out.IsChange {
 				changeOutputs++
 			}
 		}
 		require.Equal(t, 1, changeOutputs, "the send returns change, and the preview marks it")
-		require.False(t, preview.Msg.Plan.ReducesPayment, "the change pays, not the recipient")
+		require.False(t, preview.Plan.ReducesPayment, "the change pays, not the recipient")
 
-		newRate := preview.Msg.SuggestedFeeRate + 5
-		bumpResp, err := client.BumpFee(ctx, connect.NewRequest(&pb.BumpFeeRequest{
+		newRate := preview.SuggestedFeeRate + 5
+		bumpResp, err := client.BumpFee(ctx, &pb.BumpFeeRequest{
 			Txid:       origTxid,
 			NewFeeRate: newRate,
-		}))
+		})
 		require.NoError(t, err)
-		require.NotEmpty(t, bumpResp.Msg.NewTxid)
-		require.NotEqual(t, origTxid, bumpResp.Msg.NewTxid)
-		require.NotNil(t, bumpResp.Msg.Plan)
-		require.Greater(t, bumpResp.Msg.Plan.NewFeeSats, bumpResp.Msg.Plan.OldFeeSats,
+		require.NotEmpty(t, bumpResp.NewTxid)
+		require.NotEqual(t, origTxid, bumpResp.NewTxid)
+		require.NotNil(t, bumpResp.Plan)
+		require.Greater(t, bumpResp.Plan.NewFeeSats, bumpResp.Plan.OldFeeSats,
 			"the replacement pays more than the transaction it replaces")
-		t.Logf("bumped fee: %s → %s (%d → %d sats)", origTxid, bumpResp.Msg.NewTxid,
-			bumpResp.Msg.Plan.OldFeeSats, bumpResp.Msg.Plan.NewFeeSats)
+		t.Logf("bumped fee: %s → %s (%d → %d sats)", origTxid, bumpResp.NewTxid,
+			bumpResp.Plan.OldFeeSats, bumpResp.Plan.NewFeeSats)
 
 		// A confirmed transaction has no replacement.
-		_, err = client.PreviewBumpFee(ctx, connect.NewRequest(&pb.PreviewBumpFeeRequest{
+		_, err = client.PreviewBumpFee(ctx, &pb.PreviewBumpFeeRequest{
 			Txid: "0000000000000000000000000000000000000000000000000000000000000000",
-		}))
+		})
 		require.Error(t, err, "a transaction that waits in no mempool cannot be replaced")
 
 		// Mine 1 block.
@@ -512,30 +511,30 @@ func TestWalletIntegration(t *testing.T) {
 		client := nodeA.WalletClient
 
 		// DeleteAllWallets on A → wipes everything.
-		_, err := client.DeleteAllWallets(ctx, connect.NewRequest(&pb.DeleteAllWalletsRequest{}))
+		_, err := client.DeleteAllWallets(ctx, &pb.DeleteAllWalletsRequest{})
 		require.NoError(t, err)
 
-		statusResp, err := client.GetWalletStatus(ctx, connect.NewRequest(&pb.GetWalletStatusRequest{}))
+		statusResp, err := client.GetWalletStatus(ctx, &pb.GetWalletStatusRequest{})
 		require.NoError(t, err)
-		require.Equal(t, pb.WalletState_WALLET_STATE_NO_WALLET, statusResp.Msg.State)
+		require.Equal(t, pb.WalletState_WALLET_STATE_NO_WALLET, statusResp.State)
 
 		// GenerateWallet → fresh start.
-		genResp, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		genResp, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "Fresh-Wallet",
-		}))
+		})
 		require.NoError(t, err)
-		require.NotEmpty(t, genResp.Msg.WalletId)
+		require.NotEmpty(t, genResp.WalletId)
 
 		// Generate a second (bitcoinCore type) so EnsureCoreWallets has something.
-		gen2, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{
+		gen2, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{
 			Name: "Fresh-Core",
-		}))
+		})
 		require.NoError(t, err)
 		_ = gen2
 
 		// EnsureCoreWallets → works from scratch.
-		ensureResp, err := client.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+		ensureResp, err := client.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 		require.NoError(t, err)
-		require.Greater(t, ensureResp.Msg.SyncedCount, int32(0))
+		require.Greater(t, ensureResp.SyncedCount, int32(0))
 	})
 }
diff --git a/sidechain-orchestrator/wallet/keygen.go b/sidechain-orchestrator/wallet/keygen.go
index aa4fc8e848..2c1bd37918 100644
--- a/sidechain-orchestrator/wallet/keygen.go
+++ b/sidechain-orchestrator/wallet/keygen.go
@@ -10,7 +10,7 @@ import (
 	"strconv"
 	"strings"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/tyler-smith/go-bip32"
 	"github.com/tyler-smith/go-bip39"
 	"golang.org/x/text/unicode/norm"
@@ -178,7 +178,7 @@ func GenerateFullWallet(name string, customMnemonic string, passphrase string, s
 	if customMnemonic != "" {
 		mnemonic, err = ParseMnemonic(customMnemonic)
 		if err != nil {
-			return nil, connect.NewError(connect.CodeInvalidArgument, err)
+			return nil, connect.NewError(connect.CodeInvalidArgument, err.Error()).WithCause(err)
 		}
 	} else {
 		mnemonic, err = GenerateMnemonic()
diff --git a/sidechain-orchestrator/wallet/multisiglounge_test.go b/sidechain-orchestrator/wallet/multisiglounge_test.go
index e3e78d7dbd..811fd22efd 100644
--- a/sidechain-orchestrator/wallet/multisiglounge_test.go
+++ b/sidechain-orchestrator/wallet/multisiglounge_test.go
@@ -6,8 +6,11 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -641,12 +644,18 @@ func newRegtest(t *testing.T, cli, daemon string) *regtest {
 
 func (rt *regtest) stop() {
 	_, _ = rt.call("stop")
-	// Give bitcoind a moment to release its datadir before t.TempDir cleanup.
-	time.Sleep(time.Second)
+	// bitcoind deletes its pid file last, after it releases the datadir.
+	pidFile := filepath.Join(rt.dataDir, "regtest", "bitcoind.pid")
+	for deadline := time.Now().Add(30 * time.Second); time.Now().Before(deadline); {
+		if _, err := os.Stat(pidFile); errors.Is(err, os.ErrNotExist) {
+			return
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
 }
 
 func (rt *regtest) call(args ...string) ([]byte, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
 	full := append([]string{"-regtest", "-datadir=" + rt.dataDir, "-rpcuser=u", "-rpcpassword=p"}, args...)
 	out, err := exec.CommandContext(ctx, rt.cli, full...).Output()
diff --git a/sidechain-orchestrator/wallet/send_preview.go b/sidechain-orchestrator/wallet/send_preview.go
index 4107493e13..ad7afd4f21 100644
--- a/sidechain-orchestrator/wallet/send_preview.go
+++ b/sidechain-orchestrator/wallet/send_preview.go
@@ -4,14 +4,13 @@ import (
 	"bytes"
 	"context"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"math"
 	"sort"
 	"strings"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
@@ -46,8 +45,8 @@ func refuseExcludedRequiredInputs(req SendRequest) error {
 	for _, ex := range req.ExcludedInputs {
 		for _, in := range req.RequiredInputs {
 			if in.TxID == ex.TxID && in.Vout == ex.Vout {
-				return connect.NewError(connect.CodeInvalidArgument,
-					fmt.Errorf("input %s:%d is both required and excluded", in.TxID, in.Vout))
+				return connect.Errorf(connect.CodeInvalidArgument,
+					"input %s:%d is both required and excluded", in.TxID, in.Vout)
 			}
 		}
 	}
@@ -56,7 +55,7 @@ func refuseExcludedRequiredInputs(req SendRequest) error {
 
 func requireSendPreviewRate(req SendRequest) error {
 	if req.FeeRateSatPerVB <= 0 {
-		return connect.NewError(connect.CodeInvalidArgument, errors.New("a send preview needs a fee rate"))
+		return connect.NewError(connect.CodeInvalidArgument, "a send preview needs a fee rate")
 	}
 	return nil
 }
diff --git a/sidechain-orchestrator/wallet/send_preview_integration_test.go b/sidechain-orchestrator/wallet/send_preview_integration_test.go
index a83d7ee9cd..b3d5997b2f 100644
--- a/sidechain-orchestrator/wallet/send_preview_integration_test.go
+++ b/sidechain-orchestrator/wallet/send_preview_integration_test.go
@@ -9,7 +9,6 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
 	pb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/walletmanager/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/testharness"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/wallet/bip47"
@@ -25,38 +24,38 @@ func smallCoinWallet(ctx context.Context, t *testing.T, node *testharness.Node,
 	client := node.WalletClient
 	fundedAddress = node.FundWallet(t)
 	node.WaitForBalance(t)
-	wallets, err := client.ListWallets(ctx, connect.NewRequest(&pb.ListWalletsRequest{}))
+	wallets, err := client.ListWallets(ctx, &pb.ListWalletsRequest{})
 	require.NoError(t, err)
 	var fundedID string
-	for _, w := range wallets.Msg.Wallets {
+	for _, w := range wallets.Wallets {
 		if w.Name == node.Name+"-core" {
 			fundedID = w.Id
 		}
 	}
 	require.NotEmpty(t, fundedID, "FundWallet mines to the Core wallet")
 
-	gen, err := client.GenerateWallet(ctx, connect.NewRequest(&pb.GenerateWalletRequest{Name: "small-coins"}))
+	gen, err := client.GenerateWallet(ctx, &pb.GenerateWalletRequest{Name: "small-coins"})
 	require.NoError(t, err)
-	smallID = gen.Msg.WalletId
-	_, err = client.EnsureCoreWallets(ctx, connect.NewRequest(&pb.EnsureCoreWalletsRequest{}))
+	smallID = gen.WalletId
+	_, err = client.EnsureCoreWallets(ctx, &pb.EnsureCoreWalletsRequest{})
 	require.NoError(t, err)
 
 	// The wallet hands out a new receive address only after the last one
 	// received coins, so every coin gets its own send and block.
 	for range count {
-		addr, err := client.GetNewAddress(ctx, connect.NewRequest(&pb.GetNewAddressRequest{WalletId: smallID}))
+		addr, err := client.GetNewAddress(ctx, &pb.GetNewAddressRequest{WalletId: smallID})
 		require.NoError(t, err)
-		_, err = client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+		_, err = client.SendTransaction(ctx, &pb.SendTransactionRequest{
 			WalletId:           fundedID,
-			Destinations:       map[string]int64{addr.Msg.Address: previewCoinSats},
+			Destinations:       map[string]int64{addr.Address: previewCoinSats},
 			FeeRateSatPerVbyte: 1,
-		}))
+		})
 		require.NoError(t, err)
 		require.NoError(t, node.MineToAddress(ctx, 1, fundedAddress))
 	}
-	utxos, err := client.ListUnspent(ctx, connect.NewRequest(&pb.ListUnspentRequest{WalletId: smallID}))
+	utxos, err := client.ListUnspent(ctx, &pb.ListUnspentRequest{WalletId: smallID})
 	require.NoError(t, err)
-	require.Len(t, utxos.Msg.Utxos, count)
+	require.Len(t, utxos.Utxos, count)
 
 	return smallID, fundedAddress
 }
@@ -82,34 +81,34 @@ func TestPreviewSendMatchesTheBroadcast(t *testing.T) {
 
 	send := map[string]int64{fundedAddress: 20 * previewCoinSats}
 	const rate = 2
-	var preview *connect.Response[pb.PreviewSendResponse]
+	var preview *pb.PreviewSendResponse
 	var err error
 	// The second preview reuses the change address of the first.
 	for range 2 {
-		preview, err = client.PreviewSend(ctx, connect.NewRequest(&pb.PreviewSendRequest{
+		preview, err = client.PreviewSend(ctx, &pb.PreviewSendRequest{
 			WalletId:           smallID,
 			Destinations:       send,
 			FeeRateSatPerVbyte: rate,
-		}))
+		})
 		require.NoError(t, err)
 	}
 	twoInputGuess := int64(rate * (10 + 2*148 + 2*34))
-	assert.Greater(t, preview.Msg.FeeSats, twoInputGuess, "21 coins cost more than the two-coin guess")
+	assert.Greater(t, preview.FeeSats, twoInputGuess, "21 coins cost more than the two-coin guess")
 
 	// Core picks coins at random, so the send pins the coins the preview priced.
-	sent, err := client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+	sent, err := client.SendTransaction(ctx, &pb.SendTransactionRequest{
 		WalletId:           smallID,
 		Destinations:       send,
 		FeeRateSatPerVbyte: rate,
-		RequiredInputs:     preview.Msg.Inputs,
-	}))
+		RequiredInputs:     preview.Inputs,
+	})
 	require.NoError(t, err)
-	entry, err := node.CoreRPC.GetMempoolEntry(ctx, sent.Msg.Txid)
+	entry, err := node.CoreRPC.GetMempoolEntry(ctx, sent.Txid)
 	require.NoError(t, err)
 
-	assert.Equal(t, int64(math.Round(entry.Fees.Base*1e8)), preview.Msg.FeeSats, "the send pays the fee the preview showed")
-	assert.GreaterOrEqual(t, preview.Msg.VsizeVbytes, entry.Vsize)
-	assert.LessOrEqual(t, preview.Msg.VsizeVbytes-entry.Vsize, int64(previewCoinCount), "a signature is at most 1 byte under the size Core assumes")
+	assert.Equal(t, int64(math.Round(entry.Fees.Base*1e8)), preview.FeeSats, "the send pays the fee the preview showed")
+	assert.GreaterOrEqual(t, preview.VsizeVbytes, entry.Vsize)
+	assert.LessOrEqual(t, preview.VsizeVbytes-entry.Vsize, int64(previewCoinCount), "a signature is at most 1 byte under the size Core assumes")
 }
 
 // TestPreviewSendPricesTheBip47Notification previews a first payment to a
@@ -129,40 +128,40 @@ func TestPreviewSendPricesTheBip47Notification(t *testing.T) {
 	send := map[string]int64{recipient.Base58(): 5 * previewCoinSats}
 
 	const rate = 2
-	preview, err := client.PreviewSend(ctx, connect.NewRequest(&pb.PreviewSendRequest{
+	preview, err := client.PreviewSend(ctx, &pb.PreviewSendRequest{
 		WalletId:           smallID,
 		Destinations:       send,
 		FeeRateSatPerVbyte: rate,
-	}))
+	})
 	require.NoError(t, err)
-	notification := preview.Msg.NotificationInput
+	notification := preview.NotificationInput
 	require.NotNil(t, notification, "a first payment publishes a notification")
-	for _, in := range preview.Msg.Inputs {
+	for _, in := range preview.Inputs {
 		require.False(t, in.Txid == notification.Txid && in.Vout == notification.Vout,
 			"the payment leaves the notification coin alone")
 	}
 
-	sent, err := client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+	sent, err := client.SendTransaction(ctx, &pb.SendTransactionRequest{
 		WalletId:           smallID,
 		Destinations:       send,
 		FeeRateSatPerVbyte: rate,
-		RequiredInputs:     preview.Msg.Inputs,
+		RequiredInputs:     preview.Inputs,
 		NotificationInput:  notification,
-	}))
+	})
 	require.NoError(t, err)
 
 	notificationTxid, err := node.CoreRPC.TxSpendingPrevout(ctx, notification.Txid, int(notification.Vout))
 	require.NoError(t, err)
 	require.NotEmpty(t, notificationTxid, "the notification spends the coin the preview picked")
-	require.NotEqual(t, sent.Msg.Txid, notificationTxid)
+	require.NotEqual(t, sent.Txid, notificationTxid)
 
 	fee := func(txid string) int64 {
 		entry, err := node.CoreRPC.GetMempoolEntry(ctx, txid)
 		require.NoError(t, err)
 		return int64(math.Round(entry.Fees.Base * 1e8))
 	}
-	assert.Equal(t, preview.Msg.NotificationFeeSats, fee(notificationTxid))
-	assert.Equal(t, preview.Msg.FeeSats, fee(sent.Msg.Txid))
+	assert.Equal(t, preview.NotificationFeeSats, fee(notificationTxid))
+	assert.Equal(t, preview.FeeSats, fee(sent.Txid))
 }
 
 // TestPreviewSendBip47OneCoinSendsBoth previews a first payment to a payment
@@ -178,39 +177,39 @@ func TestPreviewSendBip47OneCoinSendsBoth(t *testing.T) {
 	client := node.WalletClient
 
 	smallID, _ := smallCoinWallet(ctx, t, node, 1)
-	utxos, err := client.ListUnspent(ctx, connect.NewRequest(&pb.ListUnspentRequest{WalletId: smallID}))
+	utxos, err := client.ListUnspent(ctx, &pb.ListUnspentRequest{WalletId: smallID})
 	require.NoError(t, err)
-	coin := utxos.Msg.Utxos[0]
+	coin := utxos.Utxos[0]
 
 	recipient, err := bip47.PaymentCodeFromSeed(strings.Repeat("ab", 32), &chaincfg.RegressionNetParams)
 	require.NoError(t, err)
 	send := map[string]int64{recipient.Base58(): previewCoinSats / 2}
 
 	const rate = 2
-	preview, err := client.PreviewSend(ctx, connect.NewRequest(&pb.PreviewSendRequest{
+	preview, err := client.PreviewSend(ctx, &pb.PreviewSendRequest{
 		WalletId:           smallID,
 		Destinations:       send,
 		FeeRateSatPerVbyte: rate,
-	}))
+	})
 	require.NoError(t, err)
-	assert.True(t, preview.Msg.FeeIsEstimate)
-	assert.Positive(t, preview.Msg.FeeSats)
-	assert.Positive(t, preview.Msg.NotificationFeeSats)
-	assert.Empty(t, preview.Msg.Inputs)
-	assert.Nil(t, preview.Msg.NotificationInput)
+	assert.True(t, preview.FeeIsEstimate)
+	assert.Positive(t, preview.FeeSats)
+	assert.Positive(t, preview.NotificationFeeSats)
+	assert.Empty(t, preview.Inputs)
+	assert.Nil(t, preview.NotificationInput)
 
-	sent, err := client.SendTransaction(ctx, connect.NewRequest(&pb.SendTransactionRequest{
+	sent, err := client.SendTransaction(ctx, &pb.SendTransactionRequest{
 		WalletId:           smallID,
 		Destinations:       send,
 		FeeRateSatPerVbyte: rate,
-	}))
+	})
 	require.NoError(t, err)
 
 	notificationTxid, err := node.CoreRPC.TxSpendingPrevout(ctx, coin.Txid, int(coin.Vout))
 	require.NoError(t, err)
 	require.NotEmpty(t, notificationTxid, "the notification spends the only coin")
-	require.NotEqual(t, sent.Msg.Txid, notificationTxid)
-	for _, txid := range []string{notificationTxid, sent.Msg.Txid} {
+	require.NotEqual(t, sent.Txid, notificationTxid)
+	for _, txid := range []string{notificationTxid, sent.Txid} {
 		_, err := node.CoreRPC.GetMempoolEntry(ctx, txid)
 		require.NoError(t, err, "transaction %s is in the mempool", txid)
 	}
diff --git a/sidechain-orchestrator/wallet/service.go b/sidechain-orchestrator/wallet/service.go
index 25d27a1e4a..b3b2960c89 100644
--- a/sidechain-orchestrator/wallet/service.go
+++ b/sidechain-orchestrator/wallet/service.go
@@ -17,7 +17,7 @@ import (
 	"sync"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/walletfile"
 	"github.com/btcsuite/btcd/chaincfg"
@@ -855,11 +855,11 @@ func validateHotScriptType(s string) (string, error) {
 func (s *Service) createWatchOnly(name string, gradient json.RawMessage, xpubOrDescriptor string, requested ScriptKind, walletType WalletType) (*WalletData, error) {
 	desc, err := ParseDescriptorAs(xpubOrDescriptor, requested)
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid watch-only descriptor: %w", err))
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("invalid watch-only descriptor: %w", err).Error())
 	}
 	for _, k := range desc.Keys {
 		if k.Account.IsPrivate() {
-			return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("watch-only import must not contain private keys"))
+			return nil, connect.NewError(connect.CodeInvalidArgument, "watch-only import must not contain private keys")
 		}
 	}
 
@@ -1534,14 +1534,14 @@ func (s *Service) CheckDeletable(walletID string) error {
 
 func deleteRefusal(wallets []WalletData, starterWalletID, walletID string) error {
 	if !lo.ContainsBy(wallets, func(w WalletData) bool { return w.ID == walletID }) {
-		return connect.NewError(connect.CodeNotFound, fmt.Errorf("wallet %s not found", walletID))
+		return connect.Errorf(connect.CodeNotFound, "wallet %s not found", walletID)
 	}
 	// The starter wallet's seed derives every sidechain's starter. Delete it
 	// while another wallet remains and the pin moves to a different seed, so
 	// every sidechain restarts against coins the user does not hold. Deleting
 	// the last wallet is fine: nothing is left to derive from either way.
 	if starterWalletID == walletID && len(wallets) > 1 {
-		return connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("wallet %s derives the sidechain starters and cannot be deleted", walletID))
+		return connect.Errorf(connect.CodeFailedPrecondition, "wallet %s derives the sidechain starters and cannot be deleted", walletID)
 	}
 	return nil
 }
diff --git a/sidechain-orchestrator/zside_integration_test.go b/sidechain-orchestrator/zside_integration_test.go
index be158e886f..873da969f7 100644
--- a/sidechain-orchestrator/zside_integration_test.go
+++ b/sidechain-orchestrator/zside_integration_test.go
@@ -13,7 +13,8 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/config"
 	bmmpb "github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1"
 	"github.com/LayerTwo-Labs/sidesail/sidechain-orchestrator/gen/bmm/v1/bmmv1connect"
@@ -87,55 +88,55 @@ func TestZSideWallet(t *testing.T) {
 	startOrchestrator(t, orchBin, home, mainDir)
 	httpClient := &http.Client{Timeout: 120 * time.Second}
 	orchURL := fmt.Sprintf("http://127.0.0.1:%d", orchestratorPort)
-	wallets := walletmanagerv1connect.NewWalletManagerServiceClient(httpClient, orchURL)
-	bmm := bmmv1connect.NewBMMServiceClient(httpClient, orchURL)
-	zside := zsidev1connect.NewZSideServiceClient(httpClient, orchURL)
+	wallets := walletmanagerv1connect.NewWalletManagerServiceClient(connect.NewClient(connecthttp.NewTransport(httpClient, orchURL, connecthttp.WithReadMaxBytes(0))))
+	bmm := bmmv1connect.NewBMMServiceClient(connect.NewClient(connecthttp.NewTransport(httpClient, orchURL, connecthttp.WithReadMaxBytes(0))))
+	zside := zsidev1connect.NewZSideServiceClient(connect.NewClient(connecthttp.NewTransport(httpClient, orchURL, connecthttp.WithReadMaxBytes(0))))
 	waitFor(t, 60*time.Second, "drivechaind", func() bool {
-		_, err := wallets.GetWalletStatus(ctx, connect.NewRequest(&wmpb.GetWalletStatusRequest{}))
+		_, err := wallets.GetWalletStatus(ctx, &wmpb.GetWalletStatusRequest{})
 		return err == nil
 	})
 	waitFor(t, 90*time.Second, "zside through drivechaind", func() bool {
-		_, err := zside.GetBlockCount(ctx, connect.NewRequest(&zpb.GetBlockCountRequest{}))
+		_, err := zside.GetBlockCount(ctx, &zpb.GetBlockCountRequest{})
 		return err == nil
 	})
 
-	mnemonic, err := zside.GenerateMnemonic(ctx, connect.NewRequest(&zpb.GenerateMnemonicRequest{}))
+	mnemonic, err := zside.GenerateMnemonic(ctx, &zpb.GenerateMnemonicRequest{})
 	require.NoError(t, err, "generate mnemonic")
-	_, err = zside.SetSeedFromMnemonic(ctx, connect.NewRequest(&zpb.SetSeedFromMnemonicRequest{
-		Mnemonic: mnemonic.Msg.Mnemonic,
-	}))
+	_, err = zside.SetSeedFromMnemonic(ctx, &zpb.SetSeedFromMnemonicRequest{
+		Mnemonic: mnemonic.Mnemonic,
+	})
 	require.NoError(t, err, "set seed")
 
 	// Only a Bitcoin Core wallet can build the bare scriptPubKey an M8 needs.
 	generateWallet(ctx, t, wallets, "enforcer")
 	coreWallet := generateWallet(ctx, t, wallets, "core")
-	_, err = wallets.SwitchWallet(ctx, connect.NewRequest(&wmpb.SwitchWalletRequest{WalletId: coreWallet}))
+	_, err = wallets.SwitchWallet(ctx, &wmpb.SwitchWalletRequest{WalletId: coreWallet})
 	require.NoError(t, err)
-	mainAddr, err := wallets.GetNewAddress(ctx, connect.NewRequest(&wmpb.GetNewAddressRequest{}))
+	mainAddr, err := wallets.GetNewAddress(ctx, &wmpb.GetNewAddressRequest{})
 	require.NoError(t, err)
-	mineMainchain(ctx, t, enforcer, 150, mainAddr.Msg.Address)
+	mineMainchain(ctx, t, enforcer, 150, mainAddr.Address)
 	waitFor(t, 60*time.Second, "bidding funds", func() bool {
-		bal, err := wallets.GetBalance(ctx, connect.NewRequest(&wmpb.GetBalanceRequest{}))
-		return err == nil && bal.Msg.ConfirmedSats > 0
+		bal, err := wallets.GetBalance(ctx, &wmpb.GetBalanceRequest{})
+		return err == nil && bal.ConfirmedSats > 0
 	})
 
 	mainchain := newCoreRPC(t, filepath.Join(mainDir, "regtest"), mainchainRPCPort)
 	height := func(t *testing.T) int64 {
 		t.Helper()
-		resp, err := zside.GetBlockCount(ctx, connect.NewRequest(&zpb.GetBlockCountRequest{}))
+		resp, err := zside.GetBlockCount(ctx, &zpb.GetBlockCountRequest{})
 		require.NoError(t, err)
-		return resp.Msg.Count
+		return resp.Count
 	}
 	blindMergeMine := func(t *testing.T) {
 		t.Helper()
 		before := height(t)
-		bid, err := bmm.CreateBid(ctx, connect.NewRequest(&bmmpb.CreateBidRequest{
+		bid, err := bmm.CreateBid(ctx, &bmmpb.CreateBidRequest{
 			Sidechain: orchpb.BinaryType_BINARY_TYPE_ZSIDE,
 			BidSats:   1000,
-		}))
+		})
 		require.NoError(t, err, "create bid")
-		require.NotEmpty(t, bid.Msg.BmmTxid)
-		mineMainchain(ctx, t, enforcer, 1, mainAddr.Msg.Address)
+		require.NotEmpty(t, bid.BmmTxid)
+		mineMainchain(ctx, t, enforcer, 1, mainAddr.Address)
 		// The node lists no inclusion for a mainchain block it was not given, so
 		// the test names it, as the BMM engine does.
 		var included string
@@ -143,18 +144,18 @@ func TestZSideWallet(t *testing.T) {
 
 		deadline := time.Now().Add(60 * time.Second)
 		for {
-			resp, err := bmm.ConnectBid(ctx, connect.NewRequest(&bmmpb.ConnectBidRequest{
+			resp, err := bmm.ConnectBid(ctx, &bmmpb.ConnectBidRequest{
 				Sidechain:     orchpb.BinaryType_BINARY_TYPE_ZSIDE,
-				CriticalHash:  bid.Msg.CriticalHash,
-				BlockJson:     bid.Msg.BlockJson,
+				CriticalHash:  bid.CriticalHash,
+				BlockJson:     bid.BlockJson,
 				MainBlockHash: included,
-			}))
-			require.NoError(t, err, "connect bid %s", bid.Msg.CriticalHash)
-			if resp.Msg.Connected {
+			})
+			require.NoError(t, err, "connect bid %s", bid.CriticalHash)
+			if resp.Connected {
 				break
 			}
 			if time.Now().After(deadline) {
-				t.Fatalf("bid %s for %s in block %s never connected", bid.Msg.BmmTxid, bid.Msg.CriticalHash, included)
+				t.Fatalf("bid %s for %s in block %s never connected", bid.BmmTxid, bid.CriticalHash, included)
 			}
 			time.Sleep(time.Second)
 		}
@@ -162,10 +163,10 @@ func TestZSideWallet(t *testing.T) {
 	}
 	balance := func(t *testing.T) *zpb.GetBalanceResponse {
 		t.Helper()
-		resp, err := zside.GetBalance(ctx, connect.NewRequest(&zpb.GetBalanceRequest{}))
+		resp, err := zside.GetBalance(ctx, &zpb.GetBalanceRequest{})
 		require.NoError(t, err)
-		t.Logf("balance: shielded %d, transparent %d", resp.Msg.TotalShieldedSats, resp.Msg.TotalTransparentSats)
-		return resp.Msg
+		t.Logf("balance: shielded %d, transparent %d", resp.TotalShieldedSats, resp.TotalTransparentSats)
+		return resp
 	}
 
 	// A transaction no block can take would sit in every later template.
@@ -173,7 +174,7 @@ func TestZSideWallet(t *testing.T) {
 		if !t.Failed() {
 			return
 		}
-		_, err := zside.RemoveFromMempool(ctx, connect.NewRequest(&zpb.RemoveFromMempoolRequest{Txid: txid}))
+		_, err := zside.RemoveFromMempool(ctx, &zpb.RemoveFromMempoolRequest{Txid: txid})
 		if err != nil {
 			t.Errorf("remove %s from the mempool: %v", txid, err)
 		}
@@ -196,18 +197,18 @@ func TestZSideWallet(t *testing.T) {
 	})
 
 	t.Run("deposit", func(t *testing.T) {
-		addr, err := zside.GetNewTransparentAddress(ctx, connect.NewRequest(&zpb.GetNewTransparentAddressRequest{}))
+		addr, err := zside.GetNewTransparentAddress(ctx, &zpb.GetNewTransparentAddressRequest{})
 		require.NoError(t, err)
-		deposit, err := wallets.CreateDeposit(ctx, connect.NewRequest(&wmpb.CreateDepositRequest{
+		deposit, err := wallets.CreateDeposit(ctx, &wmpb.CreateDepositRequest{
 			Slot:        zsideSlot,
-			Destination: formatDepositAddress(addr.Msg.Address, zsideSlot),
+			Destination: formatDepositAddress(addr.Address, zsideSlot),
 			AmountSats:  depositSats,
 			FeeSats:     10_000,
-		}))
+		})
 		require.NoError(t, err, "create deposit")
-		require.NotEmpty(t, deposit.Msg.Txid)
+		require.NotEmpty(t, deposit.Txid)
 
-		mineMainchain(ctx, t, enforcer, 1, mainAddr.Msg.Address)
+		mineMainchain(ctx, t, enforcer, 1, mainAddr.Address)
 		blindMergeMine(t)
 		require.EqualValues(t, depositSats, balance(t).TotalTransparentSats)
 	})
@@ -215,50 +216,50 @@ func TestZSideWallet(t *testing.T) {
 	// The wallet spends only confirmed coins, so each transfer gets its own block.
 	t.Run("transparent transfer", func(t *testing.T) {
 		before := balance(t)
-		dest, err := zside.GetNewTransparentAddress(ctx, connect.NewRequest(&zpb.GetNewTransparentAddressRequest{}))
+		dest, err := zside.GetNewTransparentAddress(ctx, &zpb.GetNewTransparentAddressRequest{})
 		require.NoError(t, err)
-		transfer, err := zside.TransparentTransfer(ctx, connect.NewRequest(&zpb.TransparentTransferRequest{
-			Address: dest.Msg.Address, AmountSats: moveSats, FeeSats: feeSats,
-		}))
+		transfer, err := zside.TransparentTransfer(ctx, &zpb.TransparentTransferRequest{
+			Address: dest.Address, AmountSats: moveSats, FeeSats: feeSats,
+		})
 		require.NoError(t, err, "transparent transfer")
-		defer dropOnFailure(t, transfer.Msg.Txid)
+		defer dropOnFailure(t, transfer.Txid)
 		blindMergeMine(t)
 		require.InDelta(t, before.TotalTransparentSats-feeSats, balance(t).TotalTransparentSats, zsideFeeSlack)
 	})
 
 	t.Run("transfer", func(t *testing.T) {
 		before := balance(t)
-		dest, err := zside.GetNewTransparentAddress(ctx, connect.NewRequest(&zpb.GetNewTransparentAddressRequest{}))
+		dest, err := zside.GetNewTransparentAddress(ctx, &zpb.GetNewTransparentAddressRequest{})
 		require.NoError(t, err)
-		transfer, err := zside.Transfer(ctx, connect.NewRequest(&zpb.TransferRequest{
-			Address: dest.Msg.Address, AmountSats: moveSats, FeeSats: feeSats,
-		}))
+		transfer, err := zside.Transfer(ctx, &zpb.TransferRequest{
+			Address: dest.Address, AmountSats: moveSats, FeeSats: feeSats,
+		})
 		require.NoError(t, err, "transfer")
-		defer dropOnFailure(t, transfer.Msg.Txid)
-		coins, err := zside.GetWalletUtxos(ctx, connect.NewRequest(&zpb.GetWalletUtxosRequest{}))
+		defer dropOnFailure(t, transfer.Txid)
+		coins, err := zside.GetWalletUtxos(ctx, &zpb.GetWalletUtxosRequest{})
 		require.NoError(t, err, "wallet coins with a transfer in the mempool")
-		require.Contains(t, coins.Msg.UtxosJson, `"confirmed":false`, "the change of the transfer waits in the mempool")
+		require.Contains(t, coins.UtxosJson, `"confirmed":false`, "the change of the transfer waits in the mempool")
 		blindMergeMine(t)
 		require.InDelta(t, before.TotalTransparentSats-feeSats, balance(t).TotalTransparentSats, zsideFeeSlack)
 	})
 
 	t.Run("withdraw", func(t *testing.T) {
-		dest, err := wallets.GetNewAddress(ctx, connect.NewRequest(&wmpb.GetNewAddressRequest{}))
+		dest, err := wallets.GetNewAddress(ctx, &wmpb.GetNewAddressRequest{})
 		require.NoError(t, err)
-		withdrawal, err := zside.Withdraw(ctx, connect.NewRequest(&zpb.WithdrawRequest{
-			Address: dest.Msg.Address, AmountSats: withdrawSats, SideFeeSats: feeSats, MainFeeSats: 10_000,
-		}))
+		withdrawal, err := zside.Withdraw(ctx, &zpb.WithdrawRequest{
+			Address: dest.Address, AmountSats: withdrawSats, SideFeeSats: feeSats, MainFeeSats: 10_000,
+		})
 		require.NoError(t, err, "withdraw")
-		defer dropOnFailure(t, withdrawal.Msg.Txid)
+		defer dropOnFailure(t, withdrawal.Txid)
 
 		// The node bundles withdrawals only at some heights, so mine until it does.
 		for range 12 {
 			blindMergeMine(t)
-			bundle, err := zside.GetPendingWithdrawalBundle(ctx, connect.NewRequest(&zpb.GetPendingWithdrawalBundleRequest{}))
+			bundle, err := zside.GetPendingWithdrawalBundle(ctx, &zpb.GetPendingWithdrawalBundleRequest{})
 			require.NoError(t, err)
-			if bundle.Msg.BundleJson != "" && bundle.Msg.BundleJson != "null" {
-				require.Contains(t, bundle.Msg.BundleJson, fmt.Sprintf(`"main_address":%q`, dest.Msg.Address))
-				require.Contains(t, bundle.Msg.BundleJson, fmt.Sprintf(`"value":%d`, withdrawSats))
+			if bundle.BundleJson != "" && bundle.BundleJson != "null" {
+				require.Contains(t, bundle.BundleJson, fmt.Sprintf(`"main_address":%q`, dest.Address))
+				require.Contains(t, bundle.BundleJson, fmt.Sprintf(`"value":%d`, withdrawSats))
 				t.Logf("pending withdrawal bundle at zSide height %d", height(t))
 				return
 			}
@@ -268,9 +269,9 @@ func TestZSideWallet(t *testing.T) {
 
 	t.Run("shield", func(t *testing.T) {
 		before := balance(t)
-		shield, err := zside.Shield(ctx, connect.NewRequest(&zpb.ShieldRequest{AmountSats: shieldSats, FeeSats: feeSats}))
+		shield, err := zside.Shield(ctx, &zpb.ShieldRequest{AmountSats: shieldSats, FeeSats: feeSats})
 		require.NoError(t, err, "shield")
-		defer dropOnFailure(t, shield.Msg.Txid)
+		defer dropOnFailure(t, shield.Txid)
 		blindMergeMine(t)
 		after := balance(t)
 		require.EqualValues(t, before.TotalShieldedSats+shieldSats, after.TotalShieldedSats)
@@ -282,13 +283,13 @@ func TestZSideWallet(t *testing.T) {
 
 	t.Run("shielded transfer", func(t *testing.T) {
 		before := balance(t)
-		dest, err := zside.GetNewShieldedAddress(ctx, connect.NewRequest(&zpb.GetNewShieldedAddressRequest{}))
+		dest, err := zside.GetNewShieldedAddress(ctx, &zpb.GetNewShieldedAddressRequest{})
 		require.NoError(t, err)
-		transfer, err := zside.ShieldedTransfer(ctx, connect.NewRequest(&zpb.ShieldedTransferRequest{
-			Address: dest.Msg.Address, AmountSats: moveSats, FeeSats: feeSats,
-		}))
+		transfer, err := zside.ShieldedTransfer(ctx, &zpb.ShieldedTransferRequest{
+			Address: dest.Address, AmountSats: moveSats, FeeSats: feeSats,
+		})
 		require.NoError(t, err, "shielded transfer")
-		defer dropOnFailure(t, transfer.Msg.Txid)
+		defer dropOnFailure(t, transfer.Txid)
 		blindMergeMine(t)
 		require.EqualValues(t, before.TotalShieldedSats-feeSats, balance(t).TotalShieldedSats)
 		for range zsideAnchorDepth {
@@ -298,9 +299,9 @@ func TestZSideWallet(t *testing.T) {
 
 	t.Run("unshield", func(t *testing.T) {
 		before := balance(t)
-		unshield, err := zside.Unshield(ctx, connect.NewRequest(&zpb.UnshieldRequest{AmountSats: unshieldSats, FeeSats: feeSats}))
+		unshield, err := zside.Unshield(ctx, &zpb.UnshieldRequest{AmountSats: unshieldSats, FeeSats: feeSats})
 		require.NoError(t, err, "unshield")
-		defer dropOnFailure(t, unshield.Msg.Txid)
+		defer dropOnFailure(t, unshield.Txid)
 		blindMergeMine(t)
 		after := balance(t)
 		require.EqualValues(t, before.TotalShieldedSats-unshieldSats-feeSats, after.TotalShieldedSats)
diff --git a/thunder/pubspec.yaml b/thunder/pubspec.yaml
index d30899970e..8c4569fd62 100644
--- a/thunder/pubspec.yaml
+++ b/thunder/pubspec.yaml
@@ -2,7 +2,7 @@ name: thunder
 description: UI for Drivechain (BIP300/301) based sidechains
 publish_to: "none" # Remove this line if you wish to publish to pub.dev
 
-version: 1.0.369
+version: 1.0.370
 
 environment:
   sdk: 3.13.5
diff --git a/truthcoin/pubspec.yaml b/truthcoin/pubspec.yaml
index 7c4958b716..0ec8af5461 100644
--- a/truthcoin/pubspec.yaml
+++ b/truthcoin/pubspec.yaml
@@ -2,7 +2,7 @@ name: truthcoin
 description: UI for Bitcoin Hivemind prediction market sidechain
 publish_to: "none" # Remove this line if you wish to publish to pub.dev
 
-version: 1.0.240
+version: 1.0.241
 
 environment:
   sdk: 3.13.5
diff --git a/zside/pubspec.yaml b/zside/pubspec.yaml
index fff083cfab..f1b775cc64 100644
--- a/zside/pubspec.yaml
+++ b/zside/pubspec.yaml
@@ -2,7 +2,7 @@ name: zside
 description: UI for Drivechain (BIP300/301) based sidechains
 publish_to: "none" # Remove this line if you wish to publish to pub.dev
 
-version: 1.0.366
+version: 1.0.367
 
 environment:
   sdk: 3.13.5