go: migrate services to Connect v2

.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

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

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

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

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
 }