Electra core transition operations

beacon-chain/core/electra/BUILD.bazel

@@ -3,18 +3,22 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "balance_deposits.go",
         "churn.go",
         "consolidations.go",
+        "deposits.go",
+        "effective_balance_updates.go",
+        "registry_updates.go",
         "transition.go",
         "upgrade.go",
         "validator.go",
+        "withdrawals.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra",
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
+        "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
@@ -36,9 +40,9 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "balance_deposits_test.go",
         "churn_test.go",
         "consolidations_test.go",
+        "deposits_test.go",
         "upgrade_test.go",
         "validator_test.go",
     ],

beacon-chain/core/electra/balance_deposits.go → beacon-chain/core/electra/deposits.go

@@ -7,6 +7,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	"go.opencensus.io/trace"
 )
 
@@ -75,3 +76,12 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 		return st.SetDepositBalanceToConsume(availableForProcessing)
 	}
 }
+
+// ProcessDepositReceipts is a function as part of electra to process execution layer deposits
+func ProcessDepositReceipts(ctx context.Context, beaconState state.BeaconState, receipts []*enginev1.DepositReceipt) (state.BeaconState, error) {
+	_, span := trace.StartSpan(ctx, "electra.ProcessDepositReceipts")
+	defer span.End()
+	// TODO: replace with 6110 logic
+	// return b.ProcessDepositReceipts(beaconState, receipts)
+	return beaconState, nil
+}

beacon-chain/core/electra/effective_balance_updates.go

@@ -0,0 +1,29 @@
+package electra
+
+import "github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+
+// ProcessEffectiveBalanceUpdates processes effective balance updates during epoch processing.
+//
+// Spec pseudocode definition:
+//
+//	def process_effective_balance_updates(state: BeaconState) -> None:
+//	    # Update effective balances with hysteresis
+//	    for index, validator in enumerate(state.validators):
+//	        balance = state.balances[index]
+//	        HYSTERESIS_INCREMENT = uint64(EFFECTIVE_BALANCE_INCREMENT // HYSTERESIS_QUOTIENT)
+//	        DOWNWARD_THRESHOLD = HYSTERESIS_INCREMENT * HYSTERESIS_DOWNWARD_MULTIPLIER
+//	        UPWARD_THRESHOLD = HYSTERESIS_INCREMENT * HYSTERESIS_UPWARD_MULTIPLIER
+//	        EFFECTIVE_BALANCE_LIMIT = (
+//	            MAX_EFFECTIVE_BALANCE_EIP7251 if has_compounding_withdrawal_credential(validator)
+//	            else MIN_ACTIVATION_BALANCE
+//	        )
+//
+//	        if (
+//	            balance + DOWNWARD_THRESHOLD < validator.effective_balance
+//	            or validator.effective_balance + UPWARD_THRESHOLD < balance
+//	        ):
+//	            validator.effective_balance = min(balance - balance % EFFECTIVE_BALANCE_INCREMENT, EFFECTIVE_BALANCE_LIMIT)
+func ProcessEffectiveBalanceUpdates(state state.BeaconState) error {
+	// TODO: replace with real implementation
+	return nil
+}

beacon-chain/core/electra/registry_updates.go

@@ -0,0 +1,34 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+)
+
+// ProcessRegistryUpdates rotates validators in and out of active pool.
+// the amount to rotate is determined churn limit.
+//
+// Spec pseudocode definition:
+//
+//		def process_registry_updates(state: BeaconState) -> None:
+//		    # Process activation eligibility and ejections
+//		    for index, validator in enumerate(state.validators):
+//		        if is_eligible_for_activation_queue(validator):
+//		            validator.activation_eligibility_epoch = get_current_epoch(state) + 1
+//
+//		        if (
+//		            is_active_validator(validator, get_current_epoch(state))
+//		            and validator.effective_balance <= EJECTION_BALANCE
+//		        ):
+//		            initiate_validator_exit(state, ValidatorIndex(index))
+//
+//	         # Activate all eligible validators
+//	         activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))
+//	         for validator in state.validators:
+//	             if is_eligible_for_activation(state, validator):
+//	                 validator.activation_epoch = activation_epoch
+func ProcessRegistryUpdates(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+	// TODO: replace with real implementation
+	return state, nil
+}

