Block access list changes - BAL construction, execution and validation

cmd/evm/blockrunner.go

@@ -89,7 +89,7 @@ func runBlockTest(ctx *cli.Context, fname string) ([]testResult, error) {
 			continue
 		}
 		result := &testResult{Name: name, Pass: true}
-		if err := tests[name].Run(false, rawdb.PathScheme, ctx.Bool(WitnessCrossCheckFlag.Name), tracer, func(res error, chain *core.BlockChain) {
+		if err := tests[name].Run(false, rawdb.PathScheme, ctx.Bool(WitnessCrossCheckFlag.Name), false, tracer, func(res error, chain *core.BlockChain) {
 			if ctx.Bool(DumpFlag.Name) {
 				if s, _ := chain.State(); s != nil {
 					result.State = dump(s)

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

@@ -966,6 +966,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:     "experimentalbal",
+		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 (
@@ -1852,6 +1860,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
@@ -2244,6 +2254,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_validator.go

@@ -121,6 +121,53 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
 	return nil
 }
 
+// ValidateProcessResult validates block fields against the result of execution.
+// It is used for the purpose of validating access-list-containing blocks and
+// does not check the integrity of the block's state root.
+func (v *BlockValidator) ValidateProcessResult(block *types.Block, resCh chan *ProcessResultWithMetrics, stateless bool) (*ProcessResultWithMetrics, error) {
+	header := block.Header()
+
+	res := <-resCh
+	if res.ProcessResult.Error != nil {
+		return nil, res.ProcessResult.Error
+	}
+
+	if block.GasUsed() != res.ProcessResult.GasUsed {
+		return res, fmt.Errorf("invalid gas used (remote: %d local: %d)", block.GasUsed(), res.ProcessResult.GasUsed)
+	}
+	// Validate the received block's bloom with the one derived from the generated receipts.
+	// For valid blocks this should always validate to true.
+	//
+	// Receipts must go through MakeReceipt to calculate the receipt's bloom
+	// already. Merge the receipt's bloom together instead of recalculating
+	// everything.
+	rbloom := types.MergeBloom(res.ProcessResult.Receipts)
+	if rbloom != header.Bloom {
+		return res, fmt.Errorf("invalid bloom (remote: %x  local: %x)", header.Bloom, rbloom)
+	}
+	// In stateless mode, return early because the receipt and state root are not
+	// provided through the witness, rather the cross validator needs to return it.
+	if stateless {
+		return res, nil
+	}
+	// The receipt Trie's root (R = (Tr [[H1, R1], ... [Hn, Rn]]))
+	receiptSha := types.DeriveSha(res.ProcessResult.Receipts, trie.NewStackTrie(nil))
+	if receiptSha != header.ReceiptHash {
+		return res, fmt.Errorf("invalid receipt root hash (remote: %x local: %x)", header.ReceiptHash, receiptSha)
+	}
+	// Validate the parsed requests match the expected header value.
+	if header.RequestsHash != nil {
+		reqhash := types.CalcRequestsHash(res.ProcessResult.Requests)
+		if reqhash != *header.RequestsHash {
+			return res, fmt.Errorf("invalid requests hash (remote: %x local: %x)", *header.RequestsHash, reqhash)
+		}
+	} else if res.ProcessResult.Requests != nil {
+		return res, errors.New("block has requests before prague fork")
+	}
+
+	return res, nil
+}
+
 // ValidateState validates the various changes that happen after a state transition,
 // such as amount of used gas, the receipt roots and the state root itself.
 func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateDB, res *ProcessResult, stateless bool) error {
@@ -160,6 +207,7 @@ func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateD
 	} else if res.Requests != nil {
 		return errors.New("block has requests before prague fork")
 	}
+
 	// Validate the state root against the received state root and throw
 	// an error if they don't match.
 	if root := statedb.IntermediateRoot(v.config.IsEIP158(header.Number)); header.Root != root {

core/blockchain.go

@@ -99,6 +99,14 @@ var (
 	blockExecutionTimer       = metrics.NewRegisteredResettingTimer("chain/execution", nil)
 	blockWriteTimer           = metrics.NewRegisteredResettingTimer("chain/write", nil)
 
+	// BAL-specific timers
+	blockPreprocessingTimer             = metrics.NewRegisteredResettingTimer("chain/preprocess", nil)
+	blockPreprocessingLoadTimer         = metrics.NewRegisteredResettingTimer("chain/preprocessload", nil)
+	blockPreprocessingDiffCreationTimer = metrics.NewRegisteredResettingTimer("chain/preprocessdiff", nil)
+	txExecutionTimer                    = metrics.NewRegisteredResettingTimer("chain/txexecution", nil)
+	stateRootCalctimer                  = metrics.NewRegisteredResettingTimer("chain/rootcalculation", nil)
+	blockPostprocessingTimer            = metrics.NewRegisteredResettingTimer("chain/postprocess", nil)
+
 	blockReorgMeter     = metrics.NewRegisteredMeter("chain/reorg/executes", nil)
 	blockReorgAddMeter  = metrics.NewRegisteredMeter("chain/reorg/add", nil)
 	blockReorgDropMeter = metrics.NewRegisteredMeter("chain/reorg/drop", nil)
@@ -193,6 +201,9 @@ type BlockChainConfig struct {
 	// If the value is zero, all transactions of the entire chain will be indexed.
 	// 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
 }
 
 // DefaultConfig returns the default config.
@@ -1881,7 +1892,16 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool, makeWitness
 		}
 		// The traced section of block import.
 		start := time.Now()
-		res, err := bc.processBlock(parent.Root, block, setHead, makeWitness && len(chain) == 1)
+
+		blockHasAccessList := block.Body().AccessList != nil
+		// BAL generation/verification is not enabled pre-selfdestruct removal.
+		// TODO: there is a bug where state diff recording will be activated if
+		// cancun is enabled, this should be fixed before merging!
+		forkSupportsBAL := bc.chainConfig.IsCancun(block.Number(), block.Time())
+		makeBAL := forkSupportsBAL && !blockHasAccessList
+		validateBAL := forkSupportsBAL && blockHasAccessList
+
+		res, err := bc.processBlock(parent.Root, block, setHead, makeWitness && len(chain) == 1, makeBAL, validateBAL)
 		if err != nil {
 			return nil, it.index, err
 		}
@@ -1949,7 +1969,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, constructBAL bool, validateBAL bool) (bpr *blockProcessingResult, blockEndErr error) {
 	var (
 		err       error
 		startTime = time.Now()
@@ -1960,6 +1980,9 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 
 	if bc.cfg.NoPrefetch {
 		statedb, err = state.New(parentRoot, bc.statedb)
+		if constructBAL || validateBAL {
+			statedb.EnableStateDiffRecording()
+		}
 		if err != nil {
 			return nil, err
 		}
@@ -1981,6 +2004,9 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 		if err != nil {
 			return nil, err
 		}
+		if constructBAL || validateBAL {
+			statedb.EnableStateDiffRecording()
+		}
 		// Upload the statistics of reader at the end
 		defer func() {
 			stats := prefetch.GetStats()
@@ -1999,7 +2025,10 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 			// Disable tracing for prefetcher executions.
 			vmCfg := bc.cfg.VmConfig
 			vmCfg.Tracer = nil
-			bc.prefetcher.Prefetch(block, throwaway, vmCfg, &interrupt)
+			if block.Body().AccessList == nil {
+				// only use the state prefetcher for non-BAL blocks.
+				bc.prefetcher.Prefetch(block, throwaway, vmCfg, &interrupt)
+			}
 
 			blockPrefetchExecuteTimer.Update(time.Since(start))
 			if interrupt.Load() {
@@ -2008,6 +2037,10 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 		}(time.Now(), throwaway, block)
 	}
 
+	if constructBAL {
+		statedb.EnableBALConstruction()
+	}
+
 	// 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.
@@ -2022,8 +2055,15 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 				return nil, err
 			}
 		}
-		statedb.StartPrefetcher("chain", witness)
-		defer statedb.StopPrefetcher()
+
+		// access-list containing blocks don't use the prefetcher because
+		// state root computation proceeds concurrently with transaction
+		// execution, meaning the prefetcher doesn't have any time to run
+		// before the trie nodes are needed for state root computation.
+		if block.Body().AccessList == nil {
+			statedb.StartPrefetcher("chain", witness)
+			defer statedb.StopPrefetcher()
+		}
 	}
 
 	if bc.logger != nil && bc.logger.OnBlockStart != nil {
@@ -2039,21 +2079,67 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 		}()
 	}
 
-	// Process block using the parent state as reference point
-	pstart := time.Now()
-	res, err := bc.processor.Process(block, statedb, bc.cfg.VmConfig)
-	if err != nil {
-		bc.reportBlock(block, res, err)
-		return nil, err
+	var res *ProcessResult
+	var resWithMetrics *ProcessResultWithMetrics
+	var ptime, vtime time.Duration
+	if block.Body().AccessList != nil {
+		if block.NumberU64() == 0 {
+			return nil, fmt.Errorf("genesis block cannot have a block access list")
+		}
+		if !validateBAL && !bc.chainConfig.IsGlamsterdam(block.Number(), block.Time()) {
+			bc.reportBlock(block, res, fmt.Errorf("received block containing access list before glamsterdam activated"))
+			return nil, err
+		}
+		// Process block using the parent state as reference point
+		pstart := time.Now()
+		var resCh chan *ProcessResultWithMetrics
+		resCh, err = bc.processor.ProcessWithAccessList(block, statedb, bc.cfg.VmConfig)
+		if err != nil {
+			// TODO: okay to pass nil here as execution result?
+			bc.reportBlock(block, nil, err)
+			return nil, err
+		}
+		ptime = time.Since(pstart)
+
+		vstart := time.Now()
+		var err error
+		resWithMetrics, err = bc.validator.ValidateProcessResult(block, resCh, false)
+		if err != nil {
+			// TODO: okay to pass nil here as execution result?
+			bc.reportBlock(block, nil, err)
+			return nil, err
+		}
+		res = resWithMetrics.ProcessResult
+		vtime = time.Since(vstart)
+	} else {
+		// Process block using the parent state as reference point
+		pstart := time.Now()
+		res, err = bc.processor.Process(block, statedb, 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 {
+			bc.reportBlock(block, res, err)
+			return nil, err
+		}
+		vtime = time.Since(vstart)
 	}
-	ptime := time.Since(pstart)
 
-	vstart := time.Now()
-	if err := bc.validator.ValidateState(block, statedb, res, false); err != nil {
-		bc.reportBlock(block, res, err)
-		return nil, err
+	blockHadBAL := block.Body().AccessList != nil
+
+	if constructBAL {
+		// 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 = statedb.ConstructionBlockAccessList().ToEncodingObj()
+		block = block.WithBody(*existingBody)
 	}
-	vtime := time.Since(vstart)
 
 	// If witnesses was generated and stateless self-validation requested, do
 	// that now. Self validation should *never* run in production, it's more of
@@ -2083,26 +2169,39 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 			return nil, fmt.Errorf("stateless self-validation receipt root mismatch (cross: %x local: %x)", crossReceiptRoot, block.ReceiptHash())
 		}
 	}
-	xvtime := time.Since(xvstart)
-	proctime := time.Since(startTime) // processing + validation + cross validation
 
-	// Update the metrics touched during block processing and validation
-	accountReadTimer.Update(statedb.AccountReads) // Account reads are complete(in processing)
-	storageReadTimer.Update(statedb.StorageReads) // Storage reads are complete(in processing)
-	if statedb.AccountLoaded != 0 {
-		accountReadSingleTimer.Update(statedb.AccountReads / time.Duration(statedb.AccountLoaded))
-	}
-	if statedb.StorageLoaded != 0 {
-		storageReadSingleTimer.Update(statedb.StorageReads / time.Duration(statedb.StorageLoaded))
+	var proctime time.Duration
+	if blockHadBAL {
+		blockPreprocessingTimer.Update(resWithMetrics.PreProcessTime)
+		blockPreprocessingLoadTimer.Update(resWithMetrics.PreProcessLoadTime)
+		blockPreprocessingDiffCreationTimer.Update(resWithMetrics.StateDiffCalcTime)
+		txExecutionTimer.Update(resWithMetrics.ExecTime)
+		stateRootCalctimer.Update(resWithMetrics.RootCalcTime)
+		blockPostprocessingTimer.Update(resWithMetrics.PostProcessTime)
+
+		accountHashTimer.Update(statedb.AccountHashes)
+	} else {
+		xvtime := time.Since(xvstart)
+		proctime = time.Since(startTime) // processing + validation + cross validation
+
+		// Update the metrics touched during block processing and validation
+		accountReadTimer.Update(statedb.AccountReads) // Account reads are complete(in processing)
+		storageReadTimer.Update(statedb.StorageReads) // Storage reads are complete(in processing)
+		if statedb.AccountLoaded != 0 {
+			accountReadSingleTimer.Update(statedb.AccountReads / time.Duration(statedb.AccountLoaded))
+		}
+		if statedb.StorageLoaded != 0 {
+			storageReadSingleTimer.Update(statedb.StorageReads / time.Duration(statedb.StorageLoaded))
+		}
+		accountUpdateTimer.Update(statedb.AccountUpdates)                                 // Account updates are complete(in validation)
+		storageUpdateTimer.Update(statedb.StorageUpdates)                                 // Storage updates are complete(in validation)
+		accountHashTimer.Update(statedb.AccountHashes)                                    // Account hashes are complete(in validation)
+		triehash := statedb.AccountHashes                                                 // The time spent on tries hashing
+		trieUpdate := statedb.AccountUpdates + statedb.StorageUpdates                     // The time spent on tries update
+		blockExecutionTimer.Update(ptime - (statedb.AccountReads + statedb.StorageReads)) // The time spent on EVM processing
+		blockValidationTimer.Update(vtime - (triehash + trieUpdate))                      // The time spent on block validation
+		blockCrossValidationTimer.Update(xvtime)                                          // The time spent on stateless cross validation
 	}
-	accountUpdateTimer.Update(statedb.AccountUpdates)                                 // Account updates are complete(in validation)
-	storageUpdateTimer.Update(statedb.StorageUpdates)                                 // Storage updates are complete(in validation)
-	accountHashTimer.Update(statedb.AccountHashes)                                    // Account hashes are complete(in validation)
-	triehash := statedb.AccountHashes                                                 // The time spent on tries hashing
-	trieUpdate := statedb.AccountUpdates + statedb.StorageUpdates                     // The time spent on tries update
-	blockExecutionTimer.Update(ptime - (statedb.AccountReads + statedb.StorageReads)) // The time spent on EVM processing
-	blockValidationTimer.Update(vtime - (triehash + trieUpdate))                      // The time spent on block validation
-	blockCrossValidationTimer.Update(xvtime)                                          // The time spent on stateless cross validation
 
 	// Write the block to the chain and get the status.
 	var (

core/chain_makers.go

@@ -328,11 +328,11 @@ func (b *BlockGen) collectRequests(readonly bool) (requests [][]byte) {
 		blockContext := NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase)
 		evm := vm.NewEVM(blockContext, statedb, b.cm.config, vm.Config{})
 		// EIP-7002
-		if err := ProcessWithdrawalQueue(&requests, evm); err != nil {
+		if _, err := ProcessWithdrawalQueue(&requests, evm); err != nil {
 			panic(fmt.Sprintf("could not process withdrawal requests: %v", err))
 		}
 		// EIP-7251
-		if err := ProcessConsolidationQueue(&requests, evm); err != nil {
+		if _, err := ProcessConsolidationQueue(&requests, evm); err != nil {
 			panic(fmt.Sprintf("could not process consolidation requests: %v", err))
 		}
 	}

core/genesis.go

@@ -681,7 +681,7 @@ func DeveloperGenesisBlock(gasLimit uint64, faucet *common.Address) *Genesis {
 		},
 	}
 	if faucet != nil {
-		genesis.Alloc[*faucet] = types.Account{Balance: new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(9))}
+		genesis.Alloc[*faucet] = types.Account{Balance: new(big.Int).Lsh(big.NewInt(1), 95)}
 	}
 	return genesis
 }