Fix ledger range calculation

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

@@ -19,6 +19,7 @@ import (
 	"github.com/stellar/go/xdr"
 
 	"github.com/stellar/soroban-rpc/cmd/soroban-rpc/internal/daemon/interfaces"
+	"github.com/stellar/soroban-rpc/cmd/soroban-rpc/internal/ledgerbucketwindow"
 )
 
 //go:embed sqlmigrations/*.sql
@@ -31,6 +32,10 @@ const (
 	latestLedgerSequenceMetaKey = "LatestLedgerSequence"
 )
 
+type LedgerRangeReader interface {
+	GetLedgerRange(ctx context.Context) (ledgerbucketwindow.LedgerRange, error)
+}
+
 type ReadWriter interface {
 	NewTx(ctx context.Context) (WriteTx, error)
 	GetLatestLedgerSequence(ctx context.Context) (uint32, error)

cmd/soroban-rpc/internal/db/transaction.go

@@ -42,7 +42,7 @@ type TransactionWriter interface {
 // TransactionReader provides all the public ways to read from the DB.
 type TransactionReader interface {
 	GetTransaction(ctx context.Context, hash xdr.Hash) (Transaction, ledgerbucketwindow.LedgerRange, error)
-	GetLedgerRange(ctx context.Context) (ledgerbucketwindow.LedgerRange, error)
+	LedgerRangeReader
 }
 
 type transactionHandler struct {
@@ -133,7 +133,7 @@ func (txn *transactionHandler) trimTransactions(latestLedgerSeq uint32, retentio
 	return err
 }
 
-// GetLedgerRange pulls the min/max ledger sequence numbers from the database.
+// GetLedgerRange pulls the min/max ledger sequence numbers from the transactions table.
 func (txn *transactionHandler) GetLedgerRange(ctx context.Context) (ledgerbucketwindow.LedgerRange, error) {
 	var ledgerRange ledgerbucketwindow.LedgerRange
 
@@ -142,32 +142,45 @@ func (txn *transactionHandler) GetLedgerRange(ctx context.Context) (ledgerbucket
 	// and max from the ledger table in a single query and get around sqlite's
 	// limitations with parentheses (see https://stackoverflow.com/a/22609948).
 	//
-	newestQ := sq.
-		Select("m1.meta").
+	// Queries to get the minimum and maximum ledger sequence from the transactions table
+	minLedgerSeqQ := sq.
+		Select("m1.ledger_sequence").
 		FromSelect(
 			sq.
-				Select("meta").
-				From(ledgerCloseMetaTableName).
-				OrderBy("sequence ASC").
+				Select("ledger_sequence").
+				From(transactionTableName).
+				OrderBy("ledger_sequence ASC").
 				Limit(1),
 			"m1",
 		)
-	sql, args, err := sq.
-		Select("m2.meta").
+	maxLedgerSeqQ, args, err := sq.
+		Select("m2.ledger_sequence").
 		FromSelect(
 			sq.
-				Select("meta").
-				From(ledgerCloseMetaTableName).
-				OrderBy("sequence DESC").
+				Select("ledger_sequence").
+				From(transactionTableName).
+				OrderBy("ledger_sequence DESC").
 				Limit(1),
 			"m2",
 		).ToSql()
 	if err != nil {
-		return ledgerRange, errors.Wrap(err, "couldn't build ledger range query")
+		return ledgerRange, errors.Wrap(err, "couldn't build max ledger sequence query")
 	}
 
+	// Combine the min and max ledger sequence queries using UNION ALL
+	txnMinMaxLedgersQ, _, err := minLedgerSeqQ.Suffix("UNION ALL "+maxLedgerSeqQ, args...).ToSql()
+	if err != nil {
+		return ledgerRange, errors.Wrap(err, "couldn't build max ledger sequence query")
+	}
+
+	// Final query to join ledger_close_meta table and the sequence numbers we got from txnMinMaxLedgersQ
+	finalSql := sq.
+		Select("lcm.meta").
+		From(fmt.Sprintf("%s as lcm", ledgerCloseMetaTableName)).
+		JoinClause(fmt.Sprintf("JOIN (%s) as seqs ON lcm.sequence == seqs.ledger_sequence", txnMinMaxLedgersQ))
+
 	var lcms []xdr.LedgerCloseMeta
-	if err = txn.db.Select(ctx, &lcms, newestQ.Suffix("UNION ALL "+sql, args...)); err != nil {
+	if err = txn.db.Select(ctx, &lcms, finalSql); err != nil {
 		return ledgerRange, errors.Wrap(err, "couldn't query ledger range")
 	} else if len(lcms) < 2 {
 		// There is almost certainly a row, but we want to avoid a race condition

cmd/soroban-rpc/internal/db/transaction_test.go

@@ -19,11 +19,21 @@ import (
 
 func TestTransactionNotFound(t *testing.T) {
 	db := NewTestDB(t)
+	ctx := context.TODO()
 	log := log.DefaultLogger
 	log.SetLevel(logrus.TraceLevel)
 
 	reader := NewTransactionReader(log, db, passphrase)
-	_, _, err := reader.GetTransaction(context.TODO(), xdr.Hash{})
+
+	// Assert the ledger range
+	ledgerRange, err := reader.GetLedgerRange(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(0), ledgerRange.FirstLedger.Sequence)
+	assert.Equal(t, int64(0), ledgerRange.FirstLedger.CloseTime)
+	assert.Equal(t, uint32(0), ledgerRange.LastLedger.Sequence)
+	assert.Equal(t, int64(0), ledgerRange.LastLedger.CloseTime)
+
+	_, _, err = reader.GetTransaction(context.TODO(), xdr.Hash{})
 	require.Error(t, err, ErrNoTransaction)
 }
 
@@ -51,8 +61,16 @@ func TestTransactionFound(t *testing.T) {
 	}
 	require.NoError(t, write.Commit(lcms[len(lcms)-1].LedgerSequence()))
 
-	// check 404 case
+	// Assert the ledger range
 	reader := NewTransactionReader(log, db, passphrase)
+	ledgerRange, err := reader.GetLedgerRange(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(1334), ledgerRange.FirstLedger.Sequence)
+	assert.Equal(t, ledgerCloseTime(1334), ledgerRange.FirstLedger.CloseTime)
+	assert.Equal(t, uint32(1337), ledgerRange.LastLedger.Sequence)
+	assert.Equal(t, ledgerCloseTime(1337), ledgerRange.LastLedger.CloseTime)
+
+	// check 404 case
 	_, _, err = reader.GetTransaction(ctx, xdr.Hash{})
 	require.Error(t, err, ErrNoTransaction)
 

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

@@ -1,6 +1,7 @@
 package events
 
 import (
+	"context"
 	"errors"
 	"io"
 	"sort"
@@ -267,7 +268,7 @@ func readEvents(networkPassphrase string, ledgerCloseMeta xdr.LedgerCloseMeta) (
 }
 
 // GetLedgerRange returns the first and latest ledger available in the store.
-func (m *MemoryStore) GetLedgerRange() (ledgerbucketwindow.LedgerRange, error) {
+func (m *MemoryStore) GetLedgerRange(ctx context.Context) (ledgerbucketwindow.LedgerRange, error) {
 	m.lock.RLock()
 	defer m.lock.RUnlock()
 	return m.eventsByLedger.GetLedgerRange(), nil

cmd/soroban-rpc/internal/jsonrpc.go

@@ -136,10 +136,13 @@ func NewJSONRPCHandler(cfg *config.Config, params HandlerParams) Handler {
 		},
 	}
 
-	// While we transition from in-memory to database-oriented history storage,
-	// the on-disk (transaction) retention window will always be larger than the
-	// in-memory (events) one.
-	var retentionWindow = cfg.TransactionLedgerRetentionWindow
+	// Get the largest history window
+	var ledgerRangeGetter db.LedgerRangeReader = params.EventStore
+	var retentionWindow = cfg.EventLedgerRetentionWindow
+	if cfg.TransactionLedgerRetentionWindow > cfg.EventLedgerRetentionWindow {
+		retentionWindow = cfg.TransactionLedgerRetentionWindow
+		ledgerRangeGetter = params.TransactionReader
+	}
 
 	handlers := []struct {
 		methodName           string
@@ -151,7 +154,7 @@ func NewJSONRPCHandler(cfg *config.Config, params HandlerParams) Handler {
 		{
 			methodName: "getHealth",
 			underlyingHandler: methods.NewHealthCheck(
-				retentionWindow, params.TransactionReader, cfg.MaxHealthyLedgerLatency),
+				retentionWindow, ledgerRangeGetter, cfg.MaxHealthyLedgerLatency),
 			longName:             "get_health",
 			queueLimit:           cfg.RequestBacklogGetHealthQueueLimit,
 			requestDurationLimit: cfg.MaxGetHealthExecutionDuration,
@@ -232,7 +235,7 @@ func NewJSONRPCHandler(cfg *config.Config, params HandlerParams) Handler {
 		},
 		{
 			methodName:           "getFeeStats",
-			underlyingHandler:    methods.NewGetFeeStatsHandler(params.FeeStatWindows, params.TransactionReader, params.Logger),
+			underlyingHandler:    methods.NewGetFeeStatsHandler(params.FeeStatWindows, ledgerRangeGetter, params.Logger),
 			longName:             "get_fee_stats",
 			queueLimit:           cfg.RequestBacklogGetFeeStatsTransactionQueueLimit,
 			requestDurationLimit: cfg.MaxGetFeeStatsExecutionDuration,

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

@@ -58,9 +58,9 @@ type GetFeeStatsResult struct {
 }
 
 // NewGetFeeStatsHandler returns a handler obtaining fee statistics
-func NewGetFeeStatsHandler(windows *feewindow.FeeWindows, reader db.TransactionReader, logger *log.Entry) jrpc2.Handler {
+func NewGetFeeStatsHandler(windows *feewindow.FeeWindows, reader db.LedgerRangeReader, logger *log.Entry) jrpc2.Handler {
 	return NewHandler(func(ctx context.Context) (GetFeeStatsResult, error) {
-		ledgerInfo, err := reader.GetLedgerRange(ctx)
+		ledgerRange, err := reader.GetLedgerRange(ctx)
 		if err != nil { // still not fatal
 			logger.WithError(err).
 				Error("could not fetch ledger range")
@@ -69,7 +69,7 @@ func NewGetFeeStatsHandler(windows *feewindow.FeeWindows, reader db.TransactionR
 		result := GetFeeStatsResult{
 			SorobanInclusionFee: convertFeeDistribution(windows.SorobanInclusionFeeWindow.GetFeeDistribution()),
 			InclusionFee:        convertFeeDistribution(windows.ClassicFeeWindow.GetFeeDistribution()),
-			LatestLedger:        ledgerInfo.LastLedger.Sequence,
+			LatestLedger:        ledgerRange.LastLedger.Sequence,
 		}
 		return result, nil
 	})

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

@@ -134,7 +134,7 @@ func (h transactionsRPCHandler) getTransactionsByLedgerSequence(ctx context.Cont
 	// Iterate through each ledger and its transactions until limit or end range is reached.
 	// The latest ledger acts as the end ledger range for the request.
 	var txns []TransactionInfo
-	var cursor *toid.ID
+	cursor := toid.New(0, 0, 0)
 LedgerLoop:
 	for ledgerSeq := start.LedgerSequence; ledgerSeq <= int32(ledgerRange.LastLedger.Sequence); ledgerSeq++ {
 		// Get ledger close meta from db
@@ -167,7 +167,7 @@ LedgerLoop:
 			if ierr := reader.Seek(startTxIdx - 1); ierr != nil && ierr != io.EOF {
 				return GetTransactionsResponse{}, &jrpc2.Error{
 					Code:    jrpc2.InternalError,
-					Message: err.Error(),
+					Message: ierr.Error(),
 				}
 			}
 		}

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

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/creachadair/jrpc2"
+
 	"github.com/stellar/soroban-rpc/cmd/soroban-rpc/internal/db"
 )
 
@@ -19,7 +20,7 @@ type HealthCheckResult struct {
 // NewHealthCheck returns a health check json rpc handler
 func NewHealthCheck(
 	retentionWindow uint32,
-	reader db.TransactionReader,
+	reader db.LedgerRangeReader,
 	maxHealthyLedgerLatency time.Duration,
 ) jrpc2.Handler {
 	return NewHandler(func(ctx context.Context) (HealthCheckResult, error) {

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

@@ -136,8 +136,6 @@ func TestSendTransactionBadSequence(t *testing.T) {
 	err = client.CallResult(context.Background(), "sendTransaction", request, &result)
 	assert.NoError(t, err)
 
-	assert.NotZero(t, result.LatestLedger)
-	assert.NotZero(t, result.LatestLedgerCloseTime)
 	expectedHashHex, err := tx.HashHex(StandaloneNetworkPassphrase)
 	assert.NoError(t, err)
 	assert.Equal(t, expectedHashHex, result.Hash)
@@ -245,8 +243,6 @@ func TestSendTransactionFailedInLedger(t *testing.T) {
 		assert.NoError(t, err)
 		fmt.Printf("error: %#v\n", txResult)
 	}
-	assert.NotZero(t, result.LatestLedger)
-	assert.NotZero(t, result.LatestLedgerCloseTime)
 
 	response := getTransaction(t, client, expectedHashHex)
 	assert.Equal(t, methods.TransactionStatusFailed, response.Status)
@@ -291,8 +287,6 @@ func sendSuccessfulTransaction(t *testing.T, client *jrpc2.Client, kp *keypair.F
 		assert.NoError(t, err)
 		t.Logf("error: %#v\n", txResult)
 	}
-	assert.NotZero(t, result.LatestLedger)
-	assert.NotZero(t, result.LatestLedgerCloseTime)
 
 	response := getTransaction(t, client, expectedHashHex)
 	if !assert.Equal(t, methods.TransactionStatusSuccess, response.Status) {