feat: add tracing support for StateSyncTx

cmd/cli/main.go

@@ -5,6 +5,11 @@ import (
 
 	"github.com/ethereum/go-ethereum/internal/cli"
 	"github.com/ethereum/go-ethereum/params"
+
+	// Force-load the tracer engines to trigger registration
+	_ "github.com/ethereum/go-ethereum/eth/tracers/js"
+	_ "github.com/ethereum/go-ethereum/eth/tracers/live"
+	_ "github.com/ethereum/go-ethereum/eth/tracers/native"
 )
 
 func main() {

cmd/keeper/go.mod

@@ -50,7 +50,7 @@ require (
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	golang.org/x/crypto v0.46.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/sys v0.39.0 // indirect
+	golang.org/x/sys v0.40.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 

cmd/keeper/go.sum

@@ -167,6 +167,7 @@ golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
 golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
 golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=

consensus/bor/bor.go

@@ -1123,6 +1123,19 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header, w
 	return nil
 }
 
+// extractVMConfig retrieves the vm.Config from the chain reader, if available.
+func extractVMConfig(chain consensus.ChainHeaderReader) vm.Config {
+	if bc, ok := chain.(*core.BlockChain); ok {
+		return *bc.GetVMConfig()
+	}
+	if hc, ok := chain.(*core.HeaderChain); ok {
+		if cfg := hc.GetVMConfig(); cfg != nil {
+			return *cfg
+		}
+	}
+	return vm.Config{}
+}
+
 // Finalize implements consensus.Engine, ensuring no uncles are set, nor block
 // rewards given.
 func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header, wrappedState vm.StateDB, body *types.Body, receipts []*types.Receipt) []*types.Receipt {
@@ -1139,20 +1152,37 @@ func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header,
 		err           error
 	)
 
