wip: tracer-based BAL creation

Author: jwasinger

cmd/geth/main.go

@@ -151,6 +151,7 @@ var (
 		utils.BeaconGenesisTimeFlag,
 		utils.BeaconCheckpointFlag,
 		utils.BeaconCheckpointFileFlag,
+		utils.ExperimentalBALFlag,
 	}, utils.NetworkFlags, utils.DatabaseFlags)
 
 	rpcFlags = []cli.Flag{

cmd/utils/flags.go

@@ -972,6 +972,14 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server.
 		Value:    metrics.DefaultConfig.InfluxDBOrganization,
 		Category: flags.MetricsCategory,
 	}
+
+	// Block Access List flags
+
+	ExperimentalBALFlag = &cli.BoolFlag{
+		Name:     "experimental.bal",
+		Usage:    "Enable block-access-list building when importing post-Cancun blocks, and validation that access lists contained in post-Cancun blocks correctly correspond to the state changes in those blocks. This is used for development purposes only.  Do not enable it otherwise.",
+		Category: flags.MiscCategory,
+	}
 )
 
 var (
@@ -1861,6 +1869,8 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 			cfg.VMTraceJsonConfig = ctx.String(VMTraceJsonConfigFlag.Name)
 		}
 	}
+
+	cfg.ExperimentalBAL = ctx.Bool(ExperimentalBALFlag.Name)
 }
 
 // MakeBeaconLightConfig constructs a beacon light client config based on the
@@ -2256,6 +2266,7 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh
 	}
 	options.VmConfig = vmcfg
 