beacon-chain/core/electra/transition.go

@@ -1,8 +1,15 @@
 package electra
 
 import (
+	"context"
+
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	e "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"go.opencensus.io/trace"
 )
 
 // Re-exports for methods that haven't changed in Electra.
@@ -21,3 +28,98 @@ var (
 	AttestationsDelta                    = altair.AttestationsDelta
 	ProcessSyncAggregate                 = altair.ProcessSyncAggregate
 )
+
+// ProcessEpoch describes the per epoch operations that are performed on the beacon state.
+// It's optimized by pre computing validator attested info and epoch total/attested balances upfront.
+//
+// Spec definition:
+//
+//	def process_epoch(state: BeaconState) -> None:
+//	    process_justification_and_finalization(state)
+//	    process_inactivity_updates(state)
+//	    process_rewards_and_penalties(state)
+//	    process_registry_updates(state)
+//	    process_slashings(state)
+//	    process_eth1_data_reset(state)
+//	    process_pending_balance_deposits(state)  # New in EIP7251
+//	    process_pending_consolidations(state)  # New in EIP7251
+//	    process_effective_balance_updates(state)
+//	    process_slashings_reset(state)
+//	    process_randao_mixes_reset(state)
+func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
+	_, span := trace.StartSpan(ctx, "electra.ProcessEpoch")
+	defer span.End()
+
+	if state == nil || state.IsNil() {
+		return nil, errors.New("nil state")
+	}
+	vp, bp, err := InitializePrecomputeValidators(ctx, state)
+	if err != nil {
+		return nil, err
+	}
+	vp, bp, err = ProcessEpochParticipation(ctx, state, bp, vp)
+	if err != nil {
+		return nil, err
+	}
+	state, err = precompute.ProcessJustificationAndFinalizationPreCompute(state, bp)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process justification")
+	}
+	state, vp, err = ProcessInactivityScores(ctx, state, vp)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process inactivity updates")
+	}
+	state, err = ProcessRewardsAndPenaltiesPrecompute(state, bp, vp)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process rewards and penalties")
+	}
+	state, err = ProcessRegistryUpdates(ctx, state)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process registry updates")
+	}
+	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessSlashings(state, proportionalSlashingMultiplier)
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessEth1DataReset(state)
+	if err != nil {
+		return nil, err
+	}
+	if err = ProcessPendingBalanceDeposits(ctx, state, primitives.Gwei(bp.ActiveCurrentEpoch)); err != nil {
+		return nil, err
+	}
+	if err := ProcessPendingConsolidations(ctx, state); err != nil {
+		return nil, err
+	}
+	if err := ProcessEffectiveBalanceUpdates(state); err != nil {
+		return nil, err
+	}
+	state, err = ProcessSlashingsReset(state)
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessRandaoMixesReset(state)
+	if err != nil {
+		return nil, err
+	}
+	state, err = ProcessHistoricalDataUpdate(state)
+	if err != nil {
+		return nil, err
+	}
+
+	state, err = ProcessParticipationFlagUpdates(state)
+	if err != nil {
+		return nil, err
+	}
+
+	state, err = ProcessSyncCommitteeUpdates(ctx, state)
+	if err != nil {
+		return nil, err
+	}
+
+	return state, nil
+}

beacon-chain/core/electra/withdrawals.go

