Add defensive coding and matching unit tests for fee bumps (#605)

Author: Shaptic

cmd/stellar-rpc/internal/methods/simulate_transaction.go

@@ -249,6 +249,34 @@ func formatResponse(preflight preflight.Preflight,
 	return simResp, nil
 }
 
+func sorobanDataFromEnvelope(txEnvelope xdr.TransactionEnvelope) (*xdr.SorobanTransactionData, bool) {
+	switch txEnvelope.Type {
+	case xdr.EnvelopeTypeEnvelopeTypeTx:
+		if txEnvelope.V1 == nil {
+			return nil, false
+		}
+		return sorobanDataFromTx(txEnvelope.V1.Tx)
+	case xdr.EnvelopeTypeEnvelopeTypeTxFeeBump:
+		if txEnvelope.FeeBump == nil {
+			return nil, false
+		}
+		inner := txEnvelope.FeeBump.Tx.InnerTx
+		if inner.Type != xdr.EnvelopeTypeEnvelopeTypeTx || inner.V1 == nil {
+			return nil, false
+		}
+		return sorobanDataFromTx(inner.V1.Tx)
+	default:
+		return nil, false
+	}
+}
+
+func sorobanDataFromTx(tx xdr.Transaction) (*xdr.SorobanTransactionData, bool) {
+	if tx.Ext.V != 1 || tx.Ext.SorobanData == nil {
+		return nil, false
+	}
+	return tx.Ext.SorobanData, true
+}
+
 // NewSimulateTransactionHandler returns a JSON rpc handler to run preflight simulations
 //
 //nolint:cyclop
@@ -297,13 +325,14 @@ func NewSimulateTransactionHandler(logger *log.Entry,
 		switch op.Body.Type {
 		case xdr.OperationTypeInvokeHostFunction: // no-op
 		case xdr.OperationTypeExtendFootprintTtl, xdr.OperationTypeRestoreFootprint:
-			if txEnvelope.Type != xdr.EnvelopeTypeEnvelopeTypeTx && txEnvelope.V1.Tx.Ext.V != 1 {
+			sorobanData, ok := sorobanDataFromEnvelope(txEnvelope)
+			if !ok {
 				return protocol.SimulateTransactionResponse{
 					Error: "To perform a SimulateTransaction for ExtendFootprintTtl or RestoreFootprint operations," +
 						" SorobanTransactionData must be provided",
 				}
 			}
-			footprint = txEnvelope.V1.Tx.Ext.SorobanData.Resources.Footprint
+			footprint = sorobanData.Resources.Footprint
 
 		default:
 			return protocol.SimulateTransactionResponse{

cmd/stellar-rpc/internal/methods/simulate_transaction_test.go

@@ -1,13 +1,17 @@
 package methods
 
 import (
+	"context"
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"testing"
 
+	"github.com/creachadair/jrpc2"
 	"github.com/stretchr/testify/require"
 
 	protocol "github.com/stellar/go-stellar-sdk/protocols/rpc"
+	"github.com/stellar/go-stellar-sdk/support/log"
 	"github.com/stellar/go-stellar-sdk/xdr"
 
 	"github.com/stellar/stellar-rpc/cmd/stellar-rpc/internal/preflight"
@@ -142,3 +146,90 @@ func TestLedgerEntryChange(t *testing.T) {
 	require.ErrorIs(t, err, errMissingDiff)
 	require.Equal(t, protocol.LedgerEntryChange{}, change)
 }
+
+type panicPreflightGetter struct{}
+
+func (panicPreflightGetter) GetPreflight(
+	context.Context,
+	preflight.GetterParameters,
+) (preflight.Preflight, error) {
+	panic("unexpected GetPreflight call")
+}
+
+func TestSimulateTransactionFeeBumpMissingSorobanData(t *testing.T) {
+	logger := log.New()
+	ledgerReader := &MockLedgerReader{}
+	handler := NewSimulateTransactionHandler(logger, ledgerReader, nil, panicPreflightGetter{})
+
+	txEnvelope := feeBumpExtendFootprintMissingSorobanData(t)
+	txB64, err := xdr.MarshalBase64(txEnvelope)
+	require.NoError(t, err)
+
+	requestJSON := fmt.Sprintf(`{
+"jsonrpc": "2.0",
+"id": 1,
+"method": "simulateTransaction",
+"params": { "transaction": "%s" }
+}`, txB64)
+	requests, err := jrpc2.ParseRequests([]byte(requestJSON))
+	require.NoError(t, err)
+	require.Len(t, requests, 1)
+
+	resp, err := handler(t.Context(), requests[0].ToRequest())
+	require.NoError(t, err)
+
+	simResp, ok := resp.(protocol.SimulateTransactionResponse)
+	require.True(t, ok)
+	require.Equal(t,
+		"To perform a SimulateTransaction for ExtendFootprintTtl or RestoreFootprint operations,"+
+			" SorobanTransactionData must be provided",
+		simResp.Error,
+	)
+}
+
+func feeBumpExtendFootprintMissingSorobanData(t *testing.T) xdr.TransactionEnvelope {
+	t.Helper()
+
+	sourceAccountID := xdr.MustAddress("GBXGQJWVLWOYHFLVTKWV5FGHA3LNYY2JQKM7OAJAUEQFU6LPCSEFVXON")
+	source := (&sourceAccountID).ToMuxedAccount()
+	feeSourceAccountID := xdr.MustAddress("GBXGQJWVLWOYHFLVTKWV5FGHA3LNYY2JQKM7OAJAUEQFU6LPCSEFVXON")
+	feeSource := (&feeSourceAccountID).ToMuxedAccount()
+
+	op := xdr.Operation{
+		Body: xdr.OperationBody{
+			Type: xdr.OperationTypeExtendFootprintTtl,
+			ExtendFootprintTtlOp: &xdr.ExtendFootprintTtlOp{
+				Ext:      xdr.ExtensionPoint{V: 0},
+				ExtendTo: xdr.Uint32(100),
+			},
+		},
+	}
+
+	tx := xdr.Transaction{
+		SourceAccount: source,
+		Fee:           xdr.Uint32(100),
+		SeqNum:        xdr.SequenceNumber(1),
+		Cond:          xdr.Preconditions{Type: xdr.PreconditionTypePrecondNone},
+		Memo:          xdr.Memo{Type: xdr.MemoTypeMemoNone},
+		Operations:    []xdr.Operation{op},
+		Ext:           xdr.TransactionExt{V: 0},
+	}
+
+	innerV1 := xdr.TransactionV1Envelope{Tx: tx}
+	innerTx := xdr.FeeBumpTransactionInnerTx{
+		Type: xdr.EnvelopeTypeEnvelopeTypeTx,
+		V1:   &innerV1,
+	}
+	feeBumpTx := xdr.FeeBumpTransaction{
+		FeeSource: feeSource,
+		Fee:       xdr.Int64(1000),
+		InnerTx:   innerTx,
+		Ext:       xdr.FeeBumpTransactionExt{V: 0},
+	}
+	feeBumpEnvelope := xdr.FeeBumpTransactionEnvelope{Tx: feeBumpTx}
+
+	return xdr.TransactionEnvelope{
+		Type:    xdr.EnvelopeTypeEnvelopeTypeTxFeeBump,
+		FeeBump: &feeBumpEnvelope,
+	}
+}