use core.NewBlockContext to avoid breaking changes

Author: qdm12

core/chain_makers.go

@@ -284,7 +284,8 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 		b := &BlockGen{i: i, cm: cm, parent: parent, statedb: statedb, engine: engine}
 		b.header = cm.makeHeader(parent, gap, statedb, b.engine)
 
-		err := ApplyUpgrades(config, &parent.Header().Time, b, statedb)
+		blockContext := NewBlockContext(b.header.Number, b.header.Time)
+		err := ApplyUpgrades(config, &parent.Header().Time, blockContext, statedb)
 		if err != nil {
 			return nil, nil, fmt.Errorf("failed to configure precompiles %w", err)
 		}

core/genesis.go

@@ -277,7 +277,8 @@ func (g *Genesis) toBlock(db ethdb.Database, triedb *triedb.Database) *types.Blo
 	}
 
 	// Configure any stateful precompiles that should be enabled in the genesis.
-	err = ApplyPrecompileActivations(g.Config, nil, types.NewBlockWithHeader(head), statedb)
+	blockContext := NewBlockContext(head.Number, head.Time)
+	err = ApplyPrecompileActivations(g.Config, nil, blockContext, statedb)
 	if err != nil {
 		panic(fmt.Sprintf("unable to configure precompiles in genesis block: %v", err))
 	}

core/state_processor.go

@@ -83,7 +83,8 @@ func (p *StateProcessor) Process(block *types.Block, parent *types.Header, state
 	)
 
 	// Configure any upgrades that should go into effect during this block.
-	err := ApplyUpgrades(p.config, &parent.Time, block, statedb)
+	blockContext := NewBlockContext(block.Number(), block.Time())
+	err := ApplyUpgrades(p.config, &parent.Time, blockContext, statedb)
 	if err != nil {
 		log.Error("failed to configure precompiles processing block", "hash", block.Hash(), "number", block.NumberU64(), "timestamp", block.Time(), "err", err)
 		return nil, nil, 0, err
@@ -210,7 +211,7 @@ func ProcessBeaconBlockRoot(beaconRoot common.Hash, vmenv *vm.EVM, statedb *stat
 // This function is called within genesis setup to configure the starting state for precompiles enabled at genesis.
 // In block processing and building, ApplyUpgrades is called instead which also applies state upgrades.
 func ApplyPrecompileActivations(c *params.ChainConfig, parentTimestamp *uint64, blockContext contract.ConfigurationBlockContext, statedb *state.StateDB) error {
-	blockTimestamp := blockContext.Time()
+	blockTimestamp := blockContext.Timestamp()
 	// Note: RegisteredModules returns precompiles sorted by module addresses.
 	// This ensures that the order we call Configure for each precompile is consistent.
 	// This ensures even if precompiles read/write state other than their own they will observe
@@ -261,7 +262,7 @@ func ApplyPrecompileActivations(c *params.ChainConfig, parentTimestamp *uint64,
 func applyStateUpgrades(c *params.ChainConfig, parentTimestamp *uint64, blockContext contract.ConfigurationBlockContext, statedb *state.StateDB) error {
 	// Apply state upgrades
 	configExtra := params.GetExtra(c)
-	for _, upgrade := range configExtra.GetActivatingStateUpgrades(parentTimestamp, blockContext.Time(), configExtra.StateUpgrades) {
+	for _, upgrade := range configExtra.GetActivatingStateUpgrades(parentTimestamp, blockContext.Timestamp(), configExtra.StateUpgrades) {
 		log.Info("Applying state upgrade", "blockNumber", blockContext.Number(), "upgrade", upgrade)
 		if err := stateupgrade.Configure(&upgrade, c, statedb, blockContext); err != nil {
 			return fmt.Errorf("could not configure state upgrade: %w", err)
@@ -295,5 +296,5 @@ func NewBlockContext(number *big.Int, time uint64) *blockContext {
 	}
 }
 
-func (bc *blockContext) Number() *big.Int { return bc.number }
-func (bc *blockContext) Time() uint64     { return bc.time }
+func (bc *blockContext) Number() *big.Int  { return bc.number }
+func (bc *blockContext) Timestamp() uint64 { return bc.time }

eth/state_accessor.go

@@ -284,7 +284,8 @@ func (eth *Ethereum) StateAtNextBlock(ctx context.Context, parent *types.Block,
 	}
 
 	// Apply upgrades here for the [nextBlock]
-	err = core.ApplyUpgrades(eth.blockchain.Config(), &parent.Header().Time, nextBlock, statedb)
+	blockContext := core.NewBlockContext(nextBlock.Number(), nextBlock.Time())
+	err = core.ApplyUpgrades(eth.blockchain.Config(), &parent.Header().Time, blockContext, statedb)
 	if err != nil {
 		release()
 		return nil, nil, err

eth/tracers/api_test.go

@@ -181,7 +181,8 @@ func (b *testBackend) StateAtNextBlock(ctx context.Context, parent, nextBlock *t
 		return nil, nil, err
 	}
 	// Apply upgrades to the parent state
-	err = core.ApplyUpgrades(b.chainConfig, &parent.Header().Time, nextBlock, statedb)
+	blockContext := core.NewBlockContext(nextBlock.Number(), nextBlock.Time())
+	err = core.ApplyUpgrades(b.chainConfig, &parent.Header().Time, blockContext, statedb)
 	if err != nil {
 		release()
 		return nil, nil, err

miner/worker.go

@@ -228,7 +228,8 @@ func (w *worker) commitNewWork(predicateContext *precompileconfig.PredicateConte
 		env.state.StopPrefetcher()
 	}()
 	// Configure any upgrades that should go into effect during this block.
-	err = core.ApplyUpgrades(w.chainConfig, &parent.Time, types.NewBlockWithHeader(header), env.state)
+	blockContext := core.NewBlockContext(header.Number, header.Time)
+	err = core.ApplyUpgrades(w.chainConfig, &parent.Time, blockContext, env.state)
 	if err != nil {
 		log.Error("failed to configure precompiles mining new block", "parent", parent.Hash(), "number", header.Number, "timestamp", header.Time, "err", err)
 		return nil, err

params/hooks_libevm.go

@@ -141,7 +141,7 @@ func (p *precompileBlockContext) Number() *big.Int {
 	return p.number
 }
 
-func (p *precompileBlockContext) Time() uint64 {
+func (p *precompileBlockContext) Timestamp() uint64 {
 	return p.time
 }
 

precompile/contract/interfaces.go

@@ -62,7 +62,7 @@ type AccessibleState interface {
 // ConfigurationBlockContext defines the interface required to configure a precompile.
 type ConfigurationBlockContext interface {
 	Number() *big.Int
-	Time() uint64
+	Timestamp() uint64
 }
 
 type BlockContext interface {

precompile/contract/mocks.go

@@ -60,5 +60,5 @@ func ParseABI(rawABI string) abi.ABI {
 }
 
 func IsDurangoActivated(evm AccessibleState) bool {
-	return evm.GetChainConfig().IsDurango(evm.GetBlockContext().Time())
+	return evm.GetChainConfig().IsDurango(evm.GetBlockContext().Timestamp())
 }

precompile/contract/utils.go

@@ -144,7 +144,7 @@ var (
 			ExpectedRes: []byte{},
 			SetupBlockContext: func(mbc *contract.MockBlockContext) {
 				mbc.EXPECT().Number().Return(testBlockNumber).AnyTimes()
-				mbc.EXPECT().Time().Return(uint64(0)).AnyTimes()
+				mbc.EXPECT().Timestamp().Return(uint64(0)).AnyTimes()
 			},
 			AfterHook: func(t testing.TB, state contract.StateDB) {
 				feeConfig := GetStoredFeeConfig(state)
@@ -321,7 +321,7 @@ var (
 			ExpectedErr: ErrInvalidLen.Error(),
 			SetupBlockContext: func(mbc *contract.MockBlockContext) {
 				mbc.EXPECT().Number().Return(testBlockNumber).AnyTimes()
-				mbc.EXPECT().Time().Return(uint64(0)).AnyTimes()
+				mbc.EXPECT().Timestamp().Return(uint64(0)).AnyTimes()
 			},
 		},
 		"set config with extra padded bytes should succeed with Durango": {
@@ -344,7 +344,7 @@ var (
 			ExpectedRes: []byte{},
 			SetupBlockContext: func(mbc *contract.MockBlockContext) {
 				mbc.EXPECT().Number().Return(testBlockNumber).AnyTimes()
-				mbc.EXPECT().Time().Return(uint64(0)).AnyTimes()
+				mbc.EXPECT().Timestamp().Return(uint64(0)).AnyTimes()
 			},
 			AfterHook: func(t testing.TB, state contract.StateDB) {
 				feeConfig := GetStoredFeeConfig(state)
@@ -371,7 +371,7 @@ var (
 			ReadOnly:    false,
 			SetupBlockContext: func(mbc *contract.MockBlockContext) {
 				mbc.EXPECT().Number().Return(testBlockNumber).AnyTimes()
-				mbc.EXPECT().Time().Return(uint64(0)).AnyTimes()
+				mbc.EXPECT().Timestamp().Return(uint64(0)).AnyTimes()
 			},
 		},
 		"setFeeConfig regression test should succeed after Durango": {
@@ -388,7 +388,7 @@ var (
 			ExpectedRes: []byte{},
 			SetupBlockContext: func(mbc *contract.MockBlockContext) {
 				mbc.EXPECT().Number().Return(testBlockNumber).AnyTimes()
-				mbc.EXPECT().Time().Return(uint64(0)).AnyTimes()
+				mbc.EXPECT().Timestamp().Return(uint64(0)).AnyTimes()
 			},
 			AfterHook: func(t testing.TB, state contract.StateDB) {
 				feeConfig := GetStoredFeeConfig(state)

precompile/contracts/feemanager/contract_test.go

@@ -106,7 +106,7 @@ func (test PrecompileTest) setup(t testing.TB, module modules.Module, state cont
 		test.SetupBlockContext(blockContext)
 	} else {
 		blockContext.EXPECT().Number().Return(big.NewInt(0)).AnyTimes()
-		blockContext.EXPECT().Time().Return(uint64(time.Now().Unix())).AnyTimes()
+		blockContext.EXPECT().Timestamp().Return(uint64(time.Now().Unix())).AnyTimes()
 	}
 	snowContext := utils.TestSnowContext()