feature: Add eth_createAccessList method and implementation

crypto/hd/utils_test.go

@@ -135,8 +135,7 @@ func (w *Wallet) derivePrivateKey(path accounts.DerivationPath) (*ecdsa.PrivateK
 		if w.fixIssue172 && key.IsAffectedByIssue172() {
 			key, err = key.Derive(n)
 		} else {
-			//lint:ignore SA1019 this is used for testing only
-			key, err = key.DeriveNonStandard(n) //nolint:staticcheck
+			key, err = key.DeriveNonStandard(n) //nolint:staticcheck // SA1019 this is used for testing only
 		}
 		if err != nil {
 			return nil, err

evmd/cmd/evmd/config/evmd_config.go

@@ -58,7 +58,6 @@ var maccPerms = map[string][]string{
 func BlockedAddresses() map[string]bool {
 	blockedAddrs := make(map[string]bool)
 
-	maps.Clone(maccPerms)
 	maccPerms := GetMaccPerms()
 	accs := make([]string, 0, len(maccPerms))
 	for acc := range maccPerms {

local_node.sh

@@ -287,11 +287,6 @@ if [[ $overwrite == "y" || $overwrite == "Y" ]]; then
   sed -i.bak 's/"voting_period": "172800s"/"voting_period": "30s"/g' "$GENESIS"
   sed -i.bak 's/"expedited_voting_period": "86400s"/"expedited_voting_period": "15s"/g' "$GENESIS"
 
-  # pruning
-  sed -i.bak 's/pruning = "default"/pruning = "custom"/g' "$APP_TOML"
-  sed -i.bak 's/pruning-keep-recent = "0"/pruning-keep-recent = "100"/g' "$APP_TOML"
-  sed -i.bak 's/pruning-interval = "0"/pruning-interval = "10"/g' "$APP_TOML"
-
   # fund validator (devs already funded in the loop)
   evmd genesis add-genesis-account "$VAL_KEY" 100000000000000000000000000atest --keyring-backend "$KEYRING" --home "$CHAINDIR"
 

rpc/backend/backend.go

@@ -107,6 +107,7 @@ type EVMBackend interface {
 	GetTransactionLogs(hash common.Hash) ([]*ethtypes.Log, error)
 	GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexutil.Uint) (*rpctypes.RPCTransaction, error)
 	GetTransactionByBlockNumberAndIndex(blockNum rpctypes.BlockNumber, idx hexutil.Uint) (*rpctypes.RPCTransaction, error)
+	CreateAccessList(args evmtypes.TransactionArgs, blockNrOrHash rpctypes.BlockNumberOrHash) (*rpctypes.AccessListResult, error)
 
 	// Send Transaction
 	Resend(args evmtypes.TransactionArgs, gasPrice *hexutil.Big, gasLimit *hexutil.Uint64) (common.Hash, error)

rpc/backend/tx_info.go

@@ -9,6 +9,9 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/eth/tracers/logger"
+	"github.com/ethereum/go-ethereum/params"
 	"github.com/pkg/errors"
 
 	cmtrpcclient "github.com/cometbft/cometbft/rpc/client"
@@ -375,3 +378,158 @@ func (b *Backend) GetTransactionByBlockAndIndex(block *cmtrpctypes.ResultBlock,
 		b.EvmChainID,
 	)
 }
+
+// CreateAccessList returns the list of addresses and storage keys used by the transaction (except for the
+// sender account and precompiles), plus the estimated gas if the access list were added to the transaction.
+func (b *Backend) CreateAccessList(args evmtypes.TransactionArgs, blockNrOrHash rpctypes.BlockNumberOrHash) (*rpctypes.AccessListResult, error) {
+	accessList, gasUsed, vmErr, err := b.createAccessList(args, blockNrOrHash)
+	if err != nil {
+		return nil, err
+	}
+
+	hexGasUsed := hexutil.Uint64(gasUsed)
+	result := rpctypes.AccessListResult{
+		AccessList: &accessList,
+		GasUsed:    &hexGasUsed,
+	}
+	if vmErr != nil {
+		result.Error = vmErr.Error()
+	}
+	return &result, nil
+}
+
+// createAccessList creates the access list for the transaction.
+// It iteratively expands the access list until it converges.
+// If the access list has converged, the access list is returned.
+// If the access list has not converged, an error is returned.
+// If the transaction itself fails, an vmErr is returned.
+func (b *Backend) createAccessList(args evmtypes.TransactionArgs, blockNrOrHash rpctypes.BlockNumberOrHash) (ethtypes.AccessList, uint64, error, error) {
+	args, err := b.SetTxDefaults(args)
+	if err != nil {
+		b.Logger.Error("failed to set tx defaults", "error", err)
+		return nil, 0, nil, err
+	}
+
+	blockNum, err := b.BlockNumberFromComet(blockNrOrHash)
+	if err != nil {
+		b.Logger.Error("failed to get block number", "error", err)
+		return nil, 0, nil, err
+	}
+
+	addressesToExclude, err := b.getAccessListExcludes(args, blockNum)
+	if err != nil {
+		b.Logger.Error("failed to get access list excludes", "error", err)
+		return nil, 0, nil, err
+	}
+
+	prevTracer, traceArgs, err := b.initAccessListTracer(args, blockNum, addressesToExclude)
+	if err != nil {
+		b.Logger.Error("failed to init access list tracer", "error", err)
+		return nil, 0, nil, err
+	}
+
+	// iteratively expand the access list
+	for {
+		accessList := prevTracer.AccessList()
+		traceArgs.AccessList = &accessList
+		res, err := b.DoCall(*traceArgs, blockNum)
+		if err != nil {
+			b.Logger.Error("failed to apply transaction", "error", err)
+			return nil, 0, nil, fmt.Errorf("failed to apply transaction: %v err: %v", traceArgs.ToTransaction(ethtypes.LegacyTxType).Hash(), err)
+		}
+
+		// Check if access list has converged (no new addresses/slots accessed)
+		newTracer := logger.NewAccessListTracer(accessList, addressesToExclude)
+		if newTracer.Equal(prevTracer) {
+			b.Logger.Info("access list converged", "accessList", accessList)
+			var vmErr error
+			if res.VmError != "" {
+				b.Logger.Error("vm error after access list converged", "vmError", res.VmError)
+				vmErr = errors.New(res.VmError)
+			}
+			return accessList, res.GasUsed, vmErr, nil
+		}
+		prevTracer = newTracer
+	}
+}
+
+// getAccessListExcludes returns the addresses to exclude from the access list.
+// This includes the sender account, the target account (if provided), precompiles,
+// and any addresses in the authorization list.
+func (b *Backend) getAccessListExcludes(args evmtypes.TransactionArgs, blockNum rpctypes.BlockNumber) (map[common.Address]struct{}, error) {
+	header, err := b.HeaderByNumber(blockNum)
+	if err != nil {
+		b.Logger.Error("failed to get header by number", "error", err)
+		return nil, err
+	}
+
+	// exclude sender and precompiles
+	addressesToExclude := make(map[common.Address]struct{})
+	addressesToExclude[args.GetFrom()] = struct{}{}
+	if args.To != nil {
+		addressesToExclude[*args.To] = struct{}{}
+	}
+
+	isMerge := b.ChainConfig().MergeNetsplitBlock != nil
+	precompiles := vm.ActivePrecompiles(b.ChainConfig().Rules(header.Number, isMerge, header.Time))
+	for _, addr := range precompiles {
+		addressesToExclude[addr] = struct{}{}
+	}
+
+	// check if enough gas was provided to cover all authorization lists
+	maxAuthorizations := uint64(*args.Gas) / params.CallNewAccountGas
+	if uint64(len(args.AuthorizationList)) > maxAuthorizations {
+		b.Logger.Error("insufficient gas to process all authorizations", "maxAuthorizations", maxAuthorizations)
+		return nil, errors.New("insufficient gas to process all authorizations")
+	}
+
+	for _, auth := range args.AuthorizationList {
+		// validate authorization (duplicating stateTransition.validateAuthorization() logic from geth: https://github.com/ethereum/go-ethereum/blob/bf8f63dcd27e178bd373bfe41ea718efee2851dd/core/state_transition.go#L575)
+		nonceOverflow := auth.Nonce+1 < auth.Nonce
+		invalidChainID := !auth.ChainID.IsZero() && auth.ChainID.CmpBig(b.ChainConfig().ChainID) != 0
+		if nonceOverflow || invalidChainID {
+			b.Logger.Error("invalid authorization", "auth", auth)
+			continue
+		}
+		if authority, err := auth.Authority(); err == nil {
+			addressesToExclude[authority] = struct{}{}
+		}
+	}
+
+	b.Logger.Debug("access list excludes created", "addressesToExclude", addressesToExclude)
+	return addressesToExclude, nil
+}
+
+// initAccessListTracer initializes the access list tracer for the transaction.
+// It sets the default call arguments and creates a new access list tracer.
+// If an access list is provided in args, it uses that instead of creating a new one.
+func (b *Backend) initAccessListTracer(args evmtypes.TransactionArgs, blockNum rpctypes.BlockNumber, addressesToExclude map[common.Address]struct{}) (*logger.AccessListTracer, *evmtypes.TransactionArgs, error) {
+	header, err := b.HeaderByNumber(blockNum)
+	if err != nil {
+		b.Logger.Error("failed to get header by number", "error", err)
+		return nil, nil, err
+	}
+
+	if args.Nonce == nil {
+		pending := blockNum == rpctypes.EthPendingBlockNumber
+		nonce, err := b.getAccountNonce(args.GetFrom(), pending, blockNum.Int64(), b.Logger)
+		if err != nil {
+			b.Logger.Error("failed to get account nonce", "error", err)
+			return nil, nil, err
+		}
+		nonce64 := hexutil.Uint64(nonce)
+		args.Nonce = &nonce64
+	}
+	if err = args.CallDefaults(b.RPCGasCap(), header.BaseFee, b.ChainConfig().ChainID); err != nil {
+		b.Logger.Error("failed to set default call args", "error", err)
+		return nil, nil, err
+	}
+
+	tracer := logger.NewAccessListTracer(nil, addressesToExclude)
+	if args.AccessList != nil {
+		tracer = logger.NewAccessListTracer(*args.AccessList, addressesToExclude)
+	}
+
+	b.Logger.Debug("access list tracer initialized", "tracer", tracer)
+	return tracer, &args, nil
+}