feat: live tracing support for state-sync and system transactions

builder/files/genesis-amoy.json

@@ -28,6 +28,7 @@
       "dandeliBlock": 31890000,
       "lisovoBlock": 33634700,
       "lisovoProBlock": 34062000,
+      "giuglianoBlock": 35573500,
       "skipValidatorByteCheck": [26160367, 26161087, 26171567, 26173743, 26175647],
       "stateSyncConfirmationDelay": {
         "0": 128

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/geth/main.go

@@ -197,6 +197,7 @@ var (
 		utils.RPCGlobalEVMTimeoutFlag,
 		utils.RPCGlobalTxFeeCapFlag,
 		utils.RPCGlobalLogQueryLimit,
+		utils.RPCGlobalRangeLimitFlag,
 		utils.AllowUnprotectedTxs,
 		utils.BatchRequestLimit,
 		utils.BatchResponseMaxSize,

cmd/utils/flags.go

@@ -663,6 +663,12 @@ var (
 		Value:    ethconfig.Defaults.LogQueryLimit,
 		Category: flags.APICategory,
 	}
+	RPCGlobalRangeLimitFlag = &cli.Uint64Flag{
+		Name:     "rpc.rangelimit",
+		Usage:    "Maximum block range allowed for eth_getLogs and bor_getLogs (0 = no limit)",
+		Value:    ethconfig.Defaults.RPCBlockRangeLimit,
+		Category: flags.APICategory,
+	}
 	RPCTxSyncDefaultTimeoutFlag = &cli.DurationFlag{
 		Name:     "rpc.txsync.defaulttimeout",
 		Usage:    "Default timeout for eth_sendRawTransactionSync (e.g. 2s, 500ms)",
@@ -1878,6 +1884,10 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 	}
 	if ctx.IsSet(RPCGlobalLogQueryLimit.Name) {
 		cfg.LogQueryLimit = ctx.Int(RPCGlobalLogQueryLimit.Name)
+		cfg.RPCLogQueryLimit = ctx.Int(RPCGlobalLogQueryLimit.Name)
+	}
+	if ctx.IsSet(RPCGlobalRangeLimitFlag.Name) {
+		cfg.RPCBlockRangeLimit = ctx.Uint64(RPCGlobalRangeLimitFlag.Name)
 	}
 	if ctx.IsSet(RPCTxSyncDefaultTimeoutFlag.Name) {
 		cfg.TxSyncDefaultTimeout = ctx.Duration(RPCTxSyncDefaultTimeoutFlag.Name)
@@ -2230,7 +2240,8 @@ func RegisterGraphQLService(stack *node.Node, backend ethapi.Backend, filterSyst
 func RegisterFilterAPI(stack *node.Node, backend ethapi.Backend, ethcfg *ethconfig.Config) *filters.FilterSystem {
 	filterSystem := filters.NewFilterSystem(backend, filters.Config{
 		LogCacheSize:  ethcfg.FilterLogCacheSize,
-		LogQueryLimit: ethcfg.LogQueryLimit,
+		LogQueryLimit: ethcfg.RPCLogQueryLimit,
+		RangeLimit:    ethcfg.RPCBlockRangeLimit,
 	})
 
 	filterAPI := filters.NewFilterAPI(filterSystem, ethcfg.BorLogs)

consensus/bor/bor.go

@@ -1185,22 +1185,46 @@ func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header,
 	var (
 		stateSyncData []*types.StateSyncData
 		err           error
+		vmCfg         vm.Config
 	)
 
+	if bc, ok := chain.(*core.BlockChain); ok {
+		vmCfg = *bc.GetVMConfig()
+	} else if hc, ok := chain.(*core.HeaderChain); ok {
+		if cfg := hc.GetVMConfig(); cfg != nil {
+			vmCfg = *cfg
+		}
+	}
+
 	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
@@ -1231,7 +1255,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 {
@@ -1242,7 +1266,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
@@ -1275,6 +1299,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
@@ -1331,23 +1361,32 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ
 	var (
 		stateSyncData []*types.StateSyncData
 		err           error
+		vmCfg         vm.Config
 	)
 
+	if bc, ok := chain.(*core.BlockChain); ok {
+		vmCfg = *bc.GetVMConfig()
+	} else if hc, ok := chain.(*core.HeaderChain); ok {
+		if cfg := hc.GetVMConfig(); cfg != nil {
+			vmCfg = *cfg
+		}
+	}
+
 	if IsSprintStart(headerNumber, c.config.CalculateSprint(headerNumber)) {
 		borStart := time.Now()
 		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
@@ -1374,7 +1413,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)
@@ -1576,6 +1615,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()
@@ -1592,7 +1632,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
@@ -1631,6 +1671,7 @@ func (c *Bor) FetchAndCommitSpan(
 	state vm.StateDB,
 	header *types.Header,
 	chain core.ChainContext,
+	vmCfg vm.Config,
 ) error {
 	var (
 		minSpan    borTypes.Span
@@ -1694,14 +1735,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()
@@ -1815,7 +1857,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

@@ -67,7 +67,7 @@
 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")
 	}
@@ -80,7 +80,7 @@
 // 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")
 }
 

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)
 }

consensus/bor/heimdall/span/spanner.go

@@ -291,7 +291,7 @@
 
 const method = "commitSpan"
 
-func (c *ChainSpanner) CommitSpan(ctx context.Context, minimalSpan borTypes.Span, validators, producers []stakeTypes.MinimalVal, state vm.StateDB, header *types.Header, chainContext core.ChainContext) error {
+func (c *ChainSpanner) CommitSpan(ctx context.Context, minimalSpan borTypes.Span, validators, producers []stakeTypes.MinimalVal, state vm.StateDB, header *types.Header, chainContext core.ChainContext, vmCfg vm.Config) error {
 	// get validators bytes
 	validatorBytes, err := rlp.EncodeToBytes(validators)
 	if err != nil {
@@ -329,7 +329,7 @@
 	msg := statefull.GetSystemMessage(c.validatorContractAddress, data)
 
 	// apply message
-	_, err = statefull.ApplyMessage(ctx, msg, state, header, c.chainConfig, chainContext)
+	_, err = statefull.ApplyMessage(ctx, msg, state, header, c.chainConfig, chainContext, vmCfg)
 
 	return err
 }

consensus/bor/span.go

@@ -20,5 +20,5 @@ type Spanner interface {
 	GetCurrentSpan(ctx context.Context, headerHash common.Hash, state *state.StateDB) (*borTypes.Span, error)
 	GetCurrentValidatorsByHash(ctx context.Context, headerHash common.Hash, blockNumber uint64) ([]*valset.Validator, error)
 	GetCurrentValidatorsByBlockNrOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash, blockNumber uint64) ([]*valset.Validator, error)
-	CommitSpan(ctx context.Context, minimalSpan borTypes.Span, validators, producers []stakeTypes.MinimalVal, state vm.StateDB, header *types.Header, chainContext core.ChainContext) error
+	CommitSpan(ctx context.Context, minimalSpan borTypes.Span, validators, producers []stakeTypes.MinimalVal, state vm.StateDB, header *types.Header, chainContext core.ChainContext, vmCfg vm.Config) error
 }

consensus/bor/statefull/processor.go

@@ -17,7 +17,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
-var systemAddress = common.HexToAddress("0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE")
+var SystemAddress = common.HexToAddress("0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE")
 
 type ChainContext struct {
 	Chain consensus.ChainHeaderReader
@@ -70,7 +70,7 @@ func (m Callmsg) Data() []byte         { return m.CallMsg.Data }
 func GetSystemMessage(toAddress common.Address, data []byte) Callmsg {
 	return Callmsg{
 		ethereum.CallMsg{
-			From:     systemAddress,
+			From:     SystemAddress,
 			Gas:      params.MaxTxGas, // should be more than enough for state-sync related syscalls
 			GasPrice: big.NewInt(0),
 			Value:    big.NewInt(0),
@@ -88,6 +88,7 @@ func ApplyMessage(
 	header *types.Header,
 	chainConfig *params.ChainConfig,
 	chainContext core.ChainContext,
+	vmConfig vm.Config,
 ) (uint64, error) {
 	initialGas := msg.Gas()
 
@@ -96,7 +97,7 @@ func ApplyMessage(
 
 	// Create a new environment which holds all relevant information
 	// about the transaction and calling mechanisms.
-	vmenv := vm.NewEVM(blockContext, state, chainConfig, vm.Config{})
+	vmenv := vm.NewEVM(blockContext, state, chainConfig, vmConfig)
 
 	// nolint : contextcheck
 	// Apply the transaction to the current state (included in the env)

core/blockchain.go

@@ -490,6 +490,7 @@ func NewBlockChain(db ethdb.Database, genesis *Genesis, engine consensus.Engine,
 	if err != nil {
 		return nil, err
 	}
+	bc.hc.vmConfig = &bc.cfg.VmConfig
 	bc.flushInterval.Store(int64(cfg.TrieTimeLimit))
 	bc.forker = NewForkChoice(bc, cfg.ShouldPreserve, cfg.Checker)