EIP-6110: Supply validator deposits on chain

beacon-chain/core/altair/deposit.go

@@ -25,31 +25,10 @@ func ProcessDeposits(
 		if deposit == nil || deposit.Data == nil {
 			return nil, errors.New("got a nil deposit in block")
 		}
-		beaconState, err = ProcessDeposit(beaconState, deposit, batchVerified)
+		beaconState, err = blocks.ProcessDeposit(beaconState, deposit, batchVerified)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
 		}
 	}
 	return beaconState, nil
 }
-
-// ProcessDeposit processes validator deposit for beacon state Altair.
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
-	beaconState, isNewValidator, err := blocks.ProcessDeposit(beaconState, deposit, verifySignature)
-	if err != nil {
-		return nil, err
-	}
-	if isNewValidator {
-		if err := beaconState.AppendInactivityScore(0); err != nil {
-			return nil, err
-		}
-		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return nil, err
-		}
-		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
-			return nil, err
-		}
-	}
-
-	return beaconState, nil
-}

beacon-chain/core/blocks/deposit.go

@@ -15,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
 // ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.
@@ -90,7 +91,7 @@ func ProcessDeposits(
 		if d == nil || d.Data == nil {
 			return nil, errors.New("got a nil deposit in block")
 		}
-		beaconState, _, err = ProcessDeposit(beaconState, d, batchVerified)
+		beaconState, err = ProcessDeposit(beaconState, d, batchVerified)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(d.Data.PublicKey))
 		}
@@ -122,91 +123,193 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 // Spec pseudocode definition:
 // def process_deposit(state: BeaconState, deposit: Deposit) -> None:
 //
-//	# Verify the Merkle branch
-//	assert is_valid_merkle_branch(
-//	    leaf=hash_tree_root(deposit.data),
-//	    branch=deposit.proof,
-//	    depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
-//	    index=state.eth1_deposit_index,
-//	    root=state.eth1_data.deposit_root,
-//	)
+//		# Verify the Merkle branch
+//		assert is_valid_merkle_branch(
+//		    leaf=hash_tree_root(deposit.data),
+//		    branch=deposit.proof,
+//		    depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
+//		    index=state.eth1_deposit_index,
+//		    root=state.eth1_data.deposit_root,
+//		)
 //
-//	# Deposits must be processed in order
-//	state.eth1_deposit_index += 1
+//	 # Deposits must be processed in order
+//	 state.eth1_deposit_index += 1
 //
-//	pubkey = deposit.data.pubkey
-//	amount = deposit.data.amount
-//	validator_pubkeys = [v.pubkey for v in state.validators]
-//	if pubkey not in validator_pubkeys:
-//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
-//	    deposit_message = DepositMessage(
-//	        pubkey=deposit.data.pubkey,
-//	        withdrawal_credentials=deposit.data.withdrawal_credentials,
-//	        amount=deposit.data.amount,
-//	    )
-//	    domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
-//	    signing_root = compute_signing_root(deposit_message, domain)
-//	    if not bls.Verify(pubkey, signing_root, deposit.data.signature):
-//	        return
-//
-//	    # Add validator and balance entries
-//	    state.validators.append(get_validator_from_deposit(state, deposit))
-//	    state.balances.append(amount)
-//	else:
-//	    # Increase balance by deposit amount
-//	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
-//	    increase_balance(state, index, amount)
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, bool, error) {
-	var newValidator bool
+//	 apply_deposit(
+//	  state=state,
+//	  pubkey=deposit.data.pubkey,
+//	  withdrawal_credentials=deposit.data.withdrawal_credentials,
+//	  amount=deposit.data.amount,
+//	  signature=deposit.data.signature,
+//	 )
+func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
 	if err := verifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
-			return nil, newValidator, err
+			return nil, err
 		}
-		return nil, newValidator, errors.Wrapf(err, "could not verify deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
+		return nil, errors.Wrapf(err, "could not verify deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
 	}
 	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
-		return nil, newValidator, err
+		return nil, err
 	}
