Don't pass requests to consensus Finalize (#12425)

Input requests are unused after PR #12370 & #12337

cmd/state/commands/opcode_tracer.go

@@ -740,7 +740,7 @@ func runBlock(engine consensus.Engine, ibs *state.IntraBlockState, txnWriter sta
  if !vmConfig.ReadOnly {
  // Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
  tx := block.Transactions()
- if _, _, _, _, err := engine.FinalizeAndAssemble(chainConfig, header, ibs, tx, block.Uncles(), receipts, block.Withdrawals(), nil, nil, nil, nil, logger); err != nil {
+ if _, _, _, _, err := engine.FinalizeAndAssemble(chainConfig, header, ibs, tx, block.Uncles(), receipts, block.Withdrawals(), nil, nil, nil, logger); err != nil {
 
  return nil, fmt.Errorf("finalize of block %d failed: %w", block.NumberU64(), err)
  }

cmd/state/exec3/historical_trace_worker.go

@@ -174,7 +174,7 @@ func (rw *HistoricalTraceWorker) RunTxTask(txTask *state.TxTask) {
  return core.SysCallContract(contract, data, rw.execArgs.ChainConfig, ibs, header, rw.execArgs.Engine, false /* constCall */)
  }
 
- _, _, _, err := rw.execArgs.Engine.Finalize(rw.execArgs.ChainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, rw.logger)
+ _, _, _, err := rw.execArgs.Engine.Finalize(rw.execArgs.ChainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, rw.chain, syscall, rw.logger)
  if err != nil {
  txTask.Error = err
  }

cmd/state/exec3/state.go

@@ -233,9 +233,9 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask, isMining bool) {
  }
 
  if isMining {
- _, txTask.Txs, txTask.BlockReceipts, _, err = rw.engine.FinalizeAndAssemble(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, nil /*requests */, rw.chain, syscall, nil, rw.logger)
+ _, txTask.Txs, txTask.BlockReceipts, _, err = rw.engine.FinalizeAndAssemble(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, rw.chain, syscall, nil, rw.logger)
  } else {
- _, _, _, err = rw.engine.Finalize(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, nil /*requests*/, rw.chain, syscall, rw.logger)
+ _, _, _, err = rw.engine.Finalize(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, rw.chain, syscall, rw.logger)
  }
  if err != nil {
  txTask.Error = err

cmd/state/exec3/state_recon.go

@@ -332,7 +332,7 @@ func (rw *ReconWorker) runTxTask(txTask *state.TxTask) error {
  syscall := func(contract libcommon.Address, data []byte) ([]byte, error) {
  return core.SysCallContract(contract, data, rw.chainConfig, ibs, header, rw.engine, false /* constCall */)
  }
- if _, _, _, err := rw.engine.Finalize(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, rw.logger); err != nil {
+ if _, _, _, err := rw.engine.Finalize(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, rw.chain, syscall, rw.logger); err != nil {
  if _, readError := rw.stateReader.ReadError(); !readError {
  return fmt.Errorf("finalize of block %d failed: %w", txTask.BlockNum, err)
  }

consensus/aura/aura.go

@@ -706,7 +706,7 @@ func (c *AuRa) applyRewards(header *types.Header, state *state.IntraBlockState,
 
 // word `signal epoch` == word `pending epoch`
 func (c *AuRa) Finalize(config *chain.Config, header *types.Header, state *state.IntraBlockState, txs types.Transactions,
- uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests,
+ uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, logger log.Logger,
 ) (types.Transactions, types.Receipts, types.FlatRequests, error) {
  if err := c.applyRewards(header, state, syscall); err != nil {
@@ -845,8 +845,8 @@ func allHeadersUntil(chain consensus.ChainHeaderReader, from *types.Header, to l
 //}
 
 // FinalizeAndAssemble implements consensus.Engine
-func (c *AuRa) FinalizeAndAssemble(config *chain.Config, header *types.Header, state *state.IntraBlockState, txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests, chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger) (*types.Block, types.Transactions, types.Receipts, types.FlatRequests, error) {
- outTxs, outReceipts, _, err := c.Finalize(config, header, state, txs, uncles, receipts, withdrawals, requests, chain, syscall, logger)
+func (c *AuRa) FinalizeAndAssemble(config *chain.Config, header *types.Header, state *state.IntraBlockState, txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger) (*types.Block, types.Transactions, types.Receipts, types.FlatRequests, error) {
+ outTxs, outReceipts, _, err := c.Finalize(config, header, state, txs, uncles, receipts, withdrawals, chain, syscall, logger)
  if err != nil {
  return nil, nil, nil, nil, err
  }

consensus/clique/clique.go

@@ -380,7 +380,7 @@ func (c *Clique) CalculateRewards(config *chain.Config, header *types.Header, un
 // Finalize implements consensus.Engine, ensuring no uncles are set, nor block
 // rewards given.
 func (c *Clique) Finalize(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests,
+ txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, logger log.Logger,
 ) (types.Transactions, types.Receipts, types.FlatRequests, error) {
  return txs, r, nil, nil
@@ -389,7 +389,7 @@ func (c *Clique) Finalize(config *chain.Config, header *types.Header, state *sta
 // FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set,
 // nor block rewards given, and returns the final block.
 func (c *Clique) FinalizeAndAssemble(chainConfig *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests, chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger,
+ txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger,
 ) (*types.Block, types.Transactions, types.Receipts, types.FlatRequests, error) {
  // Assemble and return the final block for sealing
  return types.NewBlockForAsembling(header, txs, nil, receipts, withdrawals), txs, receipts, nil, nil

consensus/consensus.go

@@ -168,7 +168,7 @@ type EngineWriter interface {
  // Finalize runs any post-transaction state modifications (e.g. block rewards)
  // but does not assemble the block.
  Finalize(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests, chain ChainReader, syscall SystemCall, logger log.Logger,
+ txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, chain ChainReader, syscall SystemCall, logger log.Logger,
  ) (types.Transactions, types.Receipts, types.FlatRequests, error)
 
  // FinalizeAndAssemble runs any post-transaction state modifications (e.g. block
@@ -177,7 +177,7 @@ type EngineWriter interface {
  // Note: The block header and state database might be updated to reflect any
  // consensus rules that happen at finalization (e.g. block rewards).
  FinalizeAndAssemble(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests, chain ChainReader, syscall SystemCall, call Call, logger log.Logger,
+ txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, chain ChainReader, syscall SystemCall, call Call, logger log.Logger,
  ) (*types.Block, types.Transactions, types.Receipts, types.FlatRequests, error)
 
  // Seal generates a new sealing request for the given input block and pushes

consensus/ethash/consensus.go

@@ -567,7 +567,7 @@ func (ethash *Ethash) Initialize(config *chain.Config, chain consensus.ChainHead
 // Finalize implements consensus.Engine, accumulating the block and uncle rewards,
 // setting the final state on the header
 func (ethash *Ethash) Finalize(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests,
+ txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, logger log.Logger,
 ) (types.Transactions, types.Receipts, types.FlatRequests, error) {
  // Accumulate any block and uncle rewards and commit the final state root
@@ -578,12 +578,12 @@ func (ethash *Ethash) Finalize(config *chain.Config, header *types.Header, state
 // FinalizeAndAssemble implements consensus.Engine, accumulating the block and
 // uncle rewards, setting the final state and assembling the block.
 func (ethash *Ethash) FinalizeAndAssemble(chainConfig *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests,
+ txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger,
 ) (*types.Block, types.Transactions, types.Receipts, types.FlatRequests, error) {
 
  // Finalize block
- outTxs, outR, _, err := ethash.Finalize(chainConfig, header, state, txs, uncles, r, withdrawals, requests, chain, syscall, logger)
+ outTxs, outR, _, err := ethash.Finalize(chainConfig, header, state, txs, uncles, r, withdrawals, chain, syscall, logger)
  if err != nil {
  return nil, nil, nil, nil, err
  }

consensus/merge/merge.go

@@ -150,11 +150,11 @@ func (s *Merge) CalculateRewards(config *chain.Config, header *types.Header, unc
 }
 
 func (s *Merge) Finalize(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requestsInBlock types.FlatRequests,
+ txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, logger log.Logger,
 ) (types.Transactions, types.Receipts, types.FlatRequests, error) {
  if !misc.IsPoSHeader(header) {
- return s.eth1Engine.Finalize(config, header, state, txs, uncles, receipts, withdrawals, requestsInBlock, chain, syscall, logger)
+ return s.eth1Engine.Finalize(config, header, state, txs, uncles, receipts, withdrawals, chain, syscall, logger)
  }
 
  rewards, err := s.CalculateRewards(config, header, uncles, syscall)
@@ -214,13 +214,13 @@ func (s *Merge) Finalize(config *chain.Config, header *types.Header, state *stat
 }
 
 func (s *Merge) FinalizeAndAssemble(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests, chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger,
+ txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger,
 ) (*types.Block, types.Transactions, types.Receipts, types.FlatRequests, error) {
  if !misc.IsPoSHeader(header) {
- return s.eth1Engine.FinalizeAndAssemble(config, header, state, txs, uncles, receipts, withdrawals, requests, chain, syscall, call, logger)
+ return s.eth1Engine.FinalizeAndAssemble(config, header, state, txs, uncles, receipts, withdrawals, chain, syscall, call, logger)
  }
  header.RequestsHash = nil
- outTxs, outReceipts, rs, err := s.Finalize(config, header, state, txs, uncles, receipts, withdrawals, requests, chain, syscall, logger)
+ outTxs, outReceipts, rs, err := s.Finalize(config, header, state, txs, uncles, receipts, withdrawals, chain, syscall, logger)
 
  if err != nil {
  return nil, nil, nil, nil, err

core/blockchain.go

@@ -169,7 +169,7 @@ func ExecuteBlockEphemerally(
 
  if !vmConfig.ReadOnly {
  txs := block.Transactions()
- if _, _, _, _, err := FinalizeBlockExecution(engine, stateReader, block.Header(), txs, block.Uncles(), stateWriter, chainConfig, ibs, receipts, block.Withdrawals(), nil /* requests */, chainReader, false, logger); err != nil {
+ if _, _, _, _, err := FinalizeBlockExecution(engine, stateReader, block.Header(), txs, block.Uncles(), stateWriter, chainConfig, ibs, receipts, block.Withdrawals(), chainReader, false, logger); err != nil {
  return nil, err
  }
  }
@@ -321,7 +321,7 @@ func FinalizeBlockExecution(
  header *types.Header, txs types.Transactions, uncles []*types.Header,
  stateWriter state.StateWriter, cc *chain.Config,
  ibs *state.IntraBlockState, receipts types.Receipts,
- withdrawals []*types.Withdrawal, requests types.FlatRequests, chainReader consensus.ChainReader,
+ withdrawals []*types.Withdrawal, chainReader consensus.ChainReader,
  isMining bool,
  logger log.Logger,
 ) (newBlock *types.Block, newTxs types.Transactions, newReceipt types.Receipts, retRequests types.FlatRequests, err error) {
@@ -330,10 +330,10 @@ func FinalizeBlockExecution(
  }
 
  if isMining {
- newBlock, newTxs, newReceipt, retRequests, err = engine.FinalizeAndAssemble(cc, header, ibs, txs, uncles, receipts, withdrawals, requests, chainReader, syscall, nil, logger)
+ newBlock, newTxs, newReceipt, retRequests, err = engine.FinalizeAndAssemble(cc, header, ibs, txs, uncles, receipts, withdrawals, chainReader, syscall, nil, logger)
  } else {
  // var rss types.Requests
- newTxs, newReceipt, retRequests, err = engine.Finalize(cc, header, ibs, txs, uncles, receipts, withdrawals, requests, chainReader, syscall, logger)
+ newTxs, newReceipt, retRequests, err = engine.Finalize(cc, header, ibs, txs, uncles, receipts, withdrawals, chainReader, syscall, logger)
  }
  if err != nil {
  return nil, nil, nil, nil, err

core/chain_makers.go

@@ -368,7 +368,7 @@ func GenerateChain(config *chain.Config, parent *types.Block, engine consensus.E
  txNumIncrement()
  if b.engine != nil {
  // Finalize and seal the block
- if _, _, _, _, err := b.engine.FinalizeAndAssemble(config, b.header, ibs, b.txs, b.uncles, b.receipts, nil, nil, nil, nil, nil, logger); err != nil {
+ if _, _, _, _, err := b.engine.FinalizeAndAssemble(config, b.header, ibs, b.txs, b.uncles, b.receipts, nil, nil, nil, nil, logger); err != nil {
  return nil, nil, fmt.Errorf("call to FinaliseAndAssemble: %w", err)
  }
  // Write state changes to db

core/state/txtask.go

@@ -81,8 +81,7 @@ type TxTask struct {
  // And remove this field if possible - because it will make problems for parallel-execution
  BlockReceipts types.Receipts
 
- Requests types.FlatRequests
- Config *chain.Config
+ Config *chain.Config
 }
 
 func (t *TxTask) CreateReceipt(tx kv.Tx) {

eth/stagedsync/stage_mining_exec.go

@@ -200,7 +200,7 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg
 
  var err error
  var block *types.Block
- block, current.Txs, current.Receipts, current.Requests, err = core.FinalizeBlockExecution(cfg.engine, stateReader, current.Header, current.Txs, current.Uncles, &state.NoopWriter{}, &cfg.chainConfig, ibs, current.Receipts, current.Withdrawals, nil /* requests */, chainReader, true, logger)
+ block, current.Txs, current.Receipts, current.Requests, err = core.FinalizeBlockExecution(cfg.engine, stateReader, current.Header, current.Txs, current.Uncles, &state.NoopWriter{}, &cfg.chainConfig, ibs, current.Receipts, current.Withdrawals, chainReader, true, logger)
  if err != nil {
  return fmt.Errorf("cannot finalize block execution: %s", err)
  }

polygon/bor/bor.go

@@ -1036,7 +1036,7 @@ func (c *Bor) CalculateRewards(config *chain.Config, header *types.Header, uncle
 // Finalize implements consensus.Engine, ensuring no uncles are set, nor block
 // rewards given.
 func (c *Bor) Finalize(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests,
+ txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, logger log.Logger,
 ) (types.Transactions, types.Receipts, types.FlatRequests, error) {
  headerNumber := header.Number.Uint64()
@@ -1045,7 +1045,7 @@ func (c *Bor) Finalize(config *chain.Config, header *types.Header, state *state.
  return nil, nil, nil, consensus.ErrUnexpectedWithdrawals
  }
 
- if requests != nil || header.RequestsHash != nil {
+ if header.RequestsHash != nil {
  return nil, nil, nil, consensus.ErrUnexpectedRequests
  }
 
@@ -1101,7 +1101,7 @@ func (c *Bor) changeContractCodeIfNeeded(headerNumber uint64, state *state.Intra
 // FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set,
 // nor block rewards given, and returns the final block.
 func (c *Bor) FinalizeAndAssemble(chainConfig *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests,
+ txs types.Transactions, uncles []*types.Header, receipts types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, call consensus.Call, logger log.Logger,
 ) (*types.Block, types.Transactions, types.Receipts, types.FlatRequests, error) {
  // stateSyncData := []*types.StateSyncData{}
@@ -1112,7 +1112,7 @@ func (c *Bor) FinalizeAndAssemble(chainConfig *chain.Config, header *types.Heade
  return nil, nil, nil, nil, consensus.ErrUnexpectedWithdrawals
  }
 
- if requests != nil || header.RequestsHash != nil {
+ if header.RequestsHash != nil {
  return nil, nil, nil, nil, consensus.ErrUnexpectedRequests
  }
 

polygon/bor/fake.go

@@ -37,8 +37,8 @@ func NewFaker() *FakeBor {
 }
 
 func (f *FakeBor) Finalize(config *chain.Config, header *types.Header, state *state.IntraBlockState,
- txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal, requests types.FlatRequests,
+ txs types.Transactions, uncles []*types.Header, r types.Receipts, withdrawals []*types.Withdrawal,
  chain consensus.ChainReader, syscall consensus.SystemCall, logger log.Logger,
 ) (types.Transactions, types.Receipts, types.FlatRequests, error) {
- return f.FakeEthash.Finalize(config, header, state, txs, uncles, r, withdrawals, requests, chain, syscall, logger)
+ return f.FakeEthash.Finalize(config, header, state, txs, uncles, r, withdrawals, chain, syscall, logger)
 }