all: simplify requests

cmd/evm/internal/t8ntool/execution.go

@@ -367,28 +367,18 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	var requests [][]byte
 	if chainConfig.IsPrague(vmContext.BlockNumber, vmContext.Time) {
 		requests = [][]byte{}
-		// EIP-6110 deposits
+		// EIP-6110
 		var allLogs []*types.Log
 		for _, receipt := range receipts {
 			allLogs = append(allLogs, receipt.Logs...)
 		}
-		depositRequests, err := core.ParseDepositLogs(allLogs, chainConfig)
+		if err := ParseDepositLogs(&requests, allLogs, p.config); err != nil {
-		if err != nil {
 			return nil, nil, nil, NewError(ErrorEVM, fmt.Errorf("could not parse requests logs: %v", err))
 		}
-		if depositRequests != nil {
+		// EIP-7002
-			requests = append(requests, depositRequests)
+		core.ProcessWithdrawalQueue(&requests, evm)
-		}
+		// EIP-7251
-		// EIP-7002 withdrawals
+		core.ProcessConsolidationQueue(&requests, evm)
-		withdrawalRequests := core.ProcessWithdrawalQueue(evm)
-		if withdrawalRequests != nil {
-			requests = append(requests, withdrawalRequests)
-		}
-		// EIP-7251 consolidations
-		consolidationRequests := core.ProcessConsolidationQueue(evm)
-		if consolidationRequests != nil {
-			requests = append(requests, consolidationRequests)
-		}
 	}
 
 	// Commit block

core/chain_makers.go

@@ -355,26 +355,16 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 			for _, r := range b.receipts {
 				blockLogs = append(blockLogs, r.Logs...)
 			}
-			depositRequests, err := ParseDepositLogs(blockLogs, config)
+			if err := ParseDepositLogs(&requests, blockLogs, config); err != nil {
-			if err != nil {
 				panic(fmt.Sprintf("failed to parse deposit log: %v", err))
 			}
-			if depositRequests != nil {
-				requests = append(requests, depositRequests)
-			}
 			// create EVM for system calls
 			blockContext := NewEVMBlockContext(b.header, cm, &b.header.Coinbase)
 			evm := vm.NewEVM(blockContext, statedb, cm.config, vm.Config{})
-			// EIP-7002 withdrawals
+			// EIP-7002
-			withdrawalRequests := ProcessWithdrawalQueue(evm)
+			ProcessWithdrawalQueue(&requests, evm)
-			if withdrawalRequests != nil {
+			// EIP-7251
-				requests = append(requests, withdrawalRequests)
+			ProcessConsolidationQueue(&requests, evm)
-			}
-			// EIP-7251 consolidations
-			consolidationRequests := ProcessConsolidationQueue(evm)
-			if consolidationRequests != nil {
-				requests = append(requests, consolidationRequests)
-			}
 		}
 		if requests != nil {
 			reqHash := types.CalcRequestsHash(requests)

core/state_processor.go

@@ -107,24 +107,14 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	var requests [][]byte
 	if p.config.IsPrague(block.Number(), block.Time()) {
 		requests = [][]byte{}
-		// EIP-6110 deposits
+		// EIP-6110
-		depositRequests, err := ParseDepositLogs(allLogs, p.config)
+		if err := ParseDepositLogs(&requests, allLogs, p.config); err != nil {
-		if err != nil {
 			return nil, err
 		}
-		if depositRequests != nil {
+		// EIP-7002
-			requests = append(requests, depositRequests)
+		ProcessWithdrawalQueue(&requests, evm)
-		}
+		// EIP-7251
-		// EIP-7002 withdrawals
+		ProcessConsolidationQueue(&requests, evm)
-		withdrawalRequests := ProcessWithdrawalQueue(evm)
-		if withdrawalRequests != nil {
-			requests = append(requests, withdrawalRequests)
-		}
-		// EIP-7251 consolidations
-		consolidationRequests := ProcessConsolidationQueue(evm)
-		if consolidationRequests != nil {
-			requests = append(requests, consolidationRequests)
-		}
 	}
 
 	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
@@ -278,18 +268,32 @@ func ProcessParentBlockHash(prevHash common.Hash, evm *vm.EVM) {
 
 // ProcessWithdrawalQueue calls the EIP-7002 withdrawal queue contract.
 // It returns the opaque request data returned by the contract.
+<<<<<<< HEAD
 func ProcessWithdrawalQueue(evm *vm.EVM) []byte {
 	return processRequestsSystemCall(evm, 0x01, params.WithdrawalQueueAddress)
+=======
+func ProcessWithdrawalQueue(requests *[][]byte, vmenv *vm.EVM, statedb vm.StateDB) {
+	processRequestsSystemCall(requests, vmenv, statedb, 0x01, params.WithdrawalQueueAddress)
+>>>>>>> 7481705901 (all: simplify requests)
 }
 
 // ProcessConsolidationQueue calls the EIP-7251 consolidation queue contract.
 // It returns the opaque request data returned by the contract.
+<<<<<<< HEAD
 func ProcessConsolidationQueue(evm *vm.EVM) []byte {
 	return processRequestsSystemCall(evm, 0x02, params.ConsolidationQueueAddress)
 }
 
 func processRequestsSystemCall(evm *vm.EVM, requestType byte, addr common.Address) []byte {
 	if tracer := evm.Config.Tracer; tracer != nil {
+=======
+func ProcessConsolidationQueue(requests *[][]byte, vmenv *vm.EVM, statedb vm.StateDB) {
+	processRequestsSystemCall(requests, vmenv, statedb, 0x02, params.ConsolidationQueueAddress)
+}
+
+func processRequestsSystemCall(requests *[][]byte, vmenv *vm.EVM, statedb vm.StateDB, requestType byte, addr common.Address) {
+	if tracer := vmenv.Config.Tracer; tracer != nil {
+>>>>>>> 7481705901 (all: simplify requests)
 		if tracer.OnSystemCallStart != nil {
 			tracer.OnSystemCallStart()
 		}
@@ -310,31 +314,31 @@ func processRequestsSystemCall(evm *vm.EVM, requestType byte, addr common.Addres
 	ret, _, _ := evm.Call(vm.AccountRef(msg.From), *msg.To, msg.Data, 30_000_000, common.U2560)
 	evm.StateDB.Finalise(true)
 	if len(ret) == 0 {
-		return nil
+		return // skip empty output
 	}
 
-	// Create withdrawals requestsData with prefix 0x01
+	// Append prefixed requestsData to the requests list.
 	requestsData := make([]byte, len(ret)+1)
 	requestsData[0] = requestType
 	copy(requestsData[1:], ret)
-	return requestsData
+	*requests = append(*requests, requestsData)
 }
 
 // ParseDepositLogs extracts the EIP-6110 deposit values from logs emitted by
 // BeaconDepositContract.
-func ParseDepositLogs(logs []*types.Log, config *params.ChainConfig) ([]byte, error) {
+func ParseDepositLogs(requests *[][]byte, logs []*types.Log, config *params.ChainConfig) error {
 	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)
+				return fmt.Errorf("unable to parse deposit data: %v", err)
 			}
 			deposits = append(deposits, request...)
 		}
 	}
-	if len(deposits) == 1 {
+	if len(deposits) > 1 {
-		deposits = nil
+		*requests = append(*requests, deposits)
 	}
-	return deposits, nil
+	return nil
 }

miner/worker.go

@@ -123,23 +123,13 @@ func (miner *Miner) generateWork(params *generateParams, witness bool) *newPaylo
 	if miner.chainConfig.IsPrague(work.header.Number, work.header.Time) {
 		requests = [][]byte{}
 		// EIP-6110 deposits
-		depositRequests, err := core.ParseDepositLogs(allLogs, miner.chainConfig)
+		if err := core.ParseDepositLogs(&requests, allLogs, miner.chainConfig); err != nil {
-		if err != nil {
 			return &newPayloadResult{err: err}
 		}
-		if depositRequests != nil {
+		// EIP-7002
-			requests = append(requests, depositRequests)
+		core.ProcessWithdrawalQueue(&requests, work.evm)
-		}
-		// EIP-7002 withdrawals
-		withdrawalRequests := core.ProcessWithdrawalQueue(work.evm)
-		if withdrawalRequests != nil {
-			requests = append(requests, withdrawalRequests)
-		}
 		// EIP-7251 consolidations
-		consolidationRequests := core.ProcessConsolidationQueue(work.evm)
+		core.ProcessConsolidationQueue(&requests, work.evm)
-		if consolidationRequests != nil {
-			requests = append(requests, consolidationRequests)
-		}
 	}
 	if requests != nil {
 		reqHash := types.CalcRequestsHash(requests)