Add block value to validation api

avalonche · avalonche · commit 03a9c503cc55 · 2024-06-25T16:22:43.000+10:00
diff --git a/builder/builder.go b/builder/builder.go
@@ -279,7 +279,7 @@ func (b *Builder) onSealedBlock(opts SubmitBlockOpts) error {
 		case spec.DataVersionCapella:
 			err = b.validator.ValidateBuilderSubmissionV2(&blockvalidation.BuilderBlockValidationRequestV2{SubmitBlockRequest: *versionedBlockRequest.Capella, RegisteredGasLimit: opts.ValidatorData.GasLimit})
 		case spec.DataVersionDeneb:
-			err = b.validator.ValidateBuilderSubmissionV3(&blockvalidation.BuilderBlockValidationRequestV3{SubmitBlockRequest: *versionedBlockRequest.Deneb, RegisteredGasLimit: opts.ValidatorData.GasLimit, ParentBeaconBlockRoot: *opts.Block.BeaconRoot()})
+			_, err = b.validator.ValidateBuilderSubmissionV3(&blockvalidation.BuilderBlockValidationRequestV3{SubmitBlockRequest: *versionedBlockRequest.Deneb, RegisteredGasLimit: opts.ValidatorData.GasLimit, ParentBeaconBlockRoot: *opts.Block.BeaconRoot()})
 		}
 		if err != nil {
 			log.Error("could not validate block", "version", dataVersion.String(), "err", err)
diff --git a/core/blockchain.go b/core/blockchain.go
@@ -2454,31 +2454,31 @@ func (bc *BlockChain) SetBlockValidatorAndProcessorForTesting(v Validator, p Pro
 //   - `useBalanceDiffProfit` if set to false, proposer payment is assumed to be in the last transaction of the block
 //     otherwise we use proposer balance changes after the block to calculate proposer payment (see details in the code)
 //   - `excludeWithdrawals` if set to true, withdrawals to the fee recipient are excluded from the balance change
-func (bc *BlockChain) ValidatePayload(block *types.Block, feeRecipient common.Address, expectedProfit *big.Int, registeredGasLimit uint64, vmConfig vm.Config, useBalanceDiffProfit, excludeWithdrawals bool) error {
+func (bc *BlockChain) ValidatePayload(block *types.Block, feeRecipient common.Address, expectedProfit *big.Int, registeredGasLimit uint64, vmConfig vm.Config, useBalanceDiffProfit, excludeWithdrawals bool) (*uint256.Int, error) {
 	header := block.Header()
 	if err := bc.engine.VerifyHeader(bc, header); err != nil {
-		return err
+		return nil, err
 	}
 
 	current := bc.CurrentBlock()
 	reorg, err := bc.forker.ReorgNeeded(current, header)
 	if err == nil && reorg {
-		return errors.New("block requires a reorg")
+		return nil, errors.New("block requires a reorg")
 	}
 
 	parent := bc.GetHeader(block.ParentHash(), block.NumberU64()-1)
 	if parent == nil {
-		return errors.New("parent not found")
+		return nil, errors.New("parent not found")
 	}
 
 	calculatedGasLimit := CalcGasLimit(parent.GasLimit, registeredGasLimit)
 	if calculatedGasLimit != header.GasLimit {
-		return errors.New("incorrect gas limit set")
+		return nil, errors.New("incorrect gas limit set")
 	}
 
 	statedb, err := bc.StateAt(parent.Root)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// The chain importer is starting and stopping trie prefetchers. If a bad
@@ -2491,7 +2491,7 @@ func (bc *BlockChain) ValidatePayload(block *types.Block, feeRecipient common.Ad
 
 	receipts, _, usedGas, err := bc.processor.Process(block, statedb, vmConfig)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	feeRecipientBalanceDelta := new(uint256.Int).Set(statedb.GetBalance(feeRecipient))
@@ -2507,24 +2507,24 @@ func (bc *BlockChain) ValidatePayload(block *types.Block, feeRecipient common.Ad
 
 	if bc.Config().IsShanghai(header.Number, header.Time) {
 		if header.WithdrawalsHash == nil {
-			return fmt.Errorf("withdrawals hash is missing")
+			return nil, fmt.Errorf("withdrawals hash is missing")
 		}
 		// withdrawals hash and withdrawals validated later in ValidateBody
 	} else {
 		if header.WithdrawalsHash != nil {
-			return fmt.Errorf("withdrawals hash present before shanghai")
+			return nil, fmt.Errorf("withdrawals hash present before shanghai")
 		}
 		if block.Withdrawals() != nil {
-			return fmt.Errorf("withdrawals list present in block body before shanghai")
+			return nil, fmt.Errorf("withdrawals list present in block body before shanghai")
 		}
 	}
 
 	if err := bc.validator.ValidateBody(block); err != nil {
-		return err
+		return nil, err
 	}
 
 	if err := bc.validator.ValidateState(block, statedb, receipts, usedGas); err != nil {
-		return err
+		return nil, err
 	}
 
 	// Validate proposer payment
@@ -2536,56 +2536,61 @@ func (bc *BlockChain) ValidatePayload(block *types.Block, feeRecipient common.Ad
 				if feeRecipientBalanceDelta.Cmp(uint256ExpectedProfit) > 0 {
 					log.Warn("builder claimed profit is lower than calculated profit", "expected", expectedProfit, "actual", feeRecipientBalanceDelta)
 				}
-				return nil
+				return feeRecipientBalanceDelta, nil
 			}
 			log.Warn("proposer payment not enough, trying last tx payment validation", "expected", expectedProfit, "actual", feeRecipientBalanceDelta)
 		}
 	}
 
 	if len(receipts) == 0 {
-		return errors.New("no proposer payment receipt")
+		return nil, errors.New("no proposer payment receipt")
 	}
 
 	lastReceipt := receipts[len(receipts)-1]
 	if lastReceipt.Status != types.ReceiptStatusSuccessful {
-		return errors.New("proposer payment not successful")
+		return nil, errors.New("proposer payment not successful")
 	}
 	txIndex := lastReceipt.TransactionIndex
 	if txIndex+1 != uint(len(block.Transactions())) {
-		return fmt.Errorf("proposer payment index not last transaction in the block (%d of %d)", txIndex, len(block.Transactions())-1)
+		return nil, fmt.Errorf("proposer payment index not last transaction in the block (%d of %d)", txIndex, len(block.Transactions())-1)
 	}
 
 	paymentTx := block.Transaction(lastReceipt.TxHash)
 	if paymentTx == nil {
-		return errors.New("payment tx not in the block")
+		return nil, errors.New("payment tx not in the block")
 	}
 
 	paymentTo := paymentTx.To()
 	if paymentTo == nil || *paymentTo != feeRecipient {
-		return fmt.Errorf("payment tx not to the proposers fee recipient (%v)", paymentTo)
+		return nil, fmt.Errorf("payment tx not to the proposers fee recipient (%v)", paymentTo)
 	}
 
 	if paymentTx.Value().Cmp(expectedProfit) != 0 {
-		return fmt.Errorf("inaccurate payment %s, expected %s", paymentTx.Value().String(), expectedProfit.String())
+		return nil, fmt.Errorf("inaccurate payment %s, expected %s", paymentTx.Value().String(), expectedProfit.String())
 	}
 
 	if len(paymentTx.Data()) != 0 {
-		return fmt.Errorf("malformed proposer payment, contains calldata")
+		return nil, fmt.Errorf("malformed proposer payment, contains calldata")
 	}
 
 	if paymentTx.GasPrice().Cmp(block.BaseFee()) != 0 {
-		return fmt.Errorf("malformed proposer payment, gas price not equal to base fee")
+		return nil, fmt.Errorf("malformed proposer payment, gas price not equal to base fee")
 	}
 
 	if paymentTx.GasTipCap().Cmp(block.BaseFee()) != 0 && paymentTx.GasTipCap().Sign() != 0 {
-		return fmt.Errorf("malformed proposer payment, unexpected gas tip cap")
+		return nil, fmt.Errorf("malformed proposer payment, unexpected gas tip cap")
 	}
 
 	if paymentTx.GasFeeCap().Cmp(block.BaseFee()) != 0 {
-		return fmt.Errorf("malformed proposer payment, unexpected gas fee cap")
+		return nil, fmt.Errorf("malformed proposer payment, unexpected gas fee cap")
 	}
 
-	return nil
+	blockValue, ok := uint256.FromBig(paymentTx.Value())
+	if !ok {
+		return nil, fmt.Errorf("malformed proposer payment, value too large")
+	}
+
+	return blockValue, nil
 }
 
 // SetTrieFlushInterval configures how often in-memory tries are persisted to disk.
diff --git a/eth/block-validation/api.go b/eth/block-validation/api.go
@@ -22,6 +22,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/holiman/uint256"
 )
 
 type BlacklistedAddresses []common.Address
@@ -153,7 +154,8 @@ func (api *BlockValidationAPI) ValidateBuilderSubmissionV1(params *BuilderBlockV
 		return err
 	}
 
-	return api.validateBlock(block, params.Message, params.RegisteredGasLimit)
+	_, err = api.validateBlock(block, params.Message, params.RegisteredGasLimit)
+	return err
 }
 
 type BuilderBlockValidationRequestV2 struct {
@@ -192,7 +194,8 @@ func (api *BlockValidationAPI) ValidateBuilderSubmissionV2(params *BuilderBlockV
 		return err
 	}
 
-	return api.validateBlock(block, params.Message, params.RegisteredGasLimit)
+	_, err = api.validateBlock(block, params.Message, params.RegisteredGasLimit)
+	return err
 }
 
 type BuilderBlockValidationRequestV3 struct {
@@ -201,6 +204,10 @@ type BuilderBlockValidationRequestV3 struct {
 	RegisteredGasLimit    uint64      `json:"registered_gas_limit,string"`
 }
 
+type BuilderBlockValidationResponse struct {
+	BlockValue *uint256.Int `json:"block_value"`
+}
+
 func (r *BuilderBlockValidationRequestV3) UnmarshalJSON(data []byte) error {
 	params := &struct {
 		ParentBeaconBlockRoot common.Hash `json:"parent_beacon_block_root"`
@@ -222,44 +229,44 @@ func (r *BuilderBlockValidationRequestV3) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-func (api *BlockValidationAPI) ValidateBuilderSubmissionV3(params *BuilderBlockValidationRequestV3) error {
+func (api *BlockValidationAPI) ValidateBuilderSubmissionV3(params *BuilderBlockValidationRequestV3) (*BuilderBlockValidationResponse, error) {
 	// TODO: fuzztest, make sure the validation is sound
 	payload := params.ExecutionPayload
 	blobsBundle := params.BlobsBundle
 	log.Info("blobs bundle", "blobs", len(blobsBundle.Blobs), "commits", len(blobsBundle.Commitments), "proofs", len(blobsBundle.Proofs))
 	block, err := engine.ExecutionPayloadV3ToBlock(payload, blobsBundle, params.ParentBeaconBlockRoot)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	err = api.validateBlock(block, params.Message, params.RegisteredGasLimit)
+	blockValue, err := api.validateBlock(block, params.Message, params.RegisteredGasLimit)
 	if err != nil {
 		log.Error("invalid payload", "hash", block.Hash, "number", block.NumberU64(), "parentHash", block.ParentHash, "err", err)
-		return err
+		return nil, err
 	}
 	err = validateBlobsBundle(block.Transactions(), blobsBundle)
 	if err != nil {
 		log.Error("invalid blobs bundle", "err", err)
-		return err
+		return nil, err
 	}
-	return nil
+	return &BuilderBlockValidationResponse{blockValue}, nil
 }
 
-func (api *BlockValidationAPI) validateBlock(block *types.Block, msg *builderApiV1.BidTrace, registeredGasLimit uint64) error {
+func (api *BlockValidationAPI) validateBlock(block *types.Block, msg *builderApiV1.BidTrace, registeredGasLimit uint64) (*uint256.Int, error) {
 	if msg.ParentHash != phase0.Hash32(block.ParentHash()) {
-		return fmt.Errorf("incorrect ParentHash %s, expected %s", msg.ParentHash.String(), block.ParentHash().String())
+		return nil, fmt.Errorf("incorrect ParentHash %s, expected %s", msg.ParentHash.String(), block.ParentHash().String())
 	}
 
 	if msg.BlockHash != phase0.Hash32(block.Hash()) {
-		return fmt.Errorf("incorrect BlockHash %s, expected %s", msg.BlockHash.String(), block.Hash().String())
+		return nil, fmt.Errorf("incorrect BlockHash %s, expected %s", msg.BlockHash.String(), block.Hash().String())
 	}
 
 	if msg.GasLimit != block.GasLimit() {
-		return fmt.Errorf("incorrect GasLimit %d, expected %d", msg.GasLimit, block.GasLimit())
+		return nil, fmt.Errorf("incorrect GasLimit %d, expected %d", msg.GasLimit, block.GasLimit())
 	}
 
 	if msg.GasUsed != block.GasUsed() {
-		return fmt.Errorf("incorrect GasUsed %d, expected %d", msg.GasUsed, block.GasUsed())
+		return nil, fmt.Errorf("incorrect GasUsed %d, expected %d", msg.GasUsed, block.GasUsed())
 	}
 
 	feeRecipient := common.BytesToAddress(msg.ProposerFeeRecipient[:])
@@ -269,33 +276,33 @@ func (api *BlockValidationAPI) validateBlock(block *types.Block, msg *builderApi
 	var tracer *logger.AccessListTracer = nil
 	if api.accessVerifier != nil {
 		if err := api.accessVerifier.isBlacklisted(block.Coinbase()); err != nil {
-			return err
+			return nil, err
 		}
 		if err := api.accessVerifier.isBlacklisted(feeRecipient); err != nil {
-			return err
+			return nil, err
 		}
 		if err := api.accessVerifier.verifyTransactions(types.LatestSigner(api.eth.BlockChain().Config()), block.Transactions()); err != nil {
-			return err
+			return nil, err
 		}
 		isPostMerge := true // the call is PoS-native
 		precompiles := vm.ActivePrecompiles(api.eth.APIBackend.ChainConfig().Rules(new(big.Int).SetUint64(block.NumberU64()), isPostMerge, block.Time()))
 		tracer = logger.NewAccessListTracer(nil, common.Address{}, common.Address{}, precompiles)
 		vmconfig = vm.Config{Tracer: tracer}
 	}
 
-	err := api.eth.BlockChain().ValidatePayload(block, feeRecipient, expectedProfit, registeredGasLimit, vmconfig, api.useBalanceDiffProfit, api.excludeWithdrawals)
+	blockValue, err := api.eth.BlockChain().ValidatePayload(block, feeRecipient, expectedProfit, registeredGasLimit, vmconfig, api.useBalanceDiffProfit, api.excludeWithdrawals)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	if api.accessVerifier != nil && tracer != nil {
 		if err := api.accessVerifier.verifyTraces(tracer); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
 	log.Info("validated block", "hash", block.Hash(), "number", block.NumberU64(), "parentHash", block.ParentHash())
-	return nil
+	return blockValue, nil
 }
 
 func validateBlobsBundle(txs types.Transactions, blobsBundle *builderApiDeneb.BlobsBundle) error {
diff --git a/eth/block-validation/api_test.go b/eth/block-validation/api_test.go
@@ -390,15 +390,20 @@ func TestValidateBuilderSubmissionV3(t *testing.T) {
 		ParentBeaconBlockRoot: common.Hash{42},
 	}
 
-	require.ErrorContains(t, api.ValidateBuilderSubmissionV3(blockRequest), "inaccurate payment")
+	response, err := api.ValidateBuilderSubmissionV3(blockRequest)
+	require.ErrorContains(t, err, "inaccurate payment")
+	require.Nil(t, response)
 	blockRequest.Message.Value = uint256.NewInt(132912184722468)
-	require.NoError(t, api.ValidateBuilderSubmissionV3(blockRequest))
+	response, err = api.ValidateBuilderSubmissionV3(blockRequest)
+	require.NoError(t, err)
+	require.Equal(t, response.BlockValue, uint256.NewInt(132912184722468))
 
 	blockRequest.Message.GasLimit += 1
 	blockRequest.ExecutionPayload.GasLimit += 1
 	updatePayloadHashV3(t, blockRequest)
 
-	require.ErrorContains(t, api.ValidateBuilderSubmissionV3(blockRequest), "incorrect gas limit set")
+	_, err = api.ValidateBuilderSubmissionV3(blockRequest)
+	require.ErrorContains(t, err, "incorrect gas limit set")
 
 	blockRequest.Message.GasLimit -= 1
 	blockRequest.ExecutionPayload.GasLimit -= 1
@@ -411,20 +416,23 @@ func TestValidateBuilderSubmissionV3(t *testing.T) {
 			testAddr: {},
 		},
 	}
-	require.ErrorContains(t, api.ValidateBuilderSubmissionV3(blockRequest), "transaction from blacklisted address 0x71562b71999873DB5b286dF957af199Ec94617F7")
+	_, err = api.ValidateBuilderSubmissionV3(blockRequest)
+	require.ErrorContains(t, err, "transaction from blacklisted address 0x71562b71999873DB5b286dF957af199Ec94617F7")
 
 	// Test tx to blacklisted address
 	api.accessVerifier = &AccessVerifier{
 		blacklistedAddresses: map[common.Address]struct{}{
 			{0x16}: {},
 		},
 	}
-	require.ErrorContains(t, api.ValidateBuilderSubmissionV3(blockRequest), "transaction to blacklisted address 0x1600000000000000000000000000000000000000")
+	_, err = api.ValidateBuilderSubmissionV3(blockRequest)
+	require.ErrorContains(t, err, "transaction to blacklisted address 0x1600000000000000000000000000000000000000")
 
 	api.accessVerifier = nil
 
 	blockRequest.Message.GasUsed = 10
-	require.ErrorContains(t, api.ValidateBuilderSubmissionV3(blockRequest), "incorrect GasUsed 10, expected 119996")
+	_, err = api.ValidateBuilderSubmissionV3(blockRequest)
+	require.ErrorContains(t, err, "incorrect GasUsed 10, expected 119996")
 	blockRequest.Message.GasUsed = execData.GasUsed
 
 	newTestKey, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f290")
@@ -441,7 +449,8 @@ func TestValidateBuilderSubmissionV3(t *testing.T) {
 	copy(invalidPayload.ReceiptsRoot[:], hexutil.MustDecode("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")[:32])
 	blockRequest.ExecutionPayload = invalidPayload
 	updatePayloadHashV3(t, blockRequest)
-	require.ErrorContains(t, api.ValidateBuilderSubmissionV3(blockRequest), "could not apply tx 4", "insufficient funds for gas * price + value")
+	_, err = api.ValidateBuilderSubmissionV3(blockRequest)
+	require.ErrorContains(t, err, "could not apply tx 4", "insufficient funds for gas * price + value")
 }
 
 func updatePayloadHash(t *testing.T, blockRequest *BuilderBlockValidationRequest) {

Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ func (b *Builder) onSealedBlock(opts SubmitBlockOpts) error {`
`279`	`279`	`case spec.DataVersionCapella:`
`280`	`280`	`err = b.validator.ValidateBuilderSubmissionV2(&blockvalidation.BuilderBlockValidationRequestV2{SubmitBlockRequest: *versionedBlockRequest.Capella, RegisteredGasLimit: opts.ValidatorData.GasLimit})`
`281`	`281`	`case spec.DataVersionDeneb:`
`282`		`- err = b.validator.ValidateBuilderSubmissionV3(&blockvalidation.BuilderBlockValidationRequestV3{SubmitBlockRequest: versionedBlockRequest.Deneb, RegisteredGasLimit: opts.ValidatorData.GasLimit, ParentBeaconBlockRoot: opts.Block.BeaconRoot()})`
	`282`	`+ _, err = b.validator.ValidateBuilderSubmissionV3(&blockvalidation.BuilderBlockValidationRequestV3{SubmitBlockRequest: versionedBlockRequest.Deneb, RegisteredGasLimit: opts.ValidatorData.GasLimit, ParentBeaconBlockRoot: opts.Block.BeaconRoot()})`
`283`	`283`	`}`
`284`	`284`	`if err != nil {`
`285`	`285`	`log.Error("could not validate block", "version", dataVersion.String(), "err", err)`
Original file line number	Diff line number	Diff line change
`@@ -2454,31 +2454,31 @@ func (bc *BlockChain) SetBlockValidatorAndProcessorForTesting(v Validator, p Pro`
`2454`	`2454`	// - `useBalanceDiffProfit` if set to false, proposer payment is assumed to be in the last transaction of the block
`2455`	`2455`	`// otherwise we use proposer balance changes after the block to calculate proposer payment (see details in the code)`
`2456`	`2456`	// - `excludeWithdrawals` if set to true, withdrawals to the fee recipient are excluded from the balance change
`2457`		`-func (bc BlockChain) ValidatePayload(block types.Block, feeRecipient common.Address, expectedProfit *big.Int, registeredGasLimit uint64, vmConfig vm.Config, useBalanceDiffProfit, excludeWithdrawals bool) error {`
	`2457`	`+func (bc BlockChain) ValidatePayload(block types.Block, feeRecipient common.Address, expectedProfit big.Int, registeredGasLimit uint64, vmConfig vm.Config, useBalanceDiffProfit, excludeWithdrawals bool) (uint256.Int, error) {`
`2458`	`2458`	`header := block.Header()`
`2459`	`2459`	`if err := bc.engine.VerifyHeader(bc, header); err != nil {`
`2460`		`- return err`
	`2460`	`+ return nil, err`
`2461`	`2461`	`}`
`2462`	`2462`
`2463`	`2463`	`current := bc.CurrentBlock()`
`2464`	`2464`	`reorg, err := bc.forker.ReorgNeeded(current, header)`
`2465`	`2465`	`if err == nil && reorg {`
`2466`		`- return errors.New("block requires a reorg")`
	`2466`	`+ return nil, errors.New("block requires a reorg")`
`2467`	`2467`	`}`
`2468`	`2468`
`2469`	`2469`	`parent := bc.GetHeader(block.ParentHash(), block.NumberU64()-1)`
`2470`	`2470`	`if parent == nil {`
`2471`		`- return errors.New("parent not found")`
	`2471`	`+ return nil, errors.New("parent not found")`
`2472`	`2472`	`}`
`2473`	`2473`
`2474`	`2474`	`calculatedGasLimit := CalcGasLimit(parent.GasLimit, registeredGasLimit)`
`2475`	`2475`	`if calculatedGasLimit != header.GasLimit {`
`2476`		`- return errors.New("incorrect gas limit set")`
	`2476`	`+ return nil, errors.New("incorrect gas limit set")`
`2477`	`2477`	`}`
`2478`	`2478`
`2479`	`2479`	`statedb, err := bc.StateAt(parent.Root)`
`2480`	`2480`	`if err != nil {`
`2481`		`- return err`
	`2481`	`+ return nil, err`
`2482`	`2482`	`}`
`2483`	`2483`
`2484`	`2484`	`// The chain importer is starting and stopping trie prefetchers. If a bad`
`@@ -2491,7 +2491,7 @@ func (bc BlockChain) ValidatePayload(block types.Block, feeRecipient common.Ad`
`2491`	`2491`
`2492`	`2492`	`receipts, _, usedGas, err := bc.processor.Process(block, statedb, vmConfig)`
`2493`	`2493`	`if err != nil {`
`2494`		`- return err`
	`2494`	`+ return nil, err`
`2495`	`2495`	`}`
`2496`	`2496`
`2497`	`2497`	`feeRecipientBalanceDelta := new(uint256.Int).Set(statedb.GetBalance(feeRecipient))`
`@@ -2507,24 +2507,24 @@ func (bc BlockChain) ValidatePayload(block types.Block, feeRecipient common.Ad`
`2507`	`2507`
`2508`	`2508`	`if bc.Config().IsShanghai(header.Number, header.Time) {`
`2509`	`2509`	`if header.WithdrawalsHash == nil {`
`2510`		`- return fmt.Errorf("withdrawals hash is missing")`
	`2510`	`+ return nil, fmt.Errorf("withdrawals hash is missing")`
`2511`	`2511`	`}`
`2512`	`2512`	`// withdrawals hash and withdrawals validated later in ValidateBody`
`2513`	`2513`	`} else {`
`2514`	`2514`	`if header.WithdrawalsHash != nil {`
`2515`		`- return fmt.Errorf("withdrawals hash present before shanghai")`
	`2515`	`+ return nil, fmt.Errorf("withdrawals hash present before shanghai")`
`2516`	`2516`	`}`
`2517`	`2517`	`if block.Withdrawals() != nil {`
`2518`		`- return fmt.Errorf("withdrawals list present in block body before shanghai")`
	`2518`	`+ return nil, fmt.Errorf("withdrawals list present in block body before shanghai")`
`2519`	`2519`	`}`
`2520`	`2520`	`}`
`2521`	`2521`
`2522`	`2522`	`if err := bc.validator.ValidateBody(block); err != nil {`
`2523`		`- return err`
	`2523`	`+ return nil, err`
`2524`	`2524`	`}`
`2525`	`2525`
`2526`	`2526`	`if err := bc.validator.ValidateState(block, statedb, receipts, usedGas); err != nil {`
`2527`		`- return err`
	`2527`	`+ return nil, err`
`2528`	`2528`	`}`
`2529`	`2529`
`2530`	`2530`	`// Validate proposer payment`
`@@ -2536,56 +2536,61 @@ func (bc BlockChain) ValidatePayload(block types.Block, feeRecipient common.Ad`
`2536`	`2536`	`if feeRecipientBalanceDelta.Cmp(uint256ExpectedProfit) > 0 {`
`2537`	`2537`	`log.Warn("builder claimed profit is lower than calculated profit", "expected", expectedProfit, "actual", feeRecipientBalanceDelta)`
`2538`	`2538`	`}`
`2539`		`- return nil`
	`2539`	`+ return feeRecipientBalanceDelta, nil`
`2540`	`2540`	`}`
`2541`	`2541`	`log.Warn("proposer payment not enough, trying last tx payment validation", "expected", expectedProfit, "actual", feeRecipientBalanceDelta)`
`2542`	`2542`	`}`
`2543`	`2543`	`}`
`2544`	`2544`
`2545`	`2545`	`if len(receipts) == 0 {`
`2546`		`- return errors.New("no proposer payment receipt")`
	`2546`	`+ return nil, errors.New("no proposer payment receipt")`
`2547`	`2547`	`}`
`2548`	`2548`
`2549`	`2549`	`lastReceipt := receipts[len(receipts)-1]`
`2550`	`2550`	`if lastReceipt.Status != types.ReceiptStatusSuccessful {`
`2551`		`- return errors.New("proposer payment not successful")`
	`2551`	`+ return nil, errors.New("proposer payment not successful")`
`2552`	`2552`	`}`
`2553`	`2553`	`txIndex := lastReceipt.TransactionIndex`
`2554`	`2554`	`if txIndex+1 != uint(len(block.Transactions())) {`
`2555`		`- return fmt.Errorf("proposer payment index not last transaction in the block (%d of %d)", txIndex, len(block.Transactions())-1)`
	`2555`	`+ return nil, fmt.Errorf("proposer payment index not last transaction in the block (%d of %d)", txIndex, len(block.Transactions())-1)`
`2556`	`2556`	`}`
`2557`	`2557`
`2558`	`2558`	`paymentTx := block.Transaction(lastReceipt.TxHash)`
`2559`	`2559`	`if paymentTx == nil {`
`2560`		`- return errors.New("payment tx not in the block")`
	`2560`	`+ return nil, errors.New("payment tx not in the block")`
`2561`	`2561`	`}`
`2562`	`2562`
`2563`	`2563`	`paymentTo := paymentTx.To()`
`2564`	`2564`	`if paymentTo == nil \|\| *paymentTo != feeRecipient {`
`2565`		`- return fmt.Errorf("payment tx not to the proposers fee recipient (%v)", paymentTo)`
	`2565`	`+ return nil, fmt.Errorf("payment tx not to the proposers fee recipient (%v)", paymentTo)`
`2566`	`2566`	`}`
`2567`	`2567`
`2568`	`2568`	`if paymentTx.Value().Cmp(expectedProfit) != 0 {`
`2569`		`- return fmt.Errorf("inaccurate payment %s, expected %s", paymentTx.Value().String(), expectedProfit.String())`
	`2569`	`+ return nil, fmt.Errorf("inaccurate payment %s, expected %s", paymentTx.Value().String(), expectedProfit.String())`
`2570`	`2570`	`}`
`2571`	`2571`
`2572`	`2572`	`if len(paymentTx.Data()) != 0 {`
`2573`		`- return fmt.Errorf("malformed proposer payment, contains calldata")`
	`2573`	`+ return nil, fmt.Errorf("malformed proposer payment, contains calldata")`
`2574`	`2574`	`}`
`2575`	`2575`
`2576`	`2576`	`if paymentTx.GasPrice().Cmp(block.BaseFee()) != 0 {`
`2577`		`- return fmt.Errorf("malformed proposer payment, gas price not equal to base fee")`
	`2577`	`+ return nil, fmt.Errorf("malformed proposer payment, gas price not equal to base fee")`
`2578`	`2578`	`}`
`2579`	`2579`
`2580`	`2580`	`if paymentTx.GasTipCap().Cmp(block.BaseFee()) != 0 && paymentTx.GasTipCap().Sign() != 0 {`
`2581`		`- return fmt.Errorf("malformed proposer payment, unexpected gas tip cap")`
	`2581`	`+ return nil, fmt.Errorf("malformed proposer payment, unexpected gas tip cap")`
`2582`	`2582`	`}`
`2583`	`2583`
`2584`	`2584`	`if paymentTx.GasFeeCap().Cmp(block.BaseFee()) != 0 {`
`2585`		`- return fmt.Errorf("malformed proposer payment, unexpected gas fee cap")`
	`2585`	`+ return nil, fmt.Errorf("malformed proposer payment, unexpected gas fee cap")`
`2586`	`2586`	`}`
`2587`	`2587`
`2588`		`- return nil`
	`2588`	`+ blockValue, ok := uint256.FromBig(paymentTx.Value())`
	`2589`	`+ if !ok {`
	`2590`	`+ return nil, fmt.Errorf("malformed proposer payment, value too large")`
	`2591`	`+ }`
	`2592`	`+`
	`2593`	`+ return blockValue, nil`
`2589`	`2594`	`}`
`2590`	`2595`
`2591`	`2596`	`// SetTrieFlushInterval configures how often in-memory tries are persisted to disk.`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ import (`
`22`	`22`	`"github.com/ethereum/go-ethereum/log"`
`23`	`23`	`"github.com/ethereum/go-ethereum/node"`
`24`	`24`	`"github.com/ethereum/go-ethereum/rpc"`
	`25`	`+ "github.com/holiman/uint256"`
`25`	`26`	`)`
`26`	`27`
`27`	`28`	`type BlacklistedAddresses []common.Address`
`@@ -153,7 +154,8 @@ func (api BlockValidationAPI) ValidateBuilderSubmissionV1(params BuilderBlockV`
`153`	`154`	`return err`
`154`	`155`	`}`
`155`	`156`
`156`		`- return api.validateBlock(block, params.Message, params.RegisteredGasLimit)`
	`157`	`+ _, err = api.validateBlock(block, params.Message, params.RegisteredGasLimit)`
	`158`	`+ return err`
`157`	`159`	`}`
`158`	`160`
`159`	`161`	`type BuilderBlockValidationRequestV2 struct {`
`@@ -192,7 +194,8 @@ func (api BlockValidationAPI) ValidateBuilderSubmissionV2(params BuilderBlockV`
`192`	`194`	`return err`
`193`	`195`	`}`
`194`	`196`
`195`		`- return api.validateBlock(block, params.Message, params.RegisteredGasLimit)`
	`197`	`+ _, err = api.validateBlock(block, params.Message, params.RegisteredGasLimit)`
	`198`	`+ return err`
`196`	`199`	`}`
`197`	`200`
`198`	`201`	`type BuilderBlockValidationRequestV3 struct {`
`@@ -201,6 +204,10 @@ type BuilderBlockValidationRequestV3 struct {`
`201`	`204`	RegisteredGasLimit uint64 `json:"registered_gas_limit,string"`
`202`	`205`	`}`
`203`	`206`
	`207`	`+type BuilderBlockValidationResponse struct {`
	`208`	+ BlockValue *uint256.Int `json:"block_value"`
	`209`	`+}`
	`210`	`+`
`204`	`211`	`func (r *BuilderBlockValidationRequestV3) UnmarshalJSON(data []byte) error {`
`205`	`212`	`params := &struct {`
`206`	`213`	ParentBeaconBlockRoot common.Hash `json:"parent_beacon_block_root"`
`@@ -222,44 +229,44 @@ func (r *BuilderBlockValidationRequestV3) UnmarshalJSON(data []byte) error {`
`222`	`229`	`return nil`
`223`	`230`	`}`
`224`	`231`
`225`		`-func (api BlockValidationAPI) ValidateBuilderSubmissionV3(params BuilderBlockValidationRequestV3) error {`
	`232`	`+func (api BlockValidationAPI) ValidateBuilderSubmissionV3(params BuilderBlockValidationRequestV3) (*BuilderBlockValidationResponse, error) {`
`226`	`233`	`// TODO: fuzztest, make sure the validation is sound`
`227`	`234`	`payload := params.ExecutionPayload`
`228`	`235`	`blobsBundle := params.BlobsBundle`
`229`	`236`	`log.Info("blobs bundle", "blobs", len(blobsBundle.Blobs), "commits", len(blobsBundle.Commitments), "proofs", len(blobsBundle.Proofs))`
`230`	`237`	`block, err := engine.ExecutionPayloadV3ToBlock(payload, blobsBundle, params.ParentBeaconBlockRoot)`
`231`	`238`	`if err != nil {`
`232`		`- return err`
	`239`	`+ return nil, err`
`233`	`240`	`}`
`234`	`241`
`235`		`- err = api.validateBlock(block, params.Message, params.RegisteredGasLimit)`
	`242`	`+ blockValue, err := api.validateBlock(block, params.Message, params.RegisteredGasLimit)`
`236`	`243`	`if err != nil {`
`237`	`244`	`log.Error("invalid payload", "hash", block.Hash, "number", block.NumberU64(), "parentHash", block.ParentHash, "err", err)`
`238`		`- return err`
	`245`	`+ return nil, err`
`239`	`246`	`}`
`240`	`247`	`err = validateBlobsBundle(block.Transactions(), blobsBundle)`
`241`	`248`	`if err != nil {`
`242`	`249`	`log.Error("invalid blobs bundle", "err", err)`
`243`		`- return err`
	`250`	`+ return nil, err`
`244`	`251`	`}`
`245`		`- return nil`
	`252`	`+ return &BuilderBlockValidationResponse{blockValue}, nil`
`246`	`253`	`}`
`247`	`254`
`248`		`-func (api BlockValidationAPI) validateBlock(block types.Block, msg *builderApiV1.BidTrace, registeredGasLimit uint64) error {`
	`255`	`+func (api BlockValidationAPI) validateBlock(block types.Block, msg builderApiV1.BidTrace, registeredGasLimit uint64) (uint256.Int, error) {`
`249`	`256`	`if msg.ParentHash != phase0.Hash32(block.ParentHash()) {`
`250`		`- return fmt.Errorf("incorrect ParentHash %s, expected %s", msg.ParentHash.String(), block.ParentHash().String())`
	`257`	`+ return nil, fmt.Errorf("incorrect ParentHash %s, expected %s", msg.ParentHash.String(), block.ParentHash().String())`
`251`	`258`	`}`
`252`	`259`
`253`	`260`	`if msg.BlockHash != phase0.Hash32(block.Hash()) {`
`254`		`- return fmt.Errorf("incorrect BlockHash %s, expected %s", msg.BlockHash.String(), block.Hash().String())`
	`261`	`+ return nil, fmt.Errorf("incorrect BlockHash %s, expected %s", msg.BlockHash.String(), block.Hash().String())`
`255`	`262`	`}`
`256`	`263`
`257`	`264`	`if msg.GasLimit != block.GasLimit() {`
`258`		`- return fmt.Errorf("incorrect GasLimit %d, expected %d", msg.GasLimit, block.GasLimit())`
	`265`	`+ return nil, fmt.Errorf("incorrect GasLimit %d, expected %d", msg.GasLimit, block.GasLimit())`
`259`	`266`	`}`
`260`	`267`
`261`	`268`	`if msg.GasUsed != block.GasUsed() {`
`262`		`- return fmt.Errorf("incorrect GasUsed %d, expected %d", msg.GasUsed, block.GasUsed())`
	`269`	`+ return nil, fmt.Errorf("incorrect GasUsed %d, expected %d", msg.GasUsed, block.GasUsed())`
`263`	`270`	`}`
`264`	`271`
`265`	`272`	`feeRecipient := common.BytesToAddress(msg.ProposerFeeRecipient[:])`
`@@ -269,33 +276,33 @@ func (api BlockValidationAPI) validateBlock(block types.Block, msg *builderApi`
`269`	`276`	`var tracer *logger.AccessListTracer = nil`
`270`	`277`	`if api.accessVerifier != nil {`
`271`	`278`	`if err := api.accessVerifier.isBlacklisted(block.Coinbase()); err != nil {`
`272`		`- return err`
	`279`	`+ return nil, err`
`273`	`280`	`}`
`274`	`281`	`if err := api.accessVerifier.isBlacklisted(feeRecipient); err != nil {`
`275`		`- return err`
	`282`	`+ return nil, err`
`276`	`283`	`}`
`277`	`284`	`if err := api.accessVerifier.verifyTransactions(types.LatestSigner(api.eth.BlockChain().Config()), block.Transactions()); err != nil {`
`278`		`- return err`
	`285`	`+ return nil, err`
`279`	`286`	`}`
`280`	`287`	`isPostMerge := true // the call is PoS-native`
`281`	`288`	`precompiles := vm.ActivePrecompiles(api.eth.APIBackend.ChainConfig().Rules(new(big.Int).SetUint64(block.NumberU64()), isPostMerge, block.Time()))`
`282`	`289`	`tracer = logger.NewAccessListTracer(nil, common.Address{}, common.Address{}, precompiles)`
`283`	`290`	`vmconfig = vm.Config{Tracer: tracer}`
`284`	`291`	`}`
`285`	`292`
`286`		`- err := api.eth.BlockChain().ValidatePayload(block, feeRecipient, expectedProfit, registeredGasLimit, vmconfig, api.useBalanceDiffProfit, api.excludeWithdrawals)`
	`293`	`+ blockValue, err := api.eth.BlockChain().ValidatePayload(block, feeRecipient, expectedProfit, registeredGasLimit, vmconfig, api.useBalanceDiffProfit, api.excludeWithdrawals)`
`287`	`294`	`if err != nil {`
`288`		`- return err`
	`295`	`+ return nil, err`
`289`	`296`	`}`
`290`	`297`
`291`	`298`	`if api.accessVerifier != nil && tracer != nil {`
`292`	`299`	`if err := api.accessVerifier.verifyTraces(tracer); err != nil {`
`293`		`- return err`
	`300`	`+ return nil, err`
`294`	`301`	`}`
`295`	`302`	`}`
`296`	`303`
`297`	`304`	`log.Info("validated block", "hash", block.Hash(), "number", block.NumberU64(), "parentHash", block.ParentHash())`
`298`		`- return nil`
	`305`	`+ return blockValue, nil`
`299`	`306`	`}`
`300`	`307`
`301`	`308`	`func validateBlobsBundle(txs types.Transactions, blobsBundle *builderApiDeneb.BlobsBundle) error {`