all: update deposit requests format

cmd/evm/internal/t8ntool/execution.go

@@ -385,10 +385,11 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		for _, receipt := range receipts {
 			allLogs = append(allLogs, receipt.Logs...)
 		}
-		requests, err := core.ParseDepositLogs(allLogs, chainConfig)
+		depositRequests, err := core.ParseDepositLogs(allLogs, chainConfig)
 		if err != nil {
 			return nil, nil, nil, NewError(ErrorEVM, fmt.Errorf("could not parse requests logs: %v", err))
 		}
+		requests := [][]byte{depositRequests}
 		// Calculate the requests root
 		h := types.CalcRequestsHash(requests)
 		execRs.RequestsHash = &h

core/chain_makers.go

@@ -349,11 +349,11 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 		var requests [][]byte
 		if config.IsPrague(b.header.Number, b.header.Time) {
 			for _, r := range b.receipts {
-				req, err := ParseDepositLogs(r.Logs, config)
+				depositRequests, err := ParseDepositLogs(r.Logs, config)
 				if err != nil {
 					panic(fmt.Sprintf("failed to parse deposit log: %v", err))
 				}
-				requests = append(requests, req...)
+				requests = append(requests, depositRequests)
 			}
 		}
 

core/state_processor.go

@@ -71,8 +71,9 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	var (
 		context vm.BlockContext
 		signer  = types.MakeSigner(p.config, header.Number, header.Time)
-		err     error
 	)
+
+	// Apply pre-execution system calls.
 	context = NewEVMBlockContext(header, p.chain, nil)
 	vmenv := vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
@@ -81,6 +82,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	if p.config.IsPrague(block.Number(), block.Time()) {
 		ProcessParentBlockHash(block.ParentHash(), vmenv, statedb)
 	}
+
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
 		msg, err := TransactionToMessage(tx, signer, header.BaseFee)
@@ -96,13 +98,15 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		receipts = append(receipts, receipt)
 		allLogs = append(allLogs, receipt.Logs...)
 	}
+
 	// Read requests if Prague is enabled.
 	var requests [][]byte
 	if p.config.IsPrague(block.Number(), block.Time()) {
-		requests, err = ParseDepositLogs(allLogs, p.config)
+		depositRequests, err := ParseDepositLogs(allLogs, p.config)
 		if err != nil {
 			return nil, err
 		}
+		requests = append(requests, depositRequests)
 	}
 
 	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
@@ -262,15 +266,15 @@ func ProcessParentBlockHash(prevHash common.Hash, vmenv *vm.EVM, statedb *state.
 
 // ParseDepositLogs extracts the EIP-6110 deposit values from logs emitted by
 // BeaconDepositContract.
-func ParseDepositLogs(logs []*types.Log, config *params.ChainConfig) ([][]byte, error) {
+func ParseDepositLogs(logs []*types.Log, config *params.ChainConfig) ([]byte, error) {
-	deposits := make([][]byte, 0)
+	deposits := make([]byte, 1) // note: first byte is 0x00 (== deposit request type)
 	for _, log := range logs {
 		if log.Address == config.DepositContractAddress {
 			request, err := types.DepositLogToRequest(log.Data)
 			if err != nil {
 				return nil, fmt.Errorf("unable to parse deposit data: %v", err)
 			}
-			deposits = append(deposits, request)
+			deposits = append(deposits, request...)
 		}
 	}
 	return deposits, nil

eth/catalyst/api.go

@@ -692,8 +692,8 @@ func (api *ConsensusAPI) NewPayloadWithWitnessV4(params engine.ExecutableData, v
 	if params.BlobGasUsed == nil {
 		return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil blobGasUsed post-cancun"))
 	}
-	if params.Deposits == nil {
+	if params.Requests == nil {
-		return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil deposits post-prague"))
+		return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil requests post-prague"))
 	}
 
 	if versionedHashes == nil {
@@ -780,8 +780,8 @@ func (api *ConsensusAPI) ExecuteStatelessPayloadV4(params engine.ExecutableData,
 	if params.BlobGasUsed == nil {
 		return engine.StatelessPayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil blobGasUsed post-cancun"))
 	}
-	if params.Deposits == nil {
+	if params.Requests == nil {
-		return engine.StatelessPayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil deposits post-prague"))
+		return engine.StatelessPayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("nil requests post-prague"))
 	}
 
 	if versionedHashes == nil {
@@ -957,7 +957,7 @@ func (api *ConsensusAPI) executeStatelessPayload(params engine.ExecutableData, v
 			"params.ExcessBlobGas", ebg,
 			"len(params.Transactions)", len(params.Transactions),
 			"len(params.Withdrawals)", len(params.Withdrawals),
-			"len(params.Deposits)", len(params.Deposits),
+			"len(params.Requests)", len(params.Requests),
 			"beaconRoot", beaconRoot,
 			"error", err)
 		errorMsg := err.Error()

miner/worker.go

@@ -116,13 +116,15 @@ func (miner *Miner) generateWork(params *generateParams, witness bool) *newPaylo
 		allLogs = append(allLogs, r.Logs...)
 	}
 	// Read requests if Prague is enabled.
+	var requests [][]byte
 	if miner.chainConfig.IsPrague(work.header.Number, work.header.Time) {
-		requests, err := core.ParseDepositLogs(allLogs, miner.chainConfig)
+		depositRequests, err := core.ParseDepositLogs(allLogs, miner.chainConfig)
 		if err != nil {
 			return &newPayloadResult{err: err}
 		}
-		body.Requests = requests
+		requests = append(requests, depositRequests)
 	}
+	body.Requests = requests
 	block, err := miner.engine.FinalizeAndAssemble(miner.chain, work.header, work.state, &body, work.receipts)
 	if err != nil {
 		return &newPayloadResult{err: err}