+	vmCfg := extractVMConfig(chain)
+
 	if IsSprintStart(headerNumber, c.config.CalculateSprint(headerNumber)) {
 		start := time.Now()
 		cx := statefull.ChainContext{Chain: chain, Bor: c}
+
+		// Start tracing StateSyncTx (if present in the block body)
+		if hooks := vmCfg.Tracer; hooks != nil && hooks.OnTxStart != nil {
+			if c.config.IsMadhugiri(header.Number) && len(body.Transactions) > 0 {
+				lastTx := body.Transactions[len(body.Transactions)-1]
+				if lastTx.Type() == types.StateSyncTxType {
+					vmenv := vm.NewEVM(
+						core.NewEVMBlockContext(header, cx, &header.Coinbase),
+						wrappedState, c.chainConfig, vmCfg,
+					)
+					hooks.OnTxStart(vmenv.GetVMContext(), lastTx, statefull.SystemAddress)
+				}
+			}
+		}
+
 		// check and commit span
 		if !c.config.IsRio(header.Number) {
-			if err := c.checkAndCommitSpan(wrappedState, header, cx); err != nil {
+			if err := c.checkAndCommitSpan(wrappedState, header, cx, vmCfg); err != nil {
 				log.Error("Error while committing span", "error", err)
 				return nil
 			}
 		}
 
 		if c.HeimdallClient != nil {
 			// commit states
-			stateSyncData, err = c.CommitStates(wrappedState, header, cx)
+			stateSyncData, err = c.CommitStates(wrappedState, header, cx, vmCfg)
 			if err != nil {
 				log.Error("Error while committing states", "error", err)
 				return nil
@@ -1183,7 +1213,7 @@ func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header,
 				return receipts
 			}
 			if lastTx.Type() == types.StateSyncTxType {
-				receipts = insertStateSyncTransactionAndCalculateReceipt(lastTx, header, body, wrappedState, receipts)
+				receipts = insertStateSyncTransactionAndCalculateReceipt(lastTx, header, body, wrappedState, receipts, vmCfg)
 			}
 		}
 	} else {
@@ -1194,7 +1224,7 @@ func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header,
 	return receipts
 }
 
-func insertStateSyncTransactionAndCalculateReceipt(stateSyncTx *types.Transaction, header *types.Header, body *types.Body, state vm.StateDB, receipts []*types.Receipt) []*types.Receipt {
+func insertStateSyncTransactionAndCalculateReceipt(stateSyncTx *types.Transaction, header *types.Header, body *types.Body, state vm.StateDB, receipts []*types.Receipt, vmConfig vm.Config) []*types.Receipt {
 	allLogs := state.Logs()
 	sort.SliceStable(allLogs, func(i, j int) bool {
 		return allLogs[i].Index < allLogs[j].Index
@@ -1227,6 +1257,12 @@ func insertStateSyncTransactionAndCalculateReceipt(stateSyncTx *types.Transactio
 	}
 
 	stateSyncReceipt.Bloom = types.CreateBloom(stateSyncReceipt)
+
+	// End tracing for StateSyncTx
+	if hooks := vmConfig.Tracer; hooks != nil && hooks.OnTxEnd != nil {
+		hooks.OnTxEnd(stateSyncReceipt, nil)
+	}
+
 	receipts = append(receipts, stateSyncReceipt)
 
 	return receipts
@@ -1285,20 +1321,22 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ
 		err           error
 	)
 
+	vmCfg := extractVMConfig(chain)
+
 	if IsSprintStart(headerNumber, c.config.CalculateSprint(headerNumber)) {
 		cx := statefull.ChainContext{Chain: chain, Bor: c}
 
 		// check and commit span
 		if !c.config.IsRio(header.Number) {
-			if err = c.checkAndCommitSpan(state, header, cx); err != nil {
+			if err = c.checkAndCommitSpan(state, header, cx, vmCfg); err != nil {
 				log.Error("Error while committing span", "error", err)
 				return nil, nil, 0, err
 			}
 		}
 
 		if c.HeimdallClient != nil {
 			// commit states
-			stateSyncData, err = c.CommitStates(state, header, cx)
+			stateSyncData, err = c.CommitStates(state, header, cx, vmCfg)
 			if err != nil {
 				log.Error("Error while committing states", "error", err)
 				return nil, nil, 0, err
@@ -1324,7 +1362,7 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ
 			StateSyncData: stateSyncData,
 		})
 		body.Transactions = append(body.Transactions, stateSyncTx)
-		receipts = insertStateSyncTransactionAndCalculateReceipt(stateSyncTx, header, body, state, receipts)
+		receipts = insertStateSyncTransactionAndCalculateReceipt(stateSyncTx, header, body, state, receipts, vmCfg)
 	} else {
 		// set state sync
 		bc := chain.(core.BorStateSyncer)
@@ -1526,6 +1564,7 @@ func (c *Bor) checkAndCommitSpan(
 	state vm.StateDB,
 	header *types.Header,
 	chain core.ChainContext,
+	vmCfg vm.Config,
 ) error {
 	var ctx = context.Background()
 	headerNumber := header.Number.Uint64()
@@ -1542,7 +1581,7 @@ func (c *Bor) checkAndCommitSpan(
 	tempState.IntermediateRoot(false)
 
 	if c.needToCommitSpan(span, headerNumber) {
-		return c.FetchAndCommitSpan(ctx, span.Id+1, state, header, chain)
+		return c.FetchAndCommitSpan(ctx, span.Id+1, state, header, chain, vmCfg)
 	}
 
 	return nil
@@ -1581,6 +1620,7 @@ func (c *Bor) FetchAndCommitSpan(
 	state vm.StateDB,
 	header *types.Header,
 	chain core.ChainContext,
+	vmCfg vm.Config,
 ) error {
 	var (
 		minSpan    borTypes.Span
@@ -1644,14 +1684,15 @@ func (c *Bor) FetchAndCommitSpan(
 		)
 	}
 
-	return c.spanner.CommitSpan(ctx, minSpan, validators, producers, state, header, chain)
+	return c.spanner.CommitSpan(ctx, minSpan, validators, producers, state, header, chain, vmCfg)
 }
 
 // CommitStates commit states
 func (c *Bor) CommitStates(
 	state vm.StateDB,
 	header *types.Header,
 	chain statefull.ChainContext,
+	vmCfg vm.Config,
 ) ([]*types.StateSyncData, error) {
 	fetchStart := time.Now()
 	number := header.Number.Uint64()
@@ -1765,7 +1806,7 @@ func (c *Bor) CommitStates(
 		// we expect that this call MUST emit an event, otherwise we wouldn't make a receipt
 		// if the receiver address is not a contract then we'll skip the most of the execution and emitting an event as well
 		// https://github.com/0xPolygon/genesis-contracts/blob/master/contracts/StateReceiver.sol#L27
-		gasUsed, err = c.GenesisContractsClient.CommitState(eventRecord, state, header, chain)
+		gasUsed, err = c.GenesisContractsClient.CommitState(eventRecord, state, header, chain, vmCfg)
 		if err != nil {
 			return nil, err
 		}

consensus/bor/bor_test.go

@@ -64,7 +64,7 @@ func (s *fakeSpanner) GetCurrentValidatorsByHash(ctx context.Context, headerHash
 func (s *fakeSpanner) GetCurrentValidatorsByBlockNrOrHash(ctx context.Context, _ rpc.BlockNumberOrHash, _ uint64) ([]*valset.Validator, error) {
 	return s.vals, nil
 }
-func (s *fakeSpanner) CommitSpan(ctx context.Context, _ borTypes.Span, _ []stakeTypes.MinimalVal, _ []stakeTypes.MinimalVal, _ vm.StateDB, _ *types.Header, _ core.ChainContext) error {
+func (s *fakeSpanner) CommitSpan(ctx context.Context, _ borTypes.Span, _ []stakeTypes.MinimalVal, _ []stakeTypes.MinimalVal, _ vm.StateDB, _ *types.Header, _ core.ChainContext, _ vm.Config) error {
 	if s.shouldFailCommit {
 		return errors.New("span commit failed")
 	}
@@ -77,7 +77,7 @@ type failingHeimdallClient struct{}
 // failingGenesisContract simulates GenesisContract failures
 type failingGenesisContract struct{}
 
-func (f *failingGenesisContract) CommitState(event *clerk.EventRecordWithTime, state vm.StateDB, header *types.Header, chCtx statefull.ChainContext) (uint64, error) {
+func (f *failingGenesisContract) CommitState(event *clerk.EventRecordWithTime, state vm.StateDB, header *types.Header, chCtx statefull.ChainContext, vmCfg vm.Config) (uint64, error) {
 	return 0, errors.New("commit state failed")
 }
 
@@ -2049,7 +2049,7 @@ func TestInsertStateSyncTransactionAndCalculateReceipt(t *testing.T) {
 		},
 	}
 
-	receipts := insertStateSyncTransactionAndCalculateReceipt(stateSyncTx, header, body, mockState, existingReceipts)
+	receipts := insertStateSyncTransactionAndCalculateReceipt(stateSyncTx, header, body, mockState, existingReceipts, vm.Config{})
 	require.Len(t, receipts, 2)
 
 	ssReceipt := receipts[1]
@@ -2620,7 +2620,7 @@ func TestFetchAndCommitSpan_WithHeimdallClient(t *testing.T) {
 
 	h := &types.Header{Number: big.NewInt(64), ParentHash: genesis.Hash()}
 
-	err := b.FetchAndCommitSpan(context.Background(), 1, statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	err := b.FetchAndCommitSpan(context.Background(), 1, statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 }
 
@@ -2654,7 +2654,7 @@ func TestFetchAndCommitSpan_ChainIDMismatch(t *testing.T) {
 
 	h := &types.Header{Number: big.NewInt(64), ParentHash: genesis.Hash()}
 
-	err := b.FetchAndCommitSpan(context.Background(), 1, statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	err := b.FetchAndCommitSpan(context.Background(), 1, statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "doesn't match")
 }
@@ -2673,7 +2673,7 @@ func TestFetchAndCommitSpan_NilResponse(t *testing.T) {
 
 	h := &types.Header{Number: big.NewInt(64), ParentHash: genesis.Hash()}
 
-	err := b.FetchAndCommitSpan(context.Background(), 1, statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	err := b.FetchAndCommitSpan(context.Background(), 1, statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.Error(t, err)
 }
 
@@ -2718,7 +2718,7 @@ func TestCommitStates_WithOverrideSkip(t *testing.T) {
 	h := &types.Header{Number: big.NewInt(16), ParentHash: genesis.Hash(), Time: genesis.Time + 32}
 
 	// CommitStates with override that sets records to 0 should skip
-	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	require.Empty(t, result)
 }
@@ -2750,7 +2750,7 @@ func TestCommitStates_WithIndore(t *testing.T) {
 
 	h := &types.Header{Number: big.NewInt(16), ParentHash: genesis.Hash(), Time: genesis.Time + 32}
 
-	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	require.Empty(t, result) // no events
 }
@@ -2793,7 +2793,7 @@ func TestCommitStates_WithEvents(t *testing.T) {
 
 	h := &types.Header{Number: big.NewInt(16), ParentHash: genesis.Hash(), Time: uint64(now.Unix())}
 
-	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	require.Len(t, result, 1)
 	require.Equal(t, uint64(1), result[0].ID)
@@ -3169,7 +3169,7 @@ type mockGenesisContractForCommitStatesIndore struct {
 	gasUsed     uint64
 }
 
-func (m *mockGenesisContractForCommitStatesIndore) CommitState(event *clerk.EventRecordWithTime, state vm.StateDB, header *types.Header, chCtx statefull.ChainContext) (uint64, error) {
+func (m *mockGenesisContractForCommitStatesIndore) CommitState(event *clerk.EventRecordWithTime, state vm.StateDB, header *types.Header, chCtx statefull.ChainContext, vmCfg vm.Config) (uint64, error) {
 	return m.gasUsed, nil
 }
 
@@ -3229,7 +3229,7 @@ func TestCommitStates_WithIndore_EventProcessing(t *testing.T) {
 		Time:       uint64(now.Unix()),
 	}
 
-	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	require.Len(t, result, 2) // both events should be processed
 }
@@ -3283,7 +3283,7 @@ func TestCommitStates_NonIndore(t *testing.T) {
 		Time:       uint64(time.Now().Unix()),
 	}
 
-	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	result, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	require.Len(t, result, 1)
 }
@@ -3808,7 +3808,7 @@ func TestCommitStates_WithOverrideStateSyncRecords(t *testing.T) {
 		GasLimit:   genesis.GasLimit,
 	}
 
-	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	// With OverrideStateSyncRecords truncating to 0, should get empty data
 	require.Empty(t, data)
@@ -4068,7 +4068,7 @@ func TestCommitStates_WithOverrideStateSyncRecordsInRange(t *testing.T) {
 		GasLimit:   genesis.GasLimit,
 	}
 
-	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	require.Empty(t, data) // truncated to 0 by range override
 }
@@ -4107,7 +4107,7 @@ func TestCommitStates_StateSyncEventsError(t *testing.T) {
 		GasLimit:   genesis.GasLimit,
 	}
 
-	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err) // error is logged but returns empty data
 	require.Empty(t, data)
 }
@@ -4157,7 +4157,7 @@ func TestCommitStates_EventIdLessThanLastStateId(t *testing.T) {
 		GasLimit:   genesis.GasLimit,
 	}
 
-	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err)
 	// Event ID=3 should be skipped (3 <= 5), event ID=6 should be processed
 	require.Len(t, data, 1)
@@ -4206,7 +4206,7 @@ func TestCommitStates_EventValidationError(t *testing.T) {
 		GasLimit:   genesis.GasLimit,
 	}
 
-	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b})
+	data, err := b.CommitStates(statedb, h, statefull.ChainContext{Chain: chain.HeaderChain(), Bor: b}, vm.Config{})
 	require.NoError(t, err) // validation error is logged but returned data should be empty
 	require.Empty(t, data)
 }

consensus/bor/contract/client.go

@@ -74,6 +74,7 @@ func (gc *GenesisContractsClient) CommitState(
 	state vm.StateDB,
 	header *types.Header,
 	chCtx statefull.ChainContext,
+	vmCfg vm.Config,
 ) (uint64, error) {
 	eventRecord := event.BuildEventRecord()
 
@@ -96,7 +97,7 @@ func (gc *GenesisContractsClient) CommitState(
 
 	log.Info("→ committing new state", "eventRecord", event.ID)
 
-	gasUsed, err := statefull.ApplyMessage(context.Background(), msg, state, header, gc.chainConfig, chCtx)
+	gasUsed, err := statefull.ApplyMessage(context.Background(), msg, state, header, gc.chainConfig, chCtx, vmCfg)
 
 	// Logging event log with time and individual gasUsed
 	log.Info("→ committed new state", "eventRecord", event.String(gasUsed))

consensus/bor/genesis.go

@@ -13,6 +13,6 @@ import (
 
 //go:generate mockgen -destination=./genesis_contract_mock.go -package=bor . GenesisContract
 type GenesisContract interface {
-	CommitState(event *clerk.EventRecordWithTime, state vm.StateDB, header *types.Header, chCtx statefull.ChainContext) (uint64, error)
+	CommitState(event *clerk.EventRecordWithTime, state vm.StateDB, header *types.Header, chCtx statefull.ChainContext, vmCfg vm.Config) (uint64, error)
 	LastStateId(state *state.StateDB, number uint64, hash common.Hash) (*big.Int, error)
 }