-	pubKey := deposit.Data.PublicKey
-	amount := deposit.Data.Amount
+	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
+}
+
+// ApplyDeposit
+// def apply_deposit(state: BeaconState, pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> None:
+// validator_pubkeys = [v.pubkey for v in state.validators]
+// if pubkey not in validator_pubkeys:
+//
+//	# Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
+//	  add_validator_to_registry(state, pubkey, withdrawal_credentials, amount)
+//
+// else:
+//
+//	# Increase balance by deposit amount
+//	index = ValidatorIndex(validator_pubkeys.index(pubkey))
+//	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [Modified in Electra:EIP-7251]
+//	# Check if valid deposit switch to compounding credentials
+//
+// if ( is_compounding_withdrawal_credential(withdrawal_credentials) and has_eth1_withdrawal_credential(state.validators[index])
+//
+//	 and is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature)
+//	):
+//	 switch_to_compounding_validator(state, index)
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
+	pubKey := data.PublicKey
+	amount := data.Amount
+	withdrawalCredentials := data.WithdrawalCredentials
 	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
 		if verifySignature {
-			domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+			valid, err := IsValidDepositSignature(data)
 			if err != nil {
-				return nil, newValidator, err
+				return nil, err
 			}
-			if err := verifyDepositDataSigningRoot(deposit.Data, domain); err != nil {
-				// Ignore this error as in the spec pseudo code.
-				log.WithError(err).Debug("Skipping deposit: could not verify deposit data signature")
-				return beaconState, newValidator, nil
+			if !valid {
+				return beaconState, nil
 			}
 		}
-
-		effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
-		if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
-			effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
+			return nil, err
+		}
+	} else {
+		if beaconState.Version() >= version.Electra {
+			//if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
+			//		return nil, newValidator, err
+			//	}
+			// if ( is_compounding_withdrawal_credential(withdrawal_credentials) and has_eth1_withdrawal_credential(state.validators[index])
+			//
+			//	 and is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature)
+			//	):
+			//	 switch_to_compounding_validator(state, index)
+		} else {
+			if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
+				return nil, err
+			}
 		}
-		if err := beaconState.AppendValidator(&ethpb.Validator{
-			PublicKey:                  pubKey,
-			WithdrawalCredentials:      deposit.Data.WithdrawalCredentials,
-			ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
-			ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
-			ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-			WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance:           effectiveBalance,
-		}); err != nil {
-			return nil, newValidator, err
+	}
+
+	return beaconState, nil
+}
+
+// AddValidatorToRegistry
+// def add_validator_to_registry(state: BeaconState,
+//
+//	                          pubkey: BLSPubkey,
+//	                          withdrawal_credentials: Bytes32,
+//	                          amount: uint64) -> None:
+//	index = get_index_for_new_validator(state)
+//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
+//	set_or_append_list(state.validators, index, validator)
+//	set_or_append_list(state.balances, index, 0)  # [Modified in Electra:EIP7251]
+//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000))
+//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000))
+//	set_or_append_list(state.inactivity_scores, index, uint64(0))
+//	state.pending_balance_deposits.append(PendingBalanceDeposit(index=index, amount=amount))  # [New in Electra:EIP7251]
+func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
+	val := GetValidatorFromDeposit(beaconState.Version(), pubKey, withdrawalCredentials, amount)
+	if err := beaconState.AppendValidator(val); err != nil {
+		return err
+	}
+	if beaconState.Version() >= version.Electra {
+		if err := beaconState.AppendBalance(0); err != nil {
+			return err
 		}
-		newValidator = true
+		// In specs this function is at the end function
+		//	if err := beaconState.AppendPendingBalanceDeposit(index, amount); err != nil {
+		//		return nil, newValidator, err
+		//	}
+	} else {
 		if err := beaconState.AppendBalance(amount); err != nil {
-			return nil, newValidator, err
+			return err
 		}
-	} else if err := helpers.IncreaseBalance(beaconState, index, amount); err != nil {
-		return nil, newValidator, err
 	}
 