@@ -0,0 +1,80 @@
+package electra
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+)
+
+// ProcessExecutionLayerWithdrawRequests processes the validator withdrawals from the provided execution payload
+// into the beacon state triggered by the execution layer.
+//
+// Spec pseudocode definition:
+//
+// def process_execution_layer_withdrawal_request(
+//
+//		state: BeaconState,
+//		execution_layer_withdrawal_request: ExecutionLayerWithdrawalRequest
+//
+//	 ) -> None:
+//	   amount = execution_layer_withdrawal_request.amount
+//	   is_full_exit_request = amount == FULL_EXIT_REQUEST_AMOUNT
+//
+//	   # If partial withdrawal queue is full, only full exits are processed
+//	   if len(state.pending_partial_withdrawals) == PENDING_PARTIAL_WITHDRAWALS_LIMIT and not is_full_exit_request:
+//	   return
+//
+//	   validator_pubkeys = [v.pubkey for v in state.validators]
+//	   # Verify pubkey exists
+//	   request_pubkey = execution_layer_withdrawal_request.validator_pubkey
+//	   if request_pubkey not in validator_pubkeys:
+//	   return
+//	   index = ValidatorIndex(validator_pubkeys.index(request_pubkey))
+//	   validator = state.validators[index]
+//
+//	   # Verify withdrawal credentials
+//	   has_correct_credential = has_execution_withdrawal_credential(validator)
+//	   is_correct_source_address = (
+//	    validator.withdrawal_credentials[12:] == execution_layer_withdrawal_request.source_address
+//	   )
+//	   if not (has_correct_credential and is_correct_source_address):
+//	   return
+//	   # Verify the validator is active
+//	   if not is_active_validator(validator, get_current_epoch(state)):
+//	   return
+//	   # Verify exit has not been initiated
+//	   if validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	   return
+//	   # Verify the validator has been active long enough
+//	   if get_current_epoch(state) < validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
+//	   return
+//
+//	   pending_balance_to_withdraw = get_pending_balance_to_withdraw(state, index)
+//
+//	   if is_full_exit_request:
+//	   # Only exit validator if it has no pending withdrawals in the queue
+//	   if pending_balance_to_withdraw == 0:
+//	   initiate_validator_exit(state, index)
+//	   return
+//
+//	   has_sufficient_effective_balance = validator.effective_balance >= MIN_ACTIVATION_BALANCE
+//	   has_excess_balance = state.balances[index] > MIN_ACTIVATION_BALANCE + pending_balance_to_withdraw
+//
+//	   # Only allow partial withdrawals with compounding withdrawal credentials
+//	   if has_compounding_withdrawal_credential(validator) and has_sufficient_effective_balance and has_excess_balance:
+//	   to_withdraw = min(
+//	   state.balances[index] - MIN_ACTIVATION_BALANCE - pending_balance_to_withdraw,
+//	    amount
+//	   )
+//	   exit_queue_epoch = compute_exit_epoch_and_update_churn(state, to_withdraw)
+//	   withdrawable_epoch = Epoch(exit_queue_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
+//	   state.pending_partial_withdrawals.append(PendingPartialWithdrawal(
+//	   index=index,
+//	   amount=to_withdraw,
+//	   withdrawable_epoch=withdrawable_epoch,
+//	   ))
+func ProcessExecutionLayerWithdrawRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.ExecutionLayerWithdrawalRequest) (state.BeaconState, error) {
+	//TODO: replace with real implementation
+	return st, nil
+}

beacon-chain/core/transition/transition.go

@@ -256,14 +256,18 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.
 					tracing.AnnotateError(span, err)
 					return nil, errors.Wrap(err, "could not process epoch with optimizations")
 				}
-			} else if state.Version() >= version.Altair {
+			} else if state.Version() <= version.Deneb {
 				state, err = altair.ProcessEpoch(ctx, state)
 				if err != nil {
 					tracing.AnnotateError(span, err)
-					return nil, errors.Wrap(err, "could not process epoch")
+					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
 				}
 			} else {
-				return nil, errors.New("beacon state should have a version")
+				state, err = electra.ProcessEpoch(ctx, state)
+				if err != nil {
+					tracing.AnnotateError(span, err)
+					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
+				}
 			}
 		}
 		if err := state.SetSlot(state.Slot() + 1); err != nil {