Process blind withdrawals

beacon-chain/core/blocks/error.go

@@ -6,8 +6,3 @@ var errNilSignedWithdrawalMessage = errors.New("nil SignedBLSToExecutionChange m
 var errNilWithdrawalMessage = errors.New("nil BLSToExecutionChange message")
 var errInvalidBLSPrefix = errors.New("withdrawal credential prefix is not a BLS prefix")
 var errInvalidWithdrawalCredentials = errors.New("withdrawal credentials do not match")
-var errInvalidWithdrawalIndex = errors.New("invalid withdrawal index")
-var errInvalidValidatorIndex = errors.New("invalid validator index")
-var errInvalidWithdrawalAmount = errors.New("invalid withdrawal amount")
-var errInvalidExecutionAddress = errors.New("invalid execution address")
-var errInvalidWithdrawalNumber = errors.New("invalid number of withdrawals")

beacon-chain/core/blocks/payload.go

@@ -200,12 +200,9 @@ func ValidatePayload(st state.BeaconState, payload interfaces.ExecutionData) err
 //	    transactions_root=hash_tree_root(payload.transactions),
 //	)
 func ProcessPayload(st state.BeaconState, payload interfaces.ExecutionData) (state.BeaconState, error) {
+	var err error
 	if st.Version() >= version.Capella {
-		withdrawals, err := payload.Withdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get payload withdrawals")
-		}
-		st, err = ProcessWithdrawals(st, withdrawals)
+		st, err = ProcessWithdrawals(st, payload)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not process withdrawals")
 		}
@@ -267,6 +264,13 @@ func ValidatePayloadHeader(st state.BeaconState, header interfaces.ExecutionData
 
 // ProcessPayloadHeader processes the payload header.
 func ProcessPayloadHeader(st state.BeaconState, header interfaces.ExecutionData) (state.BeaconState, error) {
+	var err error
+	if st.Version() >= version.Capella {
+		st, err = ProcessWithdrawals(st, header)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not process withdrawals")
+		}
+	}
 	if err := ValidatePayloadHeaderWhenMergeCompletes(st, header); err != nil {
 		return nil, err
 	}

beacon-chain/core/blocks/withdrawals.go

@@ -2,18 +2,20 @@ package blocks
 
 import (
 	"bytes"
+	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
+	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v3/crypto/hash"
+	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v3/encoding/ssz"
-	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v3/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/runtime/version"
@@ -110,47 +112,59 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 	return val, nil
 }
 
-func ProcessWithdrawals(st state.BeaconState, withdrawals []*enginev1.Withdrawal) (state.BeaconState, error) {
-	expected, err := st.ExpectedWithdrawals()
+func ProcessWithdrawals(st state.BeaconState, executionData interfaces.ExecutionData) (state.BeaconState, error) {
+	expectedWithdrawals, err := st.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}
-	if len(expected) != len(withdrawals) {
-		return nil, errInvalidWithdrawalNumber
-	}
-	for i, withdrawal := range withdrawals {
-		if withdrawal.Index != expected[i].Index {
-			return nil, errInvalidWithdrawalIndex
-		}
-		if withdrawal.ValidatorIndex != expected[i].ValidatorIndex {
-			return nil, errInvalidValidatorIndex
+
+	var wdRoot [32]byte
+	if executionData.IsBlinded() {
+		r, err := executionData.WithdrawalsRoot()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals root")
 		}
-		if !bytes.Equal(withdrawal.Address, expected[i].Address) {
-			return nil, errInvalidExecutionAddress
+		wdRoot = bytesutil.ToBytes32(r)
+	} else {
+		wds, err := executionData.Withdrawals()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals")
 		}
-		if withdrawal.Amount != expected[i].Amount {
-			return nil, errInvalidWithdrawalAmount
+		wdRoot, err = ssz.WithdrawalSliceRoot(hash.CustomSHA256Hasher(), wds, fieldparams.MaxWithdrawalsPerPayload)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals root")
 		}
+	}
+
+	expectedRoot, err := ssz.WithdrawalSliceRoot(hash.CustomSHA256Hasher(), expectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get expected withdrawals root")
+	}
+	if expectedRoot != wdRoot {
+		return nil, fmt.Errorf("expected withdrawals root %#x, got %#x", expectedRoot, wdRoot)
+	}
+
+	for _, withdrawal := range expectedWithdrawals {
 		err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not decrease balance")
 		}
 	}
-	if len(withdrawals) > 0 {
-		if err := st.SetNextWithdrawalIndex(withdrawals[len(withdrawals)-1].Index + 1); err != nil {
+	if len(expectedWithdrawals) > 0 {
+		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
 			return nil, errors.Wrap(err, "could not set next withdrawal index")
 		}
 	}
 	var nextValidatorIndex primitives.ValidatorIndex
-	if uint64(len(withdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
+	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
 		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get next withdrawal validator index")
 		}
 		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
 		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
 	} else {
-		nextValidatorIndex = withdrawals[len(withdrawals)-1].ValidatorIndex + 1
+		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
 		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
 			nextValidatorIndex = 0
 		}