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.EnableBAL = 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,76 @@
+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"
+	"math/big"
+)
+
+type AccessListTracer struct {
+	accessList bal.ConstructionBlockAccessList
+
+	curAccessList []*bal.ConstructionBlockAccessList
+	txIdx         int
+
+	lastCallSelfdestructed bool
+}
+
+func (a *AccessListTracer) TxEndHook(receipt *types.Receipt, err error) {
+	a.txIdx++
+}
+
+func (a *AccessListTracer) OnEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+	a.curAccessList = append(a.curAccessList, bal.NewConstructionBlockAccessList())
+}
+
+func (a *AccessListTracer) OnExit(depth int, output []byte, gasUsed uint64, err error, reverted bool) {
+	if a.lastCallSelfdestructed {
+		a.lastCallSelfdestructed = false
+		a.curAccessList = a.curAccessList[:len(a.curAccessList)-1]
+		return
+	}
+	// TODO: can we guarantee that there is a top-most call context we are exiting into here?
+	// i.e. len(a.curAccessList) > 1 ?
+	parentAccessList := a.curAccessList[len(a.curAccessList)-2]
+	scopeAccessList := a.curAccessList[len(a.curAccessList)-1]
+	// TODO: remove the need to directly assign the array here.  looks ugly
+	a.curAccessList[len(a.curAccessList)-2] = parentAccessList.Merge(scopeAccessList)
+	a.curAccessList = a.curAccessList[:len(a.curAccessList)-1]
+}
+
+func (a *AccessListTracer) OnCodeChange(addr common.Address, prevCodeHash common.Hash, prevCode []byte, codeHash common.Hash, code []byte, reason tracing.CodeChangeReason) {
+	if reason == tracing.CodeChangeSelfDestruct {
+		a.lastCallSelfdestructed = true
+		return
+	}
+	a.curAccessList[len(a.curAccessList)-1].CodeChange()
+}
+
+func (a *AccessListTracer) OnBalanceChange(addr common.Address, prev, new *big.Int, _ tracing.BalanceChangeReason) {
+	// TODO: implement this method on the StateDiff object
+	//a.stateDiffs[len(a.stateDiffs)-1].BalanceChange(addr, new)
+}
+
+func (a *AccessListTracer) OnNonceChange(addr common.Address, prev uint64, new uint64) {
+	//a.stateDiffs[len(a.stateDiffs)-1].NonceChange(addr, new)
+}
+
+func (a *AccessListTracer) OnSystemCallStart() {
+	// create a new entry on the state diff stack
+}
+
+func (a *AccessListTracer) OnSystemCallEnd() {
+	// add the contents of the state diff stack to the block access list and clear the state diff stack
+}
+
+func (a *AccessListTracer) OnColdStorageRead(addr common.Address, key common.Hash) {
+	//a.accessList.StorageRead(addr, key)
+}
+
+func (a *AccessListTracer) OnColdAccountRead(addr common.Address) {
+	//a.accessList.AccountRead(addr)
+}
+
+// TODO: figure out if we need the system call hooks?

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.EnableBAL {
+		// 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,9 @@ type BlockChainConfig struct {
 	// If the value is -1, indexing is disabled.
 	TxLookupLimit int64
 
+	// EnableBAL enables block access list creation and verification for post-Cancun blocks which contain access lists.
+	EnableBAL bool
+
 	// StateSizeTracking indicates whether the state size tracking is enabled.
 	StateSizeTracking bool
 }
@@ -1905,9 +1908,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.EnableBAL && 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 +1986,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()
@@ -2034,6 +2045,9 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 		}(time.Now(), throwaway, block)
 	}
 
+	if constructBALForTesting {
+		statedb.EnableStateDiffRecording()
+	}
 	// If we are past Byzantium, enable prefetching to pull in trie node paths
 	// while processing transactions. Before Byzantium the prefetcher is mostly
 	// useless due to the intermediate root hashing after each transaction.
@@ -2071,22 +2085,37 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 		}()
 	}
 
+	// Process block using the parent state as reference point
+	var sdb state.BlockProcessingDB = statedb
+	if constructBALForTesting {
+		sdb = state.NewBlockAccessListBuilder(statedb)
+	}
 	// Process block using the parent state as reference point
 	pstart := time.Now()
-	res, err := bc.processor.Process(block, statedb, bc.cfg.VmConfig)
+	res, err := bc.processor.Process(block, sdb, bc.cfg.VmConfig)
 	if err != nil {
 		bc.reportBlock(block, res, err)
 		return nil, err
 	}
 	ptime := time.Since(pstart)
 
 	vstart := time.Now()
-	if err := bc.validator.ValidateState(block, statedb, res, false); err != nil {
+	if err := bc.validator.ValidateState(block, sdb, res, false); err != nil {
 		bc.reportBlock(block, res, err)
 		return nil, err
 	}
 	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 = sdb.(*state.AccessListCreationDB).ConstructedBlockAccessList().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