Add getTransactions endpoint

cmd/soroban-rpc/internal/config/config.go

@@ -25,6 +25,7 @@ type Config struct {
 	CheckpointFrequency                         uint32
 	CoreRequestTimeout                          time.Duration
 	DefaultEventsLimit                          uint
+	DefaultTransactionsLimit                    uint
 	EventLedgerRetentionWindow                  uint32
 	FriendbotURL                                string
 	HistoryArchiveURLs                          []string
@@ -33,6 +34,7 @@ type Config struct {
 	LogFormat                                   LogFormat
 	LogLevel                                    logrus.Level
 	MaxEventsLimit                              uint
+	MaxTransactionsLimit                        uint
 	MaxHealthyLedgerLatency                     time.Duration
 	NetworkPassphrase                           string
 	PreflightWorkerCount                        uint

cmd/soroban-rpc/internal/config/options.go

@@ -247,6 +247,28 @@ func (cfg *Config) options() ConfigOptions {
 				return nil
 			},
 		},
+		{
+			Name:         "max-transactions-limit",
+			Usage:        "Maximum amount of transactions allowed in a single getTransactions response",
+			ConfigKey:    &cfg.MaxTransactionsLimit,
+			DefaultValue: uint(10000),
+		},
+		{
+			Name:         "default-transactions-limit",
+			Usage:        "Default cap on the amount of transactions included in a single getTransactions response",
+			ConfigKey:    &cfg.DefaultTransactionsLimit,
+			DefaultValue: uint(100),
+			Validate: func(co *ConfigOption) error {
+				if cfg.DefaultTransactionsLimit > cfg.MaxTransactionsLimit {
+					return fmt.Errorf(
+						"default-transactions-limit (%v) cannot exceed max-transactions-limit (%v)",
+						cfg.DefaultTransactionsLimit,
+						cfg.MaxTransactionsLimit,
+					)
+				}
+				return nil
+			},
+		},
 		{
 			Name: "max-healthy-ledger-latency",
 			Usage: "maximum ledger latency (i.e. time elapsed since the last known ledger closing time) considered to be healthy" +

cmd/soroban-rpc/internal/daemon/interfaces/interfaces.go

@@ -20,3 +20,11 @@ type CoreClient interface {
 	Info(ctx context.Context) (*proto.InfoResponse, error)
 	SubmitTransaction(context.Context, string) (*proto.TXResponse, error)
 }
+
+type Cursor interface {
+	String() string
+	MarshalJSON() ([]byte, error)
+	UnmarshalJSON(b []byte) error
+	Cmp(other Cursor) int
+	ParseCursor(input string) (Cursor, error)
+}

cmd/soroban-rpc/internal/events/cursor.go

@@ -8,6 +8,8 @@ import (
 	"strings"
 
 	"github.com/stellar/go/toid"
+
+	"github.com/stellar/soroban-rpc/cmd/soroban-rpc/internal/daemon/interfaces"
 )
 
 // Cursor represents the position of a Soroban event.
@@ -37,7 +39,7 @@ func (c Cursor) String() string {
 }
 
 // MarshalJSON marshals the cursor into JSON
-func (c Cursor) MarshalJSON() ([]byte, error) {
+func (c *Cursor) MarshalJSON() ([]byte, error) {
 	return json.Marshal(c.String())
 }
 
@@ -48,35 +50,40 @@ func (c *Cursor) UnmarshalJSON(b []byte) error {
 		return err
 	}
 
-	if parsed, err := ParseCursor(s); err != nil {
+	parsed, err := c.ParseCursor(s)
+	if err != nil {
 		return err
+	}
+
+	if eventCursor, ok := parsed.(*Cursor); ok {
+		*c = *eventCursor
 	} else {
-		*c = parsed
+		return fmt.Errorf("parsed cursor could not be converted to Event cursor")
 	}
 	return nil
 }
 
 // ParseCursor parses the given string and returns the corresponding cursor
-func ParseCursor(input string) (Cursor, error) {
+func (c *Cursor) ParseCursor(input string) (interfaces.Cursor, error) {
 	parts := strings.SplitN(input, "-", 2)
 	if len(parts) != 2 {
-		return Cursor{}, fmt.Errorf("invalid event id %s", input)
+		return &Cursor{}, fmt.Errorf("invalid event id %s", input)
 	}
 
 	// Parse the first part (toid)
 	idInt, err := strconv.ParseInt(parts[0], 10, 64) //lint:ignore gomnd
 	if err != nil {
-		return Cursor{}, fmt.Errorf("invalid event id %s: %w", input, err)
+		return &Cursor{}, fmt.Errorf("invalid event id %s: %w", input, err)
 	}
 	parsed := toid.Parse(idInt)
 
 	// Parse the second part (event order)
 	eventOrder, err := strconv.ParseUint(parts[1], 10, 32) //lint:ignore gomnd
 	if err != nil {
-		return Cursor{}, fmt.Errorf("invalid event id %s: %w", input, err)
+		return &Cursor{}, fmt.Errorf("invalid event id %s: %w", input, err)
 	}
 
-	return Cursor{
+	return &Cursor{
 		Ledger: uint32(parsed.LedgerSequence),
 		Tx:     uint32(parsed.TransactionOrder),
 		Op:     uint32(parsed.OperationOrder),
@@ -98,17 +105,19 @@ func cmp(a, b uint32) int {
 // 0 is returned if the c is equal to other.
 // 1 is returned if c is greater than other.
 // -1 is returned if c is less than other.
-func (c Cursor) Cmp(other Cursor) int {
-	if c.Ledger == other.Ledger {
-		if c.Tx == other.Tx {
-			if c.Op == other.Op {
-				return cmp(c.Event, other.Event)
+func (c Cursor) Cmp(other interfaces.Cursor) int {
+	otherCursor := other.(*Cursor)
+
+	if c.Ledger == otherCursor.Ledger {
+		if c.Tx == otherCursor.Tx {
+			if c.Op == otherCursor.Op {
+				return cmp(c.Event, otherCursor.Event)
 			}
-			return cmp(c.Op, other.Op)
+			return cmp(c.Op, otherCursor.Op)
 		}
-		return cmp(c.Tx, other.Tx)
+		return cmp(c.Tx, otherCursor.Tx)
 	}
-	return cmp(c.Ledger, other.Ledger)
+	return cmp(c.Ledger, otherCursor.Ledger)
 }
 
 var (

cmd/soroban-rpc/internal/events/cursor_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestParseCursor(t *testing.T) {
-	for _, cursor := range []Cursor{
+	for _, cursor := range []*Cursor{
 		{
 			Ledger: math.MaxInt32,
 			Tx:     1048575,
@@ -29,7 +29,7 @@ func TestParseCursor(t *testing.T) {
 			Event:  1,
 		},
 	} {
-		parsed, err := ParseCursor(cursor.String())
+		parsed, err := cursor.ParseCursor(cursor.String())
 		assert.NoError(t, err)
 		assert.Equal(t, cursor, parsed)
 	}
@@ -97,12 +97,12 @@ func TestCursorCmp(t *testing.T) {
 		b := testCase.b
 		expected := testCase.expected
 
-		if got := a.Cmp(b); got != expected {
+		if got := a.Cmp(&b); got != expected {
 			t.Fatalf("expected (%v).Cmp(%v) to be %v but got %v", a, b, expected, got)
 		}
 		a, b = b, a
 		expected *= -1
-		if got := a.Cmp(b); got != expected {
+		if got := a.Cmp(&b); got != expected {
 			t.Fatalf("expected (%v).Cmp(%v) to be %v but got %v", a, b, expected, got)
 		}
 	}

cmd/soroban-rpc/internal/events/events.go

@@ -128,7 +128,7 @@ func (m *MemoryStore) Scan(eventRange Range, f ScanFunction) (lastLedgerInWindow
 		timestamp := bucket.LedgerCloseTimestamp
 		for _, event := range events {
 			cur := event.cursor(bucket.LedgerSeq)
-			if eventRange.End.Cmp(cur) <= 0 {
+			if eventRange.End.Cmp(&cur) <= 0 {
 				return
 			}
 			var diagnosticEvent xdr.DiagnosticEvent
@@ -153,26 +153,26 @@ func (m *MemoryStore) validateRange(eventRange *Range) error {
 	}
 	firstBucket := m.eventsByLedger.Get(0)
 	min := Cursor{Ledger: firstBucket.LedgerSeq}
-	if eventRange.Start.Cmp(min) < 0 {
+	if eventRange.Start.Cmp(&min) < 0 {
 		if eventRange.ClampStart {
 			eventRange.Start = min
 		} else {
 			return errors.New("start is before oldest ledger")
 		}
 	}
 	max := Cursor{Ledger: min.Ledger + m.eventsByLedger.Len()}
-	if eventRange.Start.Cmp(max) >= 0 {
+	if eventRange.Start.Cmp(&max) >= 0 {
 		return errors.New("start is after newest ledger")
 	}
-	if eventRange.End.Cmp(max) > 0 {
+	if eventRange.End.Cmp(&max) > 0 {
 		if eventRange.ClampEnd {
 			eventRange.End = max
 		} else {
 			return errors.New("end is after latest ledger")
 		}
 	}
 
-	if eventRange.Start.Cmp(eventRange.End) >= 0 {
+	if eventRange.Start.Cmp(&eventRange.End) >= 0 {
 		return errors.New("start is not before end")
 	}
 
@@ -184,7 +184,8 @@ func (m *MemoryStore) validateRange(eventRange *Range) error {
 // events must be sorted in ascending order.
 func seek(events []event, cursor Cursor) []event {
 	j := sort.Search(len(events), func(i int) bool {
-		return cursor.Cmp(events[i].cursor(cursor.Ledger)) <= 0
+		cur := events[i].cursor(cursor.Ledger)
+		return cursor.Cmp(&cur) <= 0
 	})
 	return events[j:]
 }

cmd/soroban-rpc/internal/jsonrpc.go

@@ -199,6 +199,13 @@ func NewJSONRPCHandler(cfg *config.Config, params HandlerParams) Handler {
 			queueLimit:           cfg.RequestBacklogGetTransactionQueueLimit,
 			requestDurationLimit: cfg.MaxGetTransactionExecutionDuration,
 		},
+		{
+			methodName:           "getTransactions",
+			underlyingHandler:    methods.NewGetTransactionsHandler(params.Logger, params.LedgerReader, params.LedgerEntryReader, cfg.MaxTransactionsLimit, cfg.DefaultTransactionsLimit, cfg.NetworkPassphrase),
+			longName:             "get_transactions",
+			queueLimit:           cfg.RequestBacklogSendTransactionQueueLimit,
+			requestDurationLimit: cfg.MaxSendTransactionExecutionDuration,
+		},
 		{
 			methodName:           "sendTransaction",
 			underlyingHandler:    methods.NewSendTransactionHandler(params.Daemon, params.Logger, params.TransactionStore, cfg.NetworkPassphrase),

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

@@ -79,9 +79,9 @@ type EventInfo struct {
 }
 
 type GetEventsRequest struct {
-	StartLedger uint32             `json:"startLedger,omitempty"`
-	Filters     []EventFilter      `json:"filters"`
-	Pagination  *PaginationOptions `json:"pagination,omitempty"`
+	StartLedger uint32                   `json:"startLedger,omitempty"`
+	Filters     []EventFilter            `json:"filters"`
+	Pagination  *EventsPaginationOptions `json:"pagination,omitempty"`
 }
 
 func (g *GetEventsRequest) Valid(maxLimit uint) error {
@@ -288,7 +288,7 @@ func (s *SegmentFilter) UnmarshalJSON(p []byte) error {
 	return nil
 }
 
-type PaginationOptions struct {
+type EventsPaginationOptions struct {
 	Cursor *events.Cursor `json:"cursor,omitempty"`
 	Limit  uint           `json:"limit,omitempty"`
 }

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

@@ -410,7 +410,7 @@ func TestGetEventsRequestValid(t *testing.T) {
 	assert.EqualError(t, (&GetEventsRequest{
 		StartLedger: 1,
 		Filters:     []EventFilter{},
-		Pagination:  &PaginationOptions{Cursor: &events.Cursor{}},
+		Pagination:  &EventsPaginationOptions{Cursor: &events.Cursor{}},
 	}).Valid(1000), "startLedger and cursor cannot both be set")
 
 	assert.NoError(t, (&GetEventsRequest{
@@ -422,7 +422,7 @@ func TestGetEventsRequestValid(t *testing.T) {
 	assert.EqualError(t, (&GetEventsRequest{
 		StartLedger: 1,
 		Filters:     []EventFilter{},
-		Pagination:  &PaginationOptions{Limit: 1001},
+		Pagination:  &EventsPaginationOptions{Limit: 1001},
 	}).Valid(1000), "limit must not exceed 1000")
 
 	assert.EqualError(t, (&GetEventsRequest{
@@ -932,7 +932,7 @@ func TestGetEvents(t *testing.T) {
 		results, err := handler.getEvents(GetEventsRequest{
 			StartLedger: 1,
 			Filters:     []EventFilter{},
-			Pagination:  &PaginationOptions{Limit: 10},
+			Pagination:  &EventsPaginationOptions{Limit: 10},
 		})
 		assert.NoError(t, err)
 
@@ -1016,7 +1016,7 @@ func TestGetEvents(t *testing.T) {
 			defaultLimit: 100,
 		}
 		results, err := handler.getEvents(GetEventsRequest{
-			Pagination: &PaginationOptions{
+			Pagination: &EventsPaginationOptions{
 				Cursor: id,
 				Limit:  2,
 			},
@@ -1048,7 +1048,7 @@ func TestGetEvents(t *testing.T) {
 		assert.Equal(t, GetEventsResponse{expected, 5}, results)
 
 		results, err = handler.getEvents(GetEventsRequest{
-			Pagination: &PaginationOptions{
+			Pagination: &EventsPaginationOptions{
 				Cursor: &events.Cursor{Ledger: 5, Tx: 2, Op: 0, Event: 1},
 				Limit:  2,
 			},