-	return beaconState, newValidator, nil
+	if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
+		return err
+	}
+	if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
+		return err
+	}
+	return beaconState.AppendInactivityScore(0)
+}
+
+// GetValidatorFromDeposit gets a new validator object with provided paramaters
+//
+// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32) -> Validator:
+//
+//	return Validator(
+//	pubkey=pubkey,
+//	withdrawal_credentials=withdrawal_credentials,
+//	activation_eligibility_epoch=FAR_FUTURE_EPOCH,
+//	activation_epoch=FAR_FUTURE_EPOCH,
+//	exit_epoch=FAR_FUTURE_EPOCH,
+//	withdrawable_epoch=FAR_FUTURE_EPOCH,
+//	effective_balance=0,  # [Modified in Electra:EIP7251]
+//
+// )
+func GetValidatorFromDeposit(stateVersion int, pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
+	var effectiveBalance uint64
+	if stateVersion >= version.Electra {
+		effectiveBalance = 0 // [Modified in Electra:EIP7251]
+	} else {
+		effectiveBalance = amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
+		if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
+			effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+		}
+	}
+
+	return &ethpb.Validator{
+		PublicKey:                  pubKey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           effectiveBalance,
+	}
+}
+
+// IsValidDepositSignature returns whether deposit_data is valid
+// def is_valid_deposit_signature(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, signature: BLSSignature) -> bool:
+//
+//	deposit_message = DepositMessage( pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, amount=amount, )
+//	domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
+//	signing_root = compute_signing_root(deposit_message, domain)
+//	return bls.Verify(pubkey, signing_root, signature)
+func IsValidDepositSignature(data *ethpb.Deposit_Data) (bool, error) {
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	if err != nil {
+		return false, err
+	}
+	if err := verifyDepositDataSigningRoot(data, domain); err != nil {
+		// Ignore this error as in the spec pseudo code.
+		log.WithError(err).Debug("Skipping deposit: could not verify deposit data signature")
+		return false, nil
+	}
+	return true, nil
 }
 
 func verifyDeposit(beaconState state.ReadOnlyBeaconState, deposit *ethpb.Deposit) error {

beacon-chain/core/electra/deposit.go

@@ -0,0 +1,40 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+func ProcessDepositReceipts(ctx context.Context, beaconState state.BeaconState, receipts []*enginev1.DepositReceipt) (state.BeaconState, error) {
+	if beaconState.Version() < version.Electra {
+		return beaconState, nil
+	}
+	//	# Set deposit receipt start index
+	//	if state.deposit_receipts_start_index == UNSET_DEPOSIT_RECEIPTS_START_INDEX:
+	//	state.deposit_receipts_start_index = deposit_receipt.index
+	//
+	//	apply_deposit(
+	//		state=state,
+	//		pubkey=deposit_receipt.pubkey,
+	//		withdrawal_credentials=deposit_receipt.withdrawal_credentials,
+	//		amount=deposit_receipt.amount,
+	//		signature=deposit_receipt.signature,
+	//)
+	deposits := make([]*eth.Deposit, len(receipts))
+	for i, receipt := range receipts {
+		deposits[i] = &eth.Deposit{
+			Data: &eth.Deposit_Data{
+				PublicKey:             bytesutil.SafeCopyBytes(receipt.Pubkey),
+				WithdrawalCredentials: bytesutil.SafeCopyBytes(receipt.WithdrawalCredentials),
+				Signature:             bytesutil.SafeCopyBytes(receipt.Signature),
+			},
+		}
+	}
+	return altair.ProcessDeposits(ctx, beaconState, deposits)
+}

beacon-chain/core/transition/transition.go

@@ -366,13 +366,16 @@ func VerifyOperationLengths(_ context.Context, state state.BeaconState, b interf
 		return nil, errors.New("nil eth1data in state")
 	}
 	if state.Eth1DepositIndex() > eth1Data.DepositCount {
-		return nil, fmt.Errorf("expected state.deposit_index %d <= eth1data.deposit_count %d", state.Eth1DepositIndex(), eth1Data.DepositCount)
-	}
-	maxDeposits := math.Min(params.BeaconConfig().MaxDeposits, eth1Data.DepositCount-state.Eth1DepositIndex())
-	// Verify outstanding deposits are processed up to max number of deposits
-	if uint64(len(body.Deposits())) != maxDeposits {
-		return nil, fmt.Errorf("incorrect outstanding deposits in block body, wanted: %d, got: %d",
-			maxDeposits, len(body.Deposits()))
+		if len(body.Deposits()) != 0 {
+			return nil, fmt.Errorf("expected no deposits, but got %d", len(body.Deposits()))
+		}
+	} else {
+		maxDeposits := math.Min(params.BeaconConfig().MaxDeposits, eth1Data.DepositCount-state.Eth1DepositIndex())
+		// Verify outstanding deposits are processed up to max number of deposits
+		if uint64(len(body.Deposits())) != maxDeposits {
+			return nil, fmt.Errorf("incorrect outstanding deposits in block body, wanted: %d, got: %d",
+				maxDeposits, len(body.Deposits()))
+		}
 	}
 
 	return state, nil