Add getTransactions endpoint

cmd/soroban-rpc/internal/methods/get_transactions.go

@@ -5,6 +5,7 @@ import (
 	"encoding/base64"
 	"fmt"
 	"io"
+	"strconv"
 
 	"github.com/creachadair/jrpc2"
 	"github.com/creachadair/jrpc2/handler"
@@ -19,8 +20,8 @@ import (
 
 // TransactionsPaginationOptions defines the available options for paginating through transactions.
 type TransactionsPaginationOptions struct {
-	Cursor *toid.ID `json:"cursor,omitempty"`
-	Limit  uint     `json:"limit,omitempty"`
+	Cursor string `json:"cursor,omitempty"`
+	Limit  uint   `json:"limit,omitempty"`
 }
 
 // GetTransactionsRequest represents the request parameters for fetching transactions within a range of ledgers.
@@ -31,7 +32,7 @@ type GetTransactionsRequest struct {
 
 // isValid checks the validity of the request parameters.
 func (req GetTransactionsRequest) isValid(maxLimit uint, ledgerRange ledgerbucketwindow.LedgerRange) error {
-	if req.Pagination != nil && req.Pagination.Cursor != nil {
+	if req.Pagination != nil && req.Pagination.Cursor != "" {
 		if req.StartLedger != 0 {
 			return errors.New("startLedger and cursor cannot both be set")
 		}
@@ -94,15 +95,15 @@ func (h transactionsRPCHandler) getTransactionsByLedgerSequence(ctx context.Cont
 	ledgerRange, err := h.dbReader.GetLedgerRange(ctx)
 	if err != nil {
 		return GetTransactionsResponse{}, &jrpc2.Error{
-			Code:    jrpc2.InvalidParams,
+			Code:    jrpc2.InternalError,
 			Message: err.Error(),
 		}
 	}
 
 	err = request.isValid(h.maxLimit, ledgerRange)
 	if err != nil {
 		return GetTransactionsResponse{}, &jrpc2.Error{
-			Code:    jrpc2.InvalidParams,
+			Code:    jrpc2.InvalidRequest,
 			Message: err.Error(),
 		}
 	}
@@ -111,8 +112,16 @@ func (h transactionsRPCHandler) getTransactionsByLedgerSequence(ctx context.Cont
 	start := toid.New(int32(request.StartLedger), 1, 1)
 	limit := h.defaultLimit
 	if request.Pagination != nil {
-		if request.Pagination.Cursor != nil {
-			start = request.Pagination.Cursor
+		if request.Pagination.Cursor != "" {
+			cursorInt, err := strconv.ParseInt(request.Pagination.Cursor, 10, 64)
+			if err != nil {
+				return GetTransactionsResponse{}, &jrpc2.Error{
+					Code:    jrpc2.InvalidParams,
+					Message: err.Error(),
+				}
+			}
+
+			*start = toid.Parse(cursorInt)
 			// increment tx index because, when paginating,
 			// we start with the item right after the cursor
 			start.TransactionOrder++
@@ -135,7 +144,7 @@ LedgerLoop:
 				err = errors.Errorf("ledger close meta not found: %d", ledgerSeq)
 			}
 			return GetTransactionsResponse{}, &jrpc2.Error{
-				Code:    jrpc2.InvalidParams,
+				Code:    jrpc2.InternalError,
 				Message: err.Error(),
 			}
 		}
@@ -144,7 +153,7 @@ LedgerLoop:
 		reader, err := ingest.NewLedgerTransactionReaderFromLedgerCloseMeta(h.networkPassphrase, ledger)
 		if err != nil {
 			return GetTransactionsResponse{}, &jrpc2.Error{
-				Code:    jrpc2.InvalidParams,
+				Code:    jrpc2.InternalError,
 				Message: err.Error(),
 			}
 		}
@@ -155,7 +164,7 @@ LedgerLoop:
 			startTxIdx = int(start.TransactionOrder)
 			if ierr := reader.Seek(startTxIdx - 1); ierr != nil && ierr != io.EOF {
 				return GetTransactionsResponse{}, &jrpc2.Error{
-					Code:    jrpc2.InvalidParams,
+					Code:    jrpc2.InternalError,
 					Message: err.Error(),
 				}
 			}
@@ -173,15 +182,15 @@ LedgerLoop:
 					break
 				}
 				return GetTransactionsResponse{}, &jrpc2.Error{
-					Code:    jrpc2.InvalidParams,
+					Code:    jrpc2.InternalError,
 					Message: err.Error(),
 				}
 			}
 
 			tx, err := db.ParseTransaction(ledger, ingestTx)
 			if err != nil {
 				return GetTransactionsResponse{}, &jrpc2.Error{
-					Code:    jrpc2.InvalidParams,
+					Code:    jrpc2.InternalError,
 					Message: err.Error(),
 				}
 			}

cmd/soroban-rpc/internal/methods/get_transactions_test.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"testing"
 
+	"github.com/creachadair/jrpc2"
+	"github.com/stellar/go/support/errors"
 	"github.com/stellar/go/toid"
 	"github.com/stellar/go/xdr"
 	"github.com/stretchr/testify/assert"
@@ -58,14 +60,14 @@ func TestGetTransactions_DefaultLimit(t *testing.T) {
 	assert.NoError(t, err)
 
 	// assert latest ledger details
-	assert.Equal(t, response.LatestLedger, uint32(10))
-	assert.Equal(t, response.LatestLedgerCloseTime, int64(350))
+	assert.Equal(t, uint32(10), response.LatestLedger)
+	assert.Equal(t, int64(350), response.LatestLedgerCloseTime)
 
 	// assert pagination
-	assert.Equal(t, response.Cursor, toid.New(5, 2, 1).String())
+	assert.Equal(t, toid.New(5, 2, 1).String(), response.Cursor)
 
 	// assert transactions result
-	assert.Equal(t, len(response.Transactions), 10)
+	assert.Equal(t, 10, len(response.Transactions))
 }
 
 func TestGetTransactions_DefaultLimitExceedsLatestLedger(t *testing.T) {
@@ -93,14 +95,14 @@ func TestGetTransactions_DefaultLimitExceedsLatestLedger(t *testing.T) {
 	assert.NoError(t, err)
 
 	// assert latest ledger details
-	assert.Equal(t, response.LatestLedger, uint32(3))
-	assert.Equal(t, response.LatestLedgerCloseTime, int64(175))
+	assert.Equal(t, uint32(3), response.LatestLedger)
+	assert.Equal(t, int64(175), response.LatestLedgerCloseTime)
 
 	// assert pagination
-	assert.Equal(t, response.Cursor, toid.New(3, 2, 1).String())
+	assert.Equal(t, toid.New(3, 2, 1).String(), response.Cursor)
 
 	// assert transactions result
-	assert.Equal(t, len(response.Transactions), 6)
+	assert.Equal(t, 6, len(response.Transactions))
 }
 
 func TestGetTransactions_CustomLimit(t *testing.T) {
@@ -131,16 +133,16 @@ func TestGetTransactions_CustomLimit(t *testing.T) {
 	assert.NoError(t, err)
 
 	// assert latest ledger details
-	assert.Equal(t, response.LatestLedger, uint32(10))
-	assert.Equal(t, response.LatestLedgerCloseTime, int64(350))
+	assert.Equal(t, uint32(10), response.LatestLedger)
+	assert.Equal(t, int64(350), response.LatestLedgerCloseTime)
 
 	// assert pagination
-	assert.Equal(t, response.Cursor, toid.New(1, 2, 1).String())
+	assert.Equal(t, toid.New(1, 2, 1).String(), response.Cursor)
 
 	// assert transactions result
-	assert.Equal(t, len(response.Transactions), 2)
-	assert.Equal(t, response.Transactions[0].Ledger, uint32(1))
-	assert.Equal(t, response.Transactions[1].Ledger, uint32(1))
+	assert.Equal(t, 2, len(response.Transactions))
+	assert.Equal(t, uint32(1), response.Transactions[0].Ledger)
+	assert.Equal(t, uint32(1), response.Transactions[1].Ledger)
 }
 
 func TestGetTransactions_CustomLimitAndCursor(t *testing.T) {
@@ -162,30 +164,26 @@ func TestGetTransactions_CustomLimitAndCursor(t *testing.T) {
 
 	request := GetTransactionsRequest{
 		Pagination: &TransactionsPaginationOptions{
-			Cursor: &toid.ID{
-				LedgerSequence:   1,
-				TransactionOrder: 2,
-				OperationOrder:   1,
-			},
-			Limit: 3,
+			Cursor: toid.New(1, 2, 1).String(),
+			Limit:  3,
 		},
 	}
 
 	response, err := handler.getTransactionsByLedgerSequence(context.TODO(), request)
 	assert.NoError(t, err)
 
 	// assert latest ledger details
-	assert.Equal(t, response.LatestLedger, uint32(10))
-	assert.Equal(t, response.LatestLedgerCloseTime, int64(350))
+	assert.Equal(t, uint32(10), response.LatestLedger)
+	assert.Equal(t, int64(350), response.LatestLedgerCloseTime)
 
 	// assert pagination
-	assert.Equal(t, response.Cursor, toid.New(3, 1, 1).String())
+	assert.Equal(t, toid.New(3, 1, 1).String(), response.Cursor)
 
 	// assert transactions result
-	assert.Equal(t, len(response.Transactions), 3)
-	assert.Equal(t, response.Transactions[0].Ledger, uint32(2))
-	assert.Equal(t, response.Transactions[1].Ledger, uint32(2))
-	assert.Equal(t, response.Transactions[2].Ledger, uint32(3))
+	assert.Equal(t, 3, len(response.Transactions))
+	assert.Equal(t, uint32(2), response.Transactions[0].Ledger)
+	assert.Equal(t, uint32(2), response.Transactions[1].Ledger)
+	assert.Equal(t, uint32(3), response.Transactions[2].Ledger)
 }
 
 func TestGetTransactions_InvalidStartLedger(t *testing.T) {
@@ -210,7 +208,8 @@ func TestGetTransactions_InvalidStartLedger(t *testing.T) {
 	}
 
 	response, err := handler.getTransactionsByLedgerSequence(context.TODO(), request)
-	assert.Equal(t, err.Error(), "[-32602] start ledger must be between the oldest ledger: 1 and the latest ledger: 3 for this rpc instance.")
+	expectedErr := errors.Errorf("[%d] start ledger must be between the oldest ledger: 1 and the latest ledger: 3 for this rpc instance.", jrpc2.InvalidRequest)
+	assert.Equal(t, expectedErr.Error(), err.Error())
 	assert.Nil(t, response.Transactions)
 }
 
@@ -240,7 +239,8 @@ func TestGetTransactions_LedgerNotFound(t *testing.T) {
 	}
 
 	response, err := handler.getTransactionsByLedgerSequence(context.TODO(), request)
-	assert.Equal(t, err.Error(), "[-32602] ledger close meta not found: 2")
+	expectedErr := errors.Errorf("[%d] ledger close meta not found: 2", jrpc2.InternalError)
+	assert.Equal(t, expectedErr.Error(), err.Error())
 	assert.Nil(t, response.Transactions)
 }
 
@@ -269,5 +269,34 @@ func TestGetTransactions_LimitGreaterThanMaxLimit(t *testing.T) {
 	}
 
 	_, err := handler.getTransactionsByLedgerSequence(context.TODO(), request)
-	assert.Equal(t, err.Error(), "[-32602] limit must not exceed 100")
+	expectedErr := errors.Errorf("[%d] limit must not exceed 100", jrpc2.InvalidRequest)
+	assert.Equal(t, expectedErr.Error(), err.Error())
+}
+
+func TestGetTransactions_InvalidCursorString(t *testing.T) {
+	mockDbReader := db.NewMockTransactionStore(NetworkPassphrase)
+	mockLedgerReader := db.NewMockLedgerReader(mockDbReader)
+	for i := 1; i <= 3; i++ {
+		meta := createTestLedger(uint32(i))
+		err := mockDbReader.InsertTransactions(meta)
+		assert.NoError(t, err)
+	}
+
+	handler := transactionsRPCHandler{
+		ledgerReader:      mockLedgerReader,
+		dbReader:          mockDbReader,
+		maxLimit:          100,
+		defaultLimit:      10,
+		networkPassphrase: NetworkPassphrase,
+	}
+
+	request := GetTransactionsRequest{
+		Pagination: &TransactionsPaginationOptions{
+			Cursor: "abc",
+		},
+	}
+
+	_, err := handler.getTransactionsByLedgerSequence(context.TODO(), request)
+	expectedErr := errors.Errorf("[%d] strconv.ParseInt: parsing \"abc\": invalid syntax", jrpc2.InvalidParams)
+	assert.Equal(t, expectedErr.Error(), err.Error())
 }

cmd/soroban-rpc/internal/test/get_transactions_test.go

@@ -2,13 +2,11 @@ package test
 
 import (
 	"context"
-	"strconv"
 	"testing"
 
 	"github.com/creachadair/jrpc2"
 	"github.com/creachadair/jrpc2/jhttp"
 	"github.com/stellar/go/keypair"
-	"github.com/stellar/go/toid"
 	"github.com/stellar/go/txnbuild"
 	"github.com/stretchr/testify/assert"
 
@@ -89,12 +87,9 @@ func TestGetTransactions(t *testing.T) {
 	assert.Equal(t, result.Transactions[0].Ledger, ledgers[0])
 
 	// Get transactions using previous result's cursor
-	c, err := strconv.ParseInt(result.Cursor, 10, 64)
-	assert.NoError(t, err)
-	cursor := toid.Parse(c)
 	request = methods.GetTransactionsRequest{
 		Pagination: &methods.TransactionsPaginationOptions{
-			Cursor: &cursor,
+			Cursor: result.Cursor,
 			Limit:  5,
 		},
 	}