+	options.EnableBALForTesting = ctx.Bool(ExperimentalBALFlag.Name)
 	chain, err := core.NewBlockChain(chainDb, gspec, engine, options)
 	if err != nil {
 		Fatalf("Can't create BlockChain: %v", err)

core/block_access_list_creation.go

@@ -0,0 +1,109 @@
+package core
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/tracing"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/types/bal"
+	"github.com/holiman/uint256"
+	"math/big"
+)
+
+// BlockAccessListTracer constructs an EIP-7928 block access list from the
+// execution of a block
+type BlockAccessListTracer struct {
+	// this is a set of access lists for each call scope. the overall block access lists
+	// is accrued at index 0, while the access lists of various nested execution
+	// scopes are in the proceeding indices.
+	// When an execution scope terminates in a non-reverting fashion, the changes are
+	// merged into the access list of the parent scope.
+	callAccessLists []*bal.ConstructionBlockAccessList
+	txIdx           uint16
+
+	// if non-nil, it's the address of the account which just self-destructed.
+	// reset at the end of the call-scope which self-destructed.
+	selfdestructedAccount *common.Address
+}
+
+// NewBlockAccessListTracer returns an BlockAccessListTracer and a set of hooks
+func NewBlockAccessListTracer() (*BlockAccessListTracer, *tracing.Hooks) {
+	balTracer := &BlockAccessListTracer{
+		callAccessLists: []*bal.ConstructionBlockAccessList{bal.NewConstructionBlockAccessList()},
+		txIdx:           0,
+	}
+	hooks := &tracing.Hooks{
+		OnTxEnd:           balTracer.TxEndHook,
+		OnTxStart:         balTracer.TxStartHook,
+		OnEnter:           balTracer.OnEnter,
+		OnExit:            balTracer.OnExit,
+		OnCodeChangeV2:    balTracer.OnCodeChange,
+		OnBalanceChange:   balTracer.OnBalanceChange,
+		OnNonceChange:     balTracer.OnNonceChange,
+		OnStorageChange:   balTracer.OnStorageChange,
+		OnColdAccountRead: balTracer.OnColdAccountRead,
+		OnColdStorageRead: balTracer.OnColdStorageRead,
+	}
+	return balTracer, hooks
+}
+
+// AccessList returns the constructed access list
+func (a *BlockAccessListTracer) AccessList() *bal.ConstructionBlockAccessList {
+	return a.callAccessLists[0]
+}
+
+func (a *BlockAccessListTracer) TxEndHook(receipt *types.Receipt, err error) {
+	a.txIdx++
+}
+
+func (a *BlockAccessListTracer) TxStartHook(vm *tracing.VMContext, tx *types.Transaction, from common.Address) {
+	if a.txIdx == 0 {
+		a.txIdx++
+	}
+}
+
+func (a *BlockAccessListTracer) OnEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+	a.callAccessLists = append(a.callAccessLists, bal.NewConstructionBlockAccessList())
+}
+
+func (a *BlockAccessListTracer) OnExit(depth int, output []byte, gasUsed uint64, err error, reverted bool) {
+	// any self-destructed accounts must have been created in the same transaction
+	// so there is no difference between the pre/post tx state of those accounts
+	if a.selfdestructedAccount != nil {
+		delete(a.callAccessLists[len(a.callAccessLists)-1].Accounts, *a.selfdestructedAccount)
+	}
+	if !reverted {
+		parentAccessList := a.callAccessLists[len(a.callAccessLists)-2]
+		scopeAccessList := a.callAccessLists[len(a.callAccessLists)-1]
+		parentAccessList.Merge(scopeAccessList)
+	}
+
+	a.callAccessLists = a.callAccessLists[:len(a.callAccessLists)-1]
+}
+
+func (a *BlockAccessListTracer) OnCodeChange(addr common.Address, prevCodeHash common.Hash, prevCode []byte, codeHash common.Hash, code []byte, reason tracing.CodeChangeReason) {
+	if reason == tracing.CodeChangeSelfDestruct {
+		a.selfdestructedAccount = &addr
+		return
+	}
+	a.callAccessLists[len(a.callAccessLists)-1].CodeChange(addr, uint16(a.txIdx), code)
+}
+
+func (a *BlockAccessListTracer) OnBalanceChange(addr common.Address, prevBalance, newBalance *big.Int, _ tracing.BalanceChangeReason) {
+	a.callAccessLists[len(a.callAccessLists)-1].BalanceChange(a.txIdx, addr, new(uint256.Int).SetBytes(newBalance.Bytes()))
+}
+
+func (a *BlockAccessListTracer) OnNonceChange(addr common.Address, prev uint64, new uint64) {
+	a.callAccessLists[len(a.callAccessLists)-1].NonceChange(addr, a.txIdx, new)
+}
+
+func (a *BlockAccessListTracer) OnColdStorageRead(addr common.Address, key common.Hash) {
+	a.callAccessLists[len(a.callAccessLists)-1].StorageRead(addr, key)
+}
+
+func (a *BlockAccessListTracer) OnColdAccountRead(addr common.Address) {
+	a.callAccessLists[len(a.callAccessLists)-1].AccountRead(addr)
+}
+
+func (a *BlockAccessListTracer) OnStorageChange(addr common.Address, slot common.Hash, prev common.Hash, new common.Hash) {
+	a.callAccessLists[len(a.callAccessLists)-1].StorageWrite(a.txIdx, addr, slot, new)
+}

core/block_validator.go

@@ -111,6 +111,31 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
 		}
 	}
 
+	// block access lists must be present after the Amsterdam hard fork
+	if v.config.IsAmsterdam(block.Number(), block.Time()) {
+		if block.Body().AccessList == nil {
+			return fmt.Errorf("access list not present in block body")
+		} else if block.Header().BlockAccessListHash == nil {
+			return fmt.Errorf("access list hash not present in block header")
+		} else if *block.Header().BlockAccessListHash != block.Body().AccessList.Hash() {
+			return fmt.Errorf("access list hash mismatch.  local: %x. remote: %x\n", block.Body().AccessList.Hash(), *block.Header().BlockAccessListHash)
+		}
+	} else if !v.bc.cfg.EnableBALForTesting {
+		// if --experimental.bal is not enabled, block headers cannot have access list hash and bodies cannot have access lists.
+		if block.Body().AccessList != nil {
+			return fmt.Errorf("access list not allowed in block body if not in amsterdam or --experimental.bal is set")
+		} else if block.Header().BlockAccessListHash != nil {
+			return fmt.Errorf("access list hash in block header not allowed when --experimental.bal is set")
+		}
+	} else {
+		// if --experimental.bal is enabled, the BAL hash is not allowed in the header.
+		// this is in order that Geth can import pre-existing chains augmented with BALs
+		// and not have a hash mismatch.
+		if block.Header().BlockAccessListHash != nil {
+			return fmt.Errorf("access list hash in block header not allowed pre-amsterdam")
+		}
+	}
+
 	// Ancestor block must be known.
 	if !v.bc.HasBlockAndState(block.ParentHash(), block.NumberU64()-1) {
 		if !v.bc.HasBlock(block.ParentHash(), block.NumberU64()-1) {

core/blockchain.go

@@ -197,6 +197,11 @@ type BlockChainConfig struct {
 	// If the value is -1, indexing is disabled.
 	TxLookupLimit int64
 
+	// If EnableBALForTesting is enabled, block access lists will be created as part of
+	// block processing and embedded in the block body.  The block access list hash will
+	// not be set in the header.
+	EnableBALForTesting bool
+
 	// StateSizeTracking indicates whether the state size tracking is enabled.
 	StateSizeTracking bool
 }
@@ -1905,9 +1910,17 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool, makeWitness
 		if parent == nil {
 			parent = bc.GetHeader(block.ParentHash(), block.NumberU64()-1)
 		}
+
+		// construct or verify block access lists if BALs are enabled and
+		// we are post-selfdestruct removal fork.
+		enableBAL := (bc.cfg.EnableBALForTesting && bc.chainConfig.IsCancun(block.Number(), block.Time())) || bc.chainConfig.IsAmsterdam(block.Number(), block.Time())
+		blockHasAccessList := block.Body().AccessList != nil
+		makeBAL := enableBAL && !blockHasAccessList
+		validateBAL := enableBAL && blockHasAccessList
+
 		// The traced section of block import.
 		start := time.Now()
-		res, err := bc.processBlock(parent.Root, block, setHead, makeWitness && len(chain) == 1)
+		res, err := bc.processBlock(parent.Root, block, setHead, makeWitness && len(chain) == 1, makeBAL, validateBAL)
 		if err != nil {
 			return nil, it.index, err
 		}
@@ -1975,7 +1988,7 @@ type blockProcessingResult struct {
 
 // processBlock executes and validates the given block. If there was no error
 // it writes the block and associated state to database.
-func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, setHead bool, makeWitness bool) (_ *blockProcessingResult, blockEndErr error) {
+func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, setHead bool, makeWitness bool, constructBALForTesting bool, validateBAL bool) (bpr *blockProcessingResult, blockEndErr error) {
 	var (
 		err       error
 		startTime = time.Now()
@@ -2071,6 +2084,12 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 		}()
 	}
 
+	var balTracer *BlockAccessListTracer
+	// Process block using the parent state as reference point
+	if constructBALForTesting {
+		balTracer, bc.cfg.VmConfig.Tracer = NewBlockAccessListTracer()
+	}
+
 	// Process block using the parent state as reference point
 	pstart := time.Now()
 	res, err := bc.processor.Process(block, statedb, bc.cfg.VmConfig)
@@ -2087,6 +2106,16 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 	}
 	vtime := time.Since(vstart)
 
+	if constructBALForTesting {
+		// very ugly... deep-copy the block body before setting the block access
+		// list on it to prevent mutating the block instance passed by the caller.
+		existingBody := block.Body()
+		block = block.WithBody(*existingBody)
+		existingBody = block.Body()
+		existingBody.AccessList = balTracer.AccessList().ToEncodingObj()
+		block = block.WithBody(*existingBody)
+	}
+
 	// If witnesses was generated and stateless self-validation requested, do
 	// that now. Self validation should *never* run in production, it's more of
 	// a tight integration to enable running *all* consensus tests through the

core/genesis.go

@@ -67,12 +67,13 @@ type Genesis struct {
 
 	// These fields are used for consensus tests. Please don't use them
 	// in actual genesis blocks.
-	Number        uint64      `json:"number"`
-	GasUsed       uint64      `json:"gasUsed"`
-	ParentHash    common.Hash `json:"parentHash"`
-	BaseFee       *big.Int    `json:"baseFeePerGas"` // EIP-1559
-	ExcessBlobGas *uint64     `json:"excessBlobGas"` // EIP-4844
-	BlobGasUsed   *uint64     `json:"blobGasUsed"`   // EIP-4844
+	Number              uint64       `json:"number"`
+	GasUsed             uint64       `json:"gasUsed"`
+	ParentHash          common.Hash  `json:"parentHash"`
+	BaseFee             *big.Int     `json:"baseFeePerGas"`                 // EIP-1559
+	ExcessBlobGas       *uint64      `json:"excessBlobGas"`                 // EIP-4844
+	BlobGasUsed         *uint64      `json:"blobGasUsed"`                   // EIP-4844
+	BlockAccessListHash *common.Hash `json:"blockAccessListHash,omitempty"` // EIP-7928
 }
 
 // copy copies the genesis.
@@ -122,6 +123,7 @@ func ReadGenesis(db ethdb.Database) (*Genesis, error) {
 	genesis.BaseFee = genesisHeader.BaseFee
 	genesis.ExcessBlobGas = genesisHeader.ExcessBlobGas
 	genesis.BlobGasUsed = genesisHeader.BlobGasUsed
+	genesis.BlockAccessListHash = genesisHeader.BlockAccessListHash
 
 	return &genesis, nil
 }
@@ -461,18 +463,19 @@ func (g *Genesis) ToBlock() *types.Block {
 // toBlockWithRoot constructs the genesis block with the given genesis state root.
 func (g *Genesis) toBlockWithRoot(root common.Hash) *types.Block {
 	head := &types.Header{
-		Number:     new(big.Int).SetUint64(g.Number),
-		Nonce:      types.EncodeNonce(g.Nonce),
-		Time:       g.Timestamp,
-		ParentHash: g.ParentHash,
-		Extra:      g.ExtraData,
-		GasLimit:   g.GasLimit,
-		GasUsed:    g.GasUsed,
-		BaseFee:    g.BaseFee,
-		Difficulty: g.Difficulty,
-		MixDigest:  g.Mixhash,
-		Coinbase:   g.Coinbase,
-		Root:       root,
+		Number:              new(big.Int).SetUint64(g.Number),
+		Nonce:               types.EncodeNonce(g.Nonce),
+		Time:                g.Timestamp,
+		ParentHash:          g.ParentHash,
+		Extra:               g.ExtraData,
+		GasLimit:            g.GasLimit,
+		GasUsed:             g.GasUsed,
+		BaseFee:             g.BaseFee,
+		Difficulty:          g.Difficulty,
+		MixDigest:           g.Mixhash,
+		Coinbase:            g.Coinbase,
+		BlockAccessListHash: g.BlockAccessListHash,
+		Root:                root,
 	}
 	if g.GasLimit == 0 {
 		head.GasLimit = params.GenesisGasLimit

core/tracing/hooks.go

@@ -183,6 +183,12 @@ type (
 	// StorageChangeHook is called when the storage of an account changes.
 	StorageChangeHook = func(addr common.Address, slot common.Hash, prev, new common.Hash)
 
+	// ColdStorageReadHook is called before a previously-unread storage slot is read.
+	ColdStorageReadHook = func(common.Address, common.Hash)
+
+	// ColdAccountReadHook is called before an previously-unread account is read.
+	ColdAccountReadHook = func(address common.Address)
+
 	// LogHook is called when a log is emitted.
 	LogHook = func(log *types.Log)
 
@@ -209,6 +215,7 @@ type Hooks struct {
 	OnSystemCallStart   OnSystemCallStartHook
 	OnSystemCallStartV2 OnSystemCallStartHookV2
 	OnSystemCallEnd     OnSystemCallEndHook
+
 	// State events
 	OnBalanceChange BalanceChangeHook
 	OnNonceChange   NonceChangeHook
@@ -217,6 +224,9 @@ type Hooks struct {
 	OnCodeChangeV2  CodeChangeHookV2
 	OnStorageChange StorageChangeHook
 	OnLog           LogHook
+	//State read events
+	OnColdStorageRead ColdStorageReadHook
+	OnColdAccountRead ColdAccountReadHook
 	// Block hash read
 	OnBlockHashRead BlockHashReadHook
 }