internal/ethapi: eth_multicall (#27720)

This is a successor PR to #25743. This PR is based on a new iteration of
the spec: ethereum/execution-apis#484.

`eth_multicall` takes in a list of blocks, each optionally overriding
fields like number, timestamp, etc. of a base block. Each block can
include calls. At each block users can override the state. There are
extra features, such as:

- Include ether transfers as part of the logs
- Overriding precompile codes with evm bytecode
- Redirecting accounts to another address

This PR includes the following breaking changes:

- Block override fields of eth_call and debug_traceCall have had the
following fields renamed
  - `coinbase` -> `feeRecipient`
  - `random` -> `prevRandao`
  - `baseFee` -> `baseFeePerGas`

---------

Co-authored-by: Gary Rong <[email protected]>
Co-authored-by: Martin Holst Swende <[email protected]>

Author: 3 people

core/state_processor.go

@@ -196,7 +196,19 @@ func ApplyMessageWithEVM(
 
 	// Create a new receipt for the transaction, storing the intermediate root and gas used
 	// by the tx.
-	receipt = &types.Receipt{Type: tx.Type(), PostState: root, CumulativeGasUsed: *usedGas}
+	receipt = MakeReceipt(evm, result, statedb, blockNumber, blockHash, tx, *usedGas, root)
+
+	// create the bloom filter
+	receiptProcessor.Apply(receipt)
+
+	return receipt, result, err
+}
+
+// MakeReceipt generates the receipt object for a transaction given its execution result.
+func MakeReceipt(evm *vm.EVM, result *ExecutionResult, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas uint64, root []byte) *types.Receipt {
+	// Create a new receipt for the transaction, storing the intermediate root and gas used
+	// by the tx.
+	receipt := &types.Receipt{Type: tx.Type(), PostState: root, CumulativeGasUsed: usedGas}
 	if result.Failed() {
 		receipt.Status = types.ReceiptStatusFailed
 	} else {
@@ -211,19 +223,17 @@ func ApplyMessageWithEVM(
 	}
 
 	// If the transaction created a contract, store the creation address in the receipt.
-	if msg.To == nil {
+	if tx.To() == nil {
 		receipt.ContractAddress = crypto.CreateAddress(evm.TxContext.Origin, tx.Nonce())
 	}
 
 	// Set the receipt logs and create the bloom filter.
 	receipt.Logs = statedb.GetLogs(tx.Hash(), blockHash)
+	receipt.Bloom = types.CreateReceiptBloom(receipt)
 	receipt.BlockHash = blockHash
 	receipt.BlockNumber = blockNumber
 	receipt.TransactionIndex = uint(statedb.TxIndex())
-	// create the bloom filter
-	receiptProcessor.Apply(receipt)
-
-	return receipt, result, err
+	return receipt
 }
 
 // ApplyTransaction attempts to apply a transaction to the given state database

core/types/block.go

@@ -34,11 +34,6 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
-var (
-	EmptyRootHash  = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
-	EmptyUncleHash = rlpHash([]*Header(nil))
-)
-
 // A BlockNonce is a 64-bit hash which proves (combined with the
 // mix-hash) that a sufficient amount of computation has been carried
 // out on a block.

core/types/bloom9.go

@@ -117,6 +117,21 @@ func CreateBloom(receipts Receipts) Bloom {
 	return bin
 }
 
+// CreateReceiptBloom creates a bloom filter for a receipt
+func CreateReceiptBloom(receipt *Receipt) Bloom {
+	var (
+		bin Bloom
+		buf = make([]byte, 6)
+	)
+	for _, log := range receipt.Logs {
+		bin.add(log.Address.Bytes(), buf)
+		for _, b := range log.Topics {
+			bin.add(b[:], buf)
+		}
+	}
+	return bin
+}
+
 // MergeBloom assumes all receipts contain calculated bloom filters and
 // merge them to create the final bloom filter instead of recalculating
 // like CreateBloom

core/types/hashes.go

@@ -18,6 +18,7 @@ package types
 
 import (
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 )
 
@@ -30,3 +31,29 @@ func TrieRootHash(hash common.Hash) common.Hash {
 	}
 	return hash
 }
+
+var (
+	// EmptyRootHash is the known root hash of an empty merkle trie.
+	EmptyRootHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
+
+	// EmptyUncleHash is the known hash of the empty uncle set.
+	EmptyUncleHash = rlpHash([]*Header(nil)) // 1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347
+
+	// EmptyCodeHash is the known hash of the empty EVM bytecode.
+	EmptyCodeHash = crypto.Keccak256Hash(nil) // c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+
+	// EmptyTxsHash is the known hash of the empty transaction set.
+	EmptyTxsHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
+
+	// EmptyReceiptsHash is the known hash of the empty receipt set.
+	EmptyReceiptsHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
+
+	// EmptyWithdrawalsHash is the known hash of the empty withdrawal set.
+	EmptyWithdrawalsHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
+
+	// EmptyRequestsHash is the known hash of an empty request set, sha256("").
+	EmptyRequestsHash = common.HexToHash("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+
+	// EmptyVerkleHash is the known hash of an empty verkle trie.
+	EmptyVerkleHash = common.Hash{}
+)

core/vm/contracts.go

@@ -21,6 +21,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"maps"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -45,6 +46,9 @@ type PrecompiledContract interface {
 	Run(input []byte) ([]byte, error) // Run runs the precompiled contract
 }
 
+// PrecompiledContracts contains the precompiled contracts supported at the given fork.
+type PrecompiledContracts map[common.Address]PrecompiledContract
+
 // PrecompiledContractsBLS contains the set of pre-compiled Ethereum
 // contracts specified in EIP-2537. These are exported for testing purposes.
 var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{
@@ -70,35 +74,39 @@ var (
 
 	// PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum
 	// contracts used in the Frontier and Homestead releases.
-	PrecompiledContractsHomestead map[common.Address]PrecompiledContract
+	PrecompiledContractsHomestead PrecompiledContracts
 
 	// PrecompiledContractsByzantium contains the default set of pre-compiled Ethereum
 	// contracts used in the Byzantium release.
-	PrecompiledContractsByzantium map[common.Address]PrecompiledContract
+	PrecompiledContractsByzantium PrecompiledContracts
 
 	// PrecompiledContractsIstanbul contains the default set of pre-compiled Ethereum
 	// contracts used in the Istanbul release.
-	PrecompiledContractsIstanbul map[common.Address]PrecompiledContract
+	PrecompiledContractsIstanbul PrecompiledContracts
 
 	// PrecompiledContractsConsortium contains additional Consortium precompiled contract
 	// beside PrecompiledContractsIstanbul
-	PrecompiledContractsConsortium map[common.Address]PrecompiledContract
+	PrecompiledContractsConsortium PrecompiledContracts
 
 	// PrecompiledContractsConsortium contains proof of possession precompiled contract
 	// beside PrecompiledContractsConsortium
-	PrecompiledContractsConsortiumMiko map[common.Address]PrecompiledContract
+	PrecompiledContractsConsortiumMiko PrecompiledContracts
 
 	// PrecompiledContractsBerlin contains the default set of pre-compiled Ethereum
 	// contracts used in the Berlin release.
-	PrecompiledContractsBerlin map[common.Address]PrecompiledContract
+	PrecompiledContractsBerlin PrecompiledContracts
 
 	// PrecompiledContractsCancun contains the default set of pre-compiled Ethereum
 	// contracts used in the Cancun release.
-	PrecompiledContractsCancun map[common.Address]PrecompiledContract
+	PrecompiledContractsCancun PrecompiledContracts
+
+	// PrecompiledContractsPrague contains the default set of pre-compiled Ethereum
+	// contracts used in the Prague release.
+	PrecompiledContractsPrague PrecompiledContracts
 )
 
-func copyPrecompiledContract(contracts map[common.Address]PrecompiledContract) map[common.Address]PrecompiledContract {
-	cpy := make(map[common.Address]PrecompiledContract)
+func copyPrecompiledContract(contracts PrecompiledContracts) PrecompiledContracts {
+	cpy := make(PrecompiledContracts)
 
 	for address, contract := range contracts {
 		cpy[address] = contract
@@ -108,7 +116,7 @@ func copyPrecompiledContract(contracts map[common.Address]PrecompiledContract) m
 }
 
 func init() {
-	PrecompiledContractsHomestead = map[common.Address]PrecompiledContract{
+	PrecompiledContractsHomestead = PrecompiledContracts{
 		common.BytesToAddress([]byte{1}): &ecrecover{},
 		common.BytesToAddress([]byte{2}): &sha256hash{},
 		common.BytesToAddress([]byte{3}): &ripemd160hash{},
@@ -202,6 +210,30 @@ func ActivePrecompiles(rules params.Rules) []common.Address {
 	}
 }
 
+func activePrecompiledContracts(rules params.Rules) PrecompiledContracts {
+	switch {
+	case rules.IsCancun:
+		return PrecompiledContractsCancun
+	case rules.IsBerlin:
+		return PrecompiledContractsBerlin
+	case rules.IsMiko:
+		return PrecompiledContractsConsortiumMiko
+	case rules.IsLastConsortiumV1Block, rules.IsConsortiumV2:
+		return PrecompiledContractsConsortium
+	case rules.IsIstanbul:
+		return PrecompiledContractsIstanbul
+	case rules.IsByzantium:
+		return PrecompiledContractsByzantium
+	default:
+		return PrecompiledContractsHomestead
+	}
+}
+
+// ActivePrecompiledContracts returns a copy of precompiled contracts enabled with the current configuration.
+func ActivePrecompiledContracts(rules params.Rules) PrecompiledContracts {
+	return maps.Clone(activePrecompiledContracts(rules))
+}
+
 // RunPrecompiledContract runs and evaluates the output of a precompiled contract.
 // It returns
 // - the returned bytes,
@@ -220,9 +252,7 @@ func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uin
 	return output, suppliedGas, err
 }
 
-var (
-	errBlacklistedAddress = errors.New("address is blacklisted")
-)
+var errBlacklistedAddress = errors.New("address is blacklisted")
 
 type blacklistedAddress struct{}
 
@@ -282,6 +312,7 @@ type sha256hash struct{}
 func (c *sha256hash) RequiredGas(input []byte) uint64 {
 	return uint64(len(input)+31)/32*params.Sha256PerWordGas + params.Sha256BaseGas
 }
+
 func (c *sha256hash) Run(input []byte) ([]byte, error) {
 	h := sha256.Sum256(input)
 	return h[:], nil
@@ -297,6 +328,7 @@ type ripemd160hash struct{}
 func (c *ripemd160hash) RequiredGas(input []byte) uint64 {
 	return uint64(len(input)+31)/32*params.Ripemd160PerWordGas + params.Ripemd160BaseGas
 }
+
 func (c *ripemd160hash) Run(input []byte) ([]byte, error) {
 	ripemd := ripemd160.New()
 	ripemd.Write(input)
@@ -313,6 +345,7 @@ type dataCopy struct{}
 func (c *dataCopy) RequiredGas(input []byte) uint64 {
 	return uint64(len(input)+31)/32*params.IdentityPerWordGas + params.IdentityBaseGas
 }
+
 func (c *dataCopy) Run(in []byte) ([]byte, error) {
 	return common.CopyBytes(in), nil
 }

core/vm/evm.go

@@ -71,31 +71,7 @@ func (evm *EVM) precompile(caller ContractRef, addr common.Address) (Precompiled
 		}
 	}
 
-	var precompiles map[common.Address]PrecompiledContract
-	switch {
-	case evm.chainRules.IsCancun:
-		precompiles = PrecompiledContractsCancun
-	case evm.chainRules.IsBerlin:
-		precompiles = PrecompiledContractsBerlin
-	case evm.chainRules.IsMiko:
-		precompiles = PrecompiledContractsConsortiumMiko
-	case evm.chainRules.IsLastConsortiumV1Block, evm.chainRules.IsConsortiumV2:
-		precompiles = PrecompiledContractsConsortium
-	case evm.chainRules.IsIstanbul:
-		precompiles = PrecompiledContractsIstanbul
-	case evm.chainRules.IsByzantium:
-		precompiles = PrecompiledContractsByzantium
-	default:
-		precompiles = PrecompiledContractsHomestead
-	}
-
-	p, ok := precompiles[addr]
-	if ok {
-		if pWithInit, hasInit := p.(PrecompiledContractWithInit); hasInit {
-			pWithInit.Init(caller, evm)
-		}
-	}
-
+	p, ok := evm.precompiles[addr]
 	return p, ok
 }
 
@@ -176,6 +152,8 @@ type EVM struct {
 	// applied in opCall*.
 	callGasTemp uint64
 
+	precompiles PrecompiledContracts
+
 	evmHook EVMHook
 }
 
@@ -195,6 +173,7 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig
 		chainConfig: chainConfig,
 		chainRules:  chainConfig.Rules(blockCtx.BlockNumber),
 	}
+	evm.precompiles = activePrecompiledContracts(evm.chainRules)
 	evm.interpreter = NewEVMInterpreter(evm, config)
 	return evm
 }
@@ -222,6 +201,13 @@ func (evm *EVM) Interpreter() *EVMInterpreter {
 	return evm.interpreter
 }
 
+// SetPrecompiles sets the precompiled contracts for the EVM.
+// This method is only used through RPC calls.
+// It is not thread-safe.
+func (evm *EVM) SetPrecompiles(precompiles PrecompiledContracts) {
+	evm.precompiles = precompiles
+}
+
 // Call executes the contract associated with the addr with the given input as
 // parameters. It also handles any necessary value transfer required and takes
 // the necessary steps to create accounts and reverses the state in case of an
@@ -323,7 +309,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
 	if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
 		return nil, gas, ErrInsufficientBalance
 	}
-	var snapshot = evm.StateDB.Snapshot()
+	snapshot := evm.StateDB.Snapshot()
 
 	// It is allowed to call precompiles, even via delegatecall
 	if p, isPrecompile := evm.precompile(caller, addr); isPrecompile {
@@ -374,7 +360,7 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by
 	if evm.depth > int(params.CallCreateDepth) {
 		return nil, gas, ErrDepth
 	}
-	var snapshot = evm.StateDB.Snapshot()
+	snapshot := evm.StateDB.Snapshot()
 
 	// It is allowed to call precompiles, even via delegatecall
 	if p, isPrecompile := evm.precompile(caller, addr); isPrecompile {
@@ -423,7 +409,7 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte
 	// after all empty accounts were deleted, so this is not required. However, if we omit this,
 	// then certain tests start failing; stRevertTest/RevertPrecompiledTouchExactOOG.json.
 	// We could change this, but for now it's left for legacy reasons
-	var snapshot = evm.StateDB.Snapshot()
+	snapshot := evm.StateDB.Snapshot()
 
 	// We do an AddBalance of zero here, just in order to trigger a touch.
 	// This doesn't matter on Mainnet, where all empties are gone at the time of Byzantium,

core/vm/interface.go

@@ -85,6 +85,9 @@ type StateDB interface {
 	ValidDeployer(common.Address) bool
 	ValidDeployerV2(common.Address, uint64, *common.Address) bool
 	Blacklisted(*common.Address, *common.Address) bool
+
+	// Finalise must be invoked at the end of a transaction
+	Finalise(bool)
 }
 
 // CallContext provides a basic interface for the EVM calling conventions. The EVM

eth/gasestimator/gasestimator.go

@@ -217,8 +217,19 @@ func run(ctx context.Context, call *core.Message, opts *Options) (*core.Executio
 		evmContext = core.NewEVMBlockContext(opts.Header, opts.Chain, nil)
 
 		dirtyState = opts.State.Copy()
-		evm        = vm.NewEVM(evmContext, msgContext, dirtyState, opts.Config, vm.Config{NoBaseFee: true})
 	)
+
+	// TODO(kuro): Check if this fee logic is needed.
+	// Lower the basefee to 0 to avoid breaking EVM
+	// invariants (basefee < feecap).
+	// if msgContext.GasPrice.Sign() == 0 {
+	// 	evmContext.BaseFee = new(big.Int)
+	// }
+	// if msgContext.BlobFeeCap != nil && msgContext.BlobFeeCap.BitLen() == 0 {
+	// 	evmContext.BlobBaseFee = new(big.Int)
+	// }
+	evm := vm.NewEVM(evmContext, msgContext, dirtyState, opts.Config, vm.Config{NoBaseFee: true})
+
 	// Monitor the outer context and interrupt the EVM upon cancellation. To avoid
 	// a dangling goroutine until the outer estimation finishes, create an internal
 	// context for the lifetime of this method call.