core: few final cleanups

core/bench_test.go

@@ -100,12 +100,10 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
 			Nonce:    gen.TxNonce(benchRootAddr),
 			To:       &toaddr,
 			Value:    big.NewInt(1),
-			Gas:      params.TxGas,
 			Data:     data,
 			GasPrice: gasPrice,
 		}
-		gas := types.IntrinsicGas(txdata, &rules)
+		txdata.Gas = types.IntrinsicGas(txdata, &rules)
-		txdata.Gas = gas
 		tx, _ := types.SignNewTx(benchRootKey, signer, txdata)
 		gen.AddTx(tx)
 	}

core/state_transition.go

@@ -376,16 +376,15 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 		rules            = st.evm.ChainConfig().Rules(st.evm.Context.BlockNumber, st.evm.Context.Random != nil, st.evm.Context.Time)
 		contractCreation = msg.To == nil
 		floorDataGas     uint64
+		err              error
 	)
 
-	gas := msg.IntrinsicGas
 	// Check clauses 4-5, subtract intrinsic gas if everything is correct
-	if st.gasRemaining < gas {
+	if st.gasRemaining < msg.IntrinsicGas {
-		return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gasRemaining, gas)
+		return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gasRemaining, msg.IntrinsicGas)
 	}
 	// Gas limit suffices for the floor data cost (EIP-7623)
 	if rules.IsPrague {
-		var err error
 		floorDataGas, err = FloorDataGas(msg.Data)
 		if err != nil {
 			return nil, err
@@ -395,9 +394,9 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 		}
 	}
 	if t := st.evm.Config.Tracer; t != nil && t.OnGasChange != nil {
-		t.OnGasChange(st.gasRemaining, st.gasRemaining-gas, tracing.GasChangeTxIntrinsicGas)
+		t.OnGasChange(st.gasRemaining, st.gasRemaining-msg.IntrinsicGas, tracing.GasChangeTxIntrinsicGas)
 	}
-	st.gasRemaining -= gas
+	st.gasRemaining -= msg.IntrinsicGas
 
 	if rules.IsEIP4762 {
 		st.evm.AccessEvents.AddTxOrigin(msg.From)

core/types/transaction.go

@@ -581,12 +581,12 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e
 	return &Transaction{inner: cpy, time: tx.time}, nil
 }
 
-// IntrinsicGas returns the 'intrinsic gas' computed for a message with the given data.
+// IntrinsicGas returns the calculated intrinsic gas for the given transaction.
 func (tx *Transaction) IntrinsicGas(rules *params.Rules) (uint64, error) {
 	return calcIntrinsicGas(tx.inner, rules)
 }
 
-// IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
+// IntrinsicGas returns the calculated intrinsic gas for the given transaction.
 func IntrinsicGas(txdata TxData, rules *params.Rules) uint64 {
 	gas, err := calcIntrinsicGas(txdata, rules)
 	if err != nil {

core/vm/evm.go

@@ -591,8 +591,10 @@ func (evm *EVM) resolveCodeHash(addr common.Address) common.Hash {
 // ChainConfig returns the environment's chain configuration
 func (evm *EVM) ChainConfig() *params.ChainConfig { return evm.chainConfig }
 
+// Rules returns the rules for the EVM given the current block's context.
 func (evm *EVM) Rules() *params.Rules {
-	rules := evm.ChainConfig().Rules(evm.Context.BlockNumber, evm.Context.Random != nil, evm.Context.Time)
+	bctx := evm.Context
+	rules := evm.ChainConfig().Rules(bctx.BlockNumber, bctx.Random != nil, bctx.Time)
 	return &rules
 }
 

eth/tracers/api.go

@@ -536,12 +536,12 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
 		chainConfig        = api.backend.ChainConfig()
 		vmctx              = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
 		deleteEmptyObjects = chainConfig.IsEIP158(block.Number())
+		evm                = vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{})
+		rules              = evm.Rules()
 	)
-	evm := vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{})
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	rules := evm.Rules()
 	if rules.IsPrague {
 		core.ProcessParentBlockHash(block.ParentHash(), evm)
 	}
@@ -601,12 +601,14 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
 	}
 	defer release()
 
-	blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+	var (
-	evm := vm.NewEVM(blockCtx, statedb, api.backend.ChainConfig(), vm.Config{})
+		blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+		evm      = vm.NewEVM(blockCtx, statedb, api.backend.ChainConfig(), vm.Config{})
+		rules    = evm.Rules()
+	)
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	rules := evm.Rules()
 	if rules.IsPrague {
 		core.ProcessParentBlockHash(block.ParentHash(), evm)
 	}
@@ -781,11 +783,13 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
 		// Note: This copies the config, to not screw up the main config
 		chainConfig, canon = overrideConfig(chainConfig, config.Overrides)
 	}
-	evm := vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{})
+	var (
+		evm   = vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{})
+		rules = evm.Rules()
+	)
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	rules := evm.Rules()
 	if rules.IsPrague {
 		core.ProcessParentBlockHash(block.ParentHash(), evm)
 	}