feat: trace single preconfirmed transaction (#3002)

trace-single

Author: EgeCaner

core/pending.go

@@ -18,6 +18,7 @@ type PendingData interface {
 	GetStateUpdate() *StateUpdate
 	GetNewClasses() map[felt.Felt]Class
 	GetCandidateTransaction() []Transaction
+	GetTransactionStateDiffs() []*StateDiff
 	Variant() PendingDataVariant
 }
 
@@ -64,6 +65,10 @@ func (p *PreConfirmed) GetCandidateTransaction() []Transaction {
 	return p.CandidateTxs
 }
 
+func (p *PreConfirmed) GetTransactionStateDiffs() []*StateDiff {
+	return p.TransactionStateDiffs
+}
+
 func (p *PreConfirmed) Variant() PendingDataVariant {
 	return PreConfirmedBlockVariant
 }

mocks/mock_synchronizer.go

@@ -400,6 +400,9 @@ func (fs *fakeSyncer) PendingData() (core.PendingData, error) {
 }
 func (fs *fakeSyncer) PendingBlock() *core.Block                             { return nil }
 func (fs *fakeSyncer) PendingState() (core.StateReader, func() error, error) { return nil, nil, nil }
+func (fs *fakeSyncer) PendingStateBeforeIndex(index int) (core.StateReader, func() error, error) {
+	return nil, nil, nil
+}
 
 func TestSubscribeNewHeads(t *testing.T) {
 	log := utils.NewNopZapLogger()

rpc/v8/subscriptions_test.go

@@ -452,6 +452,9 @@ func (fs *fakeSyncer) PendingData() (core.PendingData, error) {
 }
 func (fs *fakeSyncer) PendingBlock() *core.Block                             { return nil }
 func (fs *fakeSyncer) PendingState() (core.StateReader, func() error, error) { return nil, nil, nil }
+func (fs *fakeSyncer) PendingStateBeforeIndex(index int) (core.StateReader, func() error, error) {
+	return nil, nil, nil
+}
 
 func TestSubscribeNewHeads(t *testing.T) {
 	log := utils.NewNopZapLogger()

rpc/v9/subscriptions_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"net/http"
 	"slices"
 	"strconv"
@@ -72,46 +73,130 @@ type FunctionInvocation struct {
 //
 // It follows the specification defined here:
 // https://github.com/starkware-libs/starknet-specs/blob/9377851884da5c81f757b6ae0ed47e84f9e7c058/api/starknet_trace_api_openrpc.json#L11
-func (h *Handler) TraceTransaction(ctx context.Context, hash felt.Felt) (*TransactionTrace, http.Header, *jsonrpc.Error) {
+func (h *Handler) TraceTransaction(ctx context.Context, hash felt.Felt) (TransactionTrace, http.Header, *jsonrpc.Error) {
 	_, blockHash, _, err := h.bcReader.Receipt(&hash)
 	httpHeader := http.Header{}
 	httpHeader.Set(ExecutionStepsHeader, "0")
 
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
-		return nil, httpHeader, rpccore.ErrTxnHashNotFound
+		return TransactionTrace{}, httpHeader, rpccore.ErrTxnHashNotFound
 	}
 
-	var block *core.Block
-	isPendingBlock := blockHash == nil
-	if isPendingBlock {
-		var pending core.PendingData
-		pending, err = h.PendingData()
+	isPreConfirmed := blockHash == nil
+	if !isPreConfirmed {
+		block, err := h.bcReader.BlockByHash(blockHash)
 		if err != nil {
 			// for traceTransaction handlers there is no block not found error
-			return nil, httpHeader, rpccore.ErrTxnHashNotFound
+			return TransactionTrace{}, httpHeader, rpccore.ErrTxnHashNotFound
 		}
-		block = pending.GetBlock()
-	} else {
-		block, err = h.bcReader.BlockByHash(blockHash)
-		if err != nil {
-			// for traceTransaction handlers there is no block not found error
-			return nil, httpHeader, rpccore.ErrTxnHashNotFound
+
+		txIndex := slices.IndexFunc(block.Transactions, func(tx core.Transaction) bool {
+			return tx.Hash().Equal(&hash)
+		})
+
+		if txIndex == -1 {
+			return TransactionTrace{}, httpHeader, rpccore.ErrTxnHashNotFound
+		}
+
+		blockTraces, httphttpHeader, rpcErr := h.traceBlockTransactions(ctx, block)
+		if rpcErr != nil {
+			return TransactionTrace{}, httphttpHeader, rpcErr
 		}
+		return *blockTraces[txIndex].TraceRoot, httphttpHeader, nil
+	}
+
+	var pendingData core.PendingData
+	pendingData, err = h.PendingData()
+	if err != nil {
+		// for traceTransaction handlers there is no block not found error
+		return TransactionTrace{}, httpHeader, rpccore.ErrTxnHashNotFound
 	}
+	block := pendingData.GetBlock()
 
 	txIndex := slices.IndexFunc(block.Transactions, func(tx core.Transaction) bool {
 		return tx.Hash().Equal(&hash)
 	})
 	if txIndex == -1 {
-		return nil, httpHeader, rpccore.ErrTxnHashNotFound
+		return TransactionTrace{}, httpHeader, rpccore.ErrTxnHashNotFound
+	}
+
+	switch v := pendingData.Variant(); v {
+	case core.PendingBlockVariant:
+		blockTraces, httphttpHeader, rpcErr := h.traceBlockTransactions(ctx, block)
+		if rpcErr != nil {
+			return TransactionTrace{}, httphttpHeader, rpcErr
+		}
+		return *blockTraces[txIndex].TraceRoot, httphttpHeader, nil
+	case core.PreConfirmedBlockVariant:
+		return h.tracePreConfirmedTransaction(block, txIndex)
+	default:
+		panic(fmt.Errorf("unknown pending data variant: %v", v))
+	}
+}
+
+func (h *Handler) tracePreConfirmedTransaction(block *core.Block, txIndex int) (TransactionTrace, http.Header, *jsonrpc.Error) {
+	httpHeader := http.Header{}
+	httpHeader.Set(ExecutionStepsHeader, "0")
+	state, stateCloser, err := h.syncReader.PendingStateBeforeIndex(txIndex)
+	if err != nil {
+		return TransactionTrace{}, httpHeader, jsonrpc.Err(jsonrpc.InternalError, err.Error())
 	}
+	defer h.callAndLogErr(stateCloser, "Failed to close head state in TraceTransaction")
+
+	var classes []core.Class
+	paidFeesOnL1 := []*felt.Felt{}
+
+	transaction := block.Transactions[txIndex]
+	switch tx := transaction.(type) {
+	/// TODO(Ege): decide what to do with this, should be an edge case
+	case *core.DeclareTransaction:
+		class, stateErr := state.Class(tx.ClassHash)
+		if stateErr != nil {
+			return TransactionTrace{}, httpHeader, jsonrpc.Err(jsonrpc.InternalError, stateErr.Error())
+		}
+		classes = append(classes, class.Class)
+	case *core.L1HandlerTransaction:
+		var fee felt.Felt
+		paidFeesOnL1 = append(paidFeesOnL1, fee.SetUint64(1))
+	}
+
+	blockHashToBeRevealed, err := h.getRevealedBlockHash(block.Number)
+	if err != nil {
+		return TransactionTrace{}, httpHeader, rpccore.ErrInternal.CloneWithData(err)
+	}
+	network := h.bcReader.Network()
+	header := block.Header
+	blockInfo := vm.BlockInfo{
+		Header:                header,
+		BlockHashToBeRevealed: blockHashToBeRevealed,
+	}
+
+	executionResult, err := h.vm.Execute([]core.Transaction{transaction}, classes, paidFeesOnL1,
+		&blockInfo, state, network, false, false, false, true, false)
+
+	httpHeader.Set(ExecutionStepsHeader, strconv.FormatUint(executionResult.NumSteps, 10))
+
+	if err != nil {
+		if errors.Is(err, utils.ErrResourceBusy) {
+			return TransactionTrace{}, httpHeader, rpccore.ErrInternal.CloneWithData(rpccore.ThrottledVMErr)
+		}
+		// Since we are tracing an existing block, we know that there should be no errors during execution. If we encounter any,
+		// report them as unexpected errors
+		return TransactionTrace{}, httpHeader, rpccore.ErrUnexpectedError.CloneWithData(err.Error())
+	}
+
+	// Adapt vm transaction trace to rpc v9 trace and add root level execution resources
+	trace := AdaptVMTransactionTrace(&executionResult.Traces[0])
 
-	traceResults, header, traceBlockErr := h.traceBlockTransactions(ctx, block)
-	if traceBlockErr != nil {
-		return nil, header, traceBlockErr
+	trace.ExecutionResources = &ExecutionResources{
+		InnerExecutionResources: InnerExecutionResources{
+			L1Gas: executionResult.GasConsumed[0].L1Gas,
+			L2Gas: executionResult.GasConsumed[0].L2Gas,
+		},
+		L1DataGas: executionResult.GasConsumed[0].L1DataGas,
 	}
 
-	return traceResults[txIndex].TraceRoot, header, nil
+	return trace, httpHeader, nil
 }
 
 // TraceBlockTransactions returns the trace for a given blockID

rpc/v9/trace.go

@@ -214,6 +214,10 @@ func (s *Sequencer) PendingState() (core.StateReader, func() error, error) {
 	return s.builder.PendingState(s.buildState)
 }
 
+func (s *Sequencer) PendingStateBeforeIndex(index int) (core.StateReader, func() error, error) {
+	return nil, nil, errors.ErrUnsupported
+}
+
 func (s *Sequencer) HighestBlockHeader() *core.Header {
 	return nil // Not relevant for Sequencer. Todo: clean Reader
 }

rpc/v9/trace_test.go

@@ -50,6 +50,10 @@ func (p *Pending) GetCandidateTransaction() []core.Transaction {
 	return []core.Transaction{}
 }
 
+func (p *Pending) GetTransactionStateDiffs() []*core.StateDiff {
+	return []*core.StateDiff{}
+}
+
 func (p *Pending) Variant() core.PendingDataVariant {
 	return core.PendingBlockVariant
 }

sequencer/sequencer.go

@@ -77,6 +77,7 @@ type Reader interface {
 	PendingData() (core.PendingData, error)
 	PendingBlock() *core.Block
 	PendingState() (core.StateReader, func() error, error)
+	PendingStateBeforeIndex(index int) (core.StateReader, func() error, error)
 }
 
 // This is temporary and will be removed once the p2p synchronizer implements this interface.
@@ -114,6 +115,10 @@ func (n *NoopSynchronizer) PendingState() (core.StateReader, func() error, error
 	return nil, nil, errors.New("PendingState() not implemented")
 }
 
+func (n *NoopSynchronizer) PendingStateBeforeIndex(index int) (core.StateReader, func() error, error) {
+	return nil, nil, errors.New("PendingStateBeforeIndex() not implemented")
+}
+
 // Synchronizer manages a list of StarknetData to fetch the latest blockchain updates
 type Synchronizer struct {
 	blockchain          *blockchain.Blockchain
@@ -703,7 +708,6 @@ func (s *Synchronizer) PendingData() (core.PendingData, error) {
 	p := *ptr
 	switch p.Variant() {
 	case core.PreConfirmedBlockVariant:
-		// pre_confirmed
 		expectedOldRoot := &felt.Zero
 		expectedBlockNumber := uint64(0)
 		if head, err := s.blockchain.HeadsHeader(); err == nil {
@@ -751,6 +755,30 @@ func (s *Synchronizer) PendingState() (core.StateReader, func() error, error) {
 	return NewPendingState(pending.GetStateUpdate().StateDiff, pending.GetNewClasses(), core.NewState(txn)), noop, nil
 }
 
+// PendingStateAfterIndex returns the state obtained by applying all transaction state diffs
+// up to given index in the pre-confirmed block.
+func (s *Synchronizer) PendingStateBeforeIndex(index int) (core.StateReader, func() error, error) {
+	txn := s.db.NewIndexedBatch()
+
+	pending, err := s.PendingData()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if pending.Variant() != core.PreConfirmedBlockVariant {
+		return nil, nil, errors.New("only supported for pre_confirmed block")
+	}
+
+	stateDiff := core.EmptyStateDiff()
+	// Transaction state diffs size must always match Transactions
+	txStateDiffs := pending.GetTransactionStateDiffs()
+	for _, txStateDiff := range txStateDiffs[:index] {
+		stateDiff.Merge(txStateDiff)
+	}
+
+	return NewPendingState(&stateDiff, pending.GetNewClasses(), core.NewState(txn)), noop, nil
+}
+
 func (s *Synchronizer) storeEmptyPendingData(lastHeader *core.Header) {
 	blockVer, err := core.ParseBlockVersion(lastHeader.ProtocolVersion)
 	if err == nil {

sync/pending.go

@@ -340,6 +340,57 @@ func TestPendingData(t *testing.T) {
 				require.NoError(t, pendingStateCloser())
 			})
 		})
+
+		t.Run("get pending state before index", func(t *testing.T) {
+			var synchronizer *sync.Synchronizer
+			testDB := memory.New()
+			chain := blockchain.New(testDB, &utils.Mainnet)
+			dataSource := sync.NewFeederGatewayDataSource(chain, gw)
+			synchronizer = sync.New(chain, dataSource, utils.NewNopZapLogger(), 0, 0, false, testDB)
+
+			require.NoError(t, err)
+			client := feeder.NewTestClient(t, &utils.SepoliaIntegration)
+			gw := adaptfeeder.New(client)
+			preConfirmed, err := gw.PreConfirmedBlockByNumber(t.Context(), 1204672)
+			preConfirmed.StateUpdate.OldRoot = &felt.Zero
+			preConfirmed.Block.Number = 0
+			require.NoError(t, err)
+			require.NoError(t, synchronizer.StorePreConfirmed(&preConfirmed))
+			txCount := len(preConfirmed.GetTransactions())
+
+			pendingState, pendingStateCloser, pErr := synchronizer.PendingStateBeforeIndex(txCount - 1)
+			require.NoError(t, pErr)
+
+			// Check storage value in two different index
+			// See clients/feeder/testdata/sepolia-integration/pre_confirmed/1204672.json
+			contractAddress, err := new(felt.Felt).SetString("0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d")
+			require.NoError(t, err)
+			key, err := new(felt.Felt).SetString("0x5496768776e3db30053404f18067d81a6e06f5a2b0de326e21298fd9d569a9a")
+			require.NoError(t, err)
+			val, err := pendingState.ContractStorage(contractAddress, key)
+			require.NoError(t, err)
+			expectedVal, err := new(felt.Felt).SetString("0x1d057bfbd3cadebffd74")
+			require.NoError(t, err)
+			require.Equal(t, expectedVal, val)
+			t.Cleanup(func() {
+				require.NoError(t, pendingStateCloser())
+			})
+
+			pendingState, pendingStateCloser, pErr = synchronizer.PendingStateBeforeIndex(txCount)
+			require.NoError(t, pErr)
+			contractAddress, err = new(felt.Felt).SetString("0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d")
+			require.NoError(t, err)
+			key, err = new(felt.Felt).SetString("0x5496768776e3db30053404f18067d81a6e06f5a2b0de326e21298fd9d569a9a")
+			require.NoError(t, err)
+			val, err = pendingState.ContractStorage(contractAddress, key)
+			require.NoError(t, err)
+			expectedVal, err = new(felt.Felt).SetString("0x1d057bfbd3df63f5dd54")
+			require.NoError(t, err)
+			require.Equal(t, expectedVal, val)
+			t.Cleanup(func() {
+				require.NoError(t, pendingStateCloser())
+			})
+		})
 	})
 }