Replace Validator Status Code With Activation/Exit Slot

beacon-chain/chaintest/backend/simulated_backend.go

@@ -69,7 +69,7 @@ func (sb *SimulatedBackend) RunChainTest(testCase *ChainTestCase) error {
 	validators := make([]*pb.ValidatorRecord, testCase.Config.ValidatorCount)
 	for i := uint64(0); i < testCase.Config.ValidatorCount; i++ {
 		validators[i] = &pb.ValidatorRecord{
-			Status:                 pb.ValidatorRecord_ACTIVE,
+			ExitSlot:               params.BeaconConfig().EntryExitDelay,
 			Balance:                c.MaxDeposit * c.Gwei,
 			Pubkey:                 []byte{},
 			RandaoCommitmentHash32: randaoReveal[:],

beacon-chain/core/attestations/attestation.go

@@ -48,7 +48,7 @@ func VerifyProposerAttestation(att *pb.AttestationData, pubKey [32]byte, propose
 		att.Slot,
 		proposerShardID,
 		att.JustifiedSlot,
-		params.BeaconConfig().InitialForkVersion,
+		params.BeaconConfig().GenesisForkVersion,
 	)
 	_ = attestationMsg
 	_ = pubKey

beacon-chain/core/balances/rewards_penalties.go

@@ -85,7 +85,7 @@ func FFGSrcRewardsPenalties(
 				totalBalance
 	}
 
-	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry)
+	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry, state.Slot)
 	didNotAttestIndices := slices.Not(justifiedAttesterIndices, allValidatorIndices)
 
 	for _, index := range didNotAttestIndices {
@@ -122,7 +122,7 @@ func FFGTargetRewardsPenalties(
 				totalBalance
 	}
 
-	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry)
+	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry, state.Slot)
 	didNotAttestIndices := slices.Not(boundaryAttesterIndices, allValidatorIndices)
 
 	for _, index := range didNotAttestIndices {
@@ -159,7 +159,7 @@ func ChainHeadRewardsPenalties(
 				totalBalance
 	}
 
-	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry)
+	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry, state.Slot)
 	didNotAttestIndices := slices.Not(headAttesterIndices, allValidatorIndices)
 
 	for _, index := range didNotAttestIndices {
@@ -211,7 +211,7 @@ func InactivityFFGSrcPenalties(
 	epochsSinceFinality uint64) *pb.BeaconState {
 
 	baseRewardQuotient := baseRewardQuotient(totalBalance)
-	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry)
+	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry, state.Slot)
 	didNotAttestIndices := slices.Not(justifiedAttesterIndices, allValidatorIndices)
 
 	for _, index := range didNotAttestIndices {
@@ -235,7 +235,7 @@ func InactivityFFGTargetPenalties(
 	epochsSinceFinality uint64) *pb.BeaconState {
 
 	baseRewardQuotient := baseRewardQuotient(totalBalance)
-	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry)
+	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry, state.Slot)
 	didNotAttestIndices := slices.Not(boundaryAttesterIndices, allValidatorIndices)
 
 	for _, index := range didNotAttestIndices {
@@ -258,7 +258,7 @@ func InactivityHeadPenalties(
 	totalBalance uint64) *pb.BeaconState {
 
 	baseRewardQuotient := baseRewardQuotient(totalBalance)
-	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry)
+	allValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry, state.Slot)
 	didNotAttestIndices := slices.Not(headAttesterIndices, allValidatorIndices)
 
 	for _, index := range didNotAttestIndices {
@@ -272,19 +272,19 @@ func InactivityHeadPenalties(
 // to inactive validators with status EXITED_WITH_PENALTY.
 //
 // Spec pseudocode definition:
-//    Any validator index with status == EXITED_WITH_PENALTY,
+//    Any active_validator index with validator.penalized_slot <= state.slot,
 //    loses 2 * inactivity_penalty(state, index, epochs_since_finality) +
-//    base_reward(state, index)
+//    base_reward(state, index).
 func InactivityExitedPenalties(
 	state *pb.BeaconState,
 	totalBalance uint64,
 	epochsSinceFinality uint64) *pb.BeaconState {
 
 	baseRewardQuotient := baseRewardQuotient(totalBalance)
-	allValidatorIndices := validators.AllValidatorsIndices(state)
+	activeValidatorIndices := validators.ActiveValidatorIndices(state.ValidatorRegistry, state.Slot)
 
-	for _, index := range allValidatorIndices {
-		if state.ValidatorRegistry[index].Status == pb.ValidatorRecord_EXITED_WITH_PENALTY {
+	for _, index := range activeValidatorIndices {
+		if state.ValidatorRegistry[index].PenalizedSlot <= state.Slot {
 			state.ValidatorBalances[index] -=
 				2*inactivityPenalty(state, index, baseRewardQuotient, epochsSinceFinality) +
 					baseReward(state, index, baseRewardQuotient)

beacon-chain/core/balances/rewards_penalties_test.go

@@ -103,10 +103,10 @@ func TestFFGSrcRewardsPenalties(t *testing.T) {
 		}
 		state := &pb.BeaconState{
 			ValidatorRegistry: []*pb.ValidatorRecord{
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
 			},
 			ValidatorBalances: validatorBalances,
 		}
@@ -142,10 +142,10 @@ func TestFFGTargetRewardsPenalties(t *testing.T) {
 		}
 		state := &pb.BeaconState{
 			ValidatorRegistry: []*pb.ValidatorRecord{
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
 			},
 			ValidatorBalances: validatorBalances,
 		}
@@ -181,10 +181,10 @@ func TestChainHeadRewardsPenalties(t *testing.T) {
 		}
 		state := &pb.BeaconState{
 			ValidatorRegistry: []*pb.ValidatorRecord{
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
 			},
 			ValidatorBalances: validatorBalances,
 		}
@@ -297,10 +297,10 @@ func TestInactivityFFGSrcPenalty(t *testing.T) {
 		}
 		state := &pb.BeaconState{
 			ValidatorRegistry: []*pb.ValidatorRecord{
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
 			},
 			ValidatorBalances: validatorBalances,
 		}
@@ -336,10 +336,10 @@ func TestInactivityFFGTargetPenalty(t *testing.T) {
 		}
 		state := &pb.BeaconState{
 			ValidatorRegistry: []*pb.ValidatorRecord{
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
 			},
 			ValidatorBalances: validatorBalances,
 		}
@@ -372,10 +372,10 @@ func TestInactivityHeadPenalty(t *testing.T) {
 		}
 		state := &pb.BeaconState{
 			ValidatorRegistry: []*pb.ValidatorRecord{
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
-				{Status: pb.ValidatorRecord_ACTIVE_PENDING_EXIT},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
 			},
 			ValidatorBalances: validatorBalances,
 		}
@@ -407,10 +407,10 @@ func TestInactivityExitedPenality(t *testing.T) {
 		}
 		state := &pb.BeaconState{
 			ValidatorRegistry: []*pb.ValidatorRecord{
-				{Status: pb.ValidatorRecord_EXITED_WITH_PENALTY},
-				{Status: pb.ValidatorRecord_EXITED_WITH_PENALTY},
-				{Status: pb.ValidatorRecord_EXITED_WITH_PENALTY},
-				{Status: pb.ValidatorRecord_EXITED_WITH_PENALTY}},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot},
+				{ExitSlot: params.BeaconConfig().FarFutureSlot}},
 			ValidatorBalances: validatorBalances,
 		}
 		state = InactivityExitedPenalties(

beacon-chain/core/blocks/block.go

@@ -29,7 +29,7 @@ func Hash(block *pb.BeaconBlock) ([32]byte, error) {
 // NewGenesisBlock returns the canonical, genesis block for the beacon chain protocol.
 func NewGenesisBlock(stateRoot []byte) *pb.BeaconBlock {
 	block := &pb.BeaconBlock{
-		Slot:               params.BeaconConfig().InitialSlotNumber,
+		Slot:               params.BeaconConfig().GenesisSlot,
 		ParentRootHash32:   params.BeaconConfig().ZeroHash[:],
 		StateRootHash32:    stateRoot,
 		RandaoRevealHash32: params.BeaconConfig().ZeroHash[:],
@@ -148,7 +148,7 @@ func EncodeDepositData(
 		return nil, fmt.Errorf("failed to encode deposit input: %v", err)
 	}
 	encodedInput := wBuf.Bytes()
-	depositData := make([]byte,0,16+len(encodedInput))
+	depositData := make([]byte, 0, 16+len(encodedInput))
 
 	value := make([]byte, 8)
 	binary.BigEndian.PutUint64(value, depositValue)

beacon-chain/core/blocks/block_operations.go

@@ -3,7 +3,6 @@ package blocks
 import (
 	"bytes"
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"reflect"
 
@@ -126,8 +125,8 @@ func verifyBlockRandao(proposer *pb.ValidatorRecord, block *pb.BeaconBlock) erro
 //   Verify that proposer_slashing.proposal_data_1.slot == proposer_slashing.proposal_data_2.slot.
 //   Verify that proposer_slashing.proposal_data_1.shard == proposer_slashing.proposal_data_2.shard.
 //   Verify that proposer_slashing.proposal_data_1.block_root != proposer_slashing.proposal_data_2.block_root.
-//   Verify that proposer.status != EXITED_WITH_PENALTY.
-//   Run update_validator_status(state, proposer_slashing.proposer_index, new_status=EXITED_WITH_PENALTY).
+//   Verify that validator.penalized_slot > state.slot.
+//   Run penalize_validator(state, proposer_slashing.proposer_index).
 func ProcessProposerSlashings(
 	beaconState *pb.BeaconState,
 	block *pb.BeaconBlock,
@@ -141,26 +140,20 @@ func ProcessProposerSlashings(
 			params.BeaconConfig().MaxProposerSlashings,
 		)
 	}
-	for idx, slashing := range body.ProposerSlashings {
-		if err := verifyProposerSlashing(slashing); err != nil {
+	var err error
+	for idx, slashing := range body.GetProposerSlashings() {
+		if err = verifyProposerSlashing(slashing); err != nil {
 			return nil, fmt.Errorf("could not verify proposer slashing #%d: %v", idx, err)
 		}
-		proposer := registry[slashing.ProposerIndex]
-		if proposer.Status != pb.ValidatorRecord_EXITED_WITH_PENALTY {
-			// TODO(#781): Replace with
-			// update_validator_status(
-			//   state,
-			//   proposer_slashing.proposer_index,
-			//   new_status=EXITED_WITH_PENALTY,
-			// ) after update_validator_status is implemented.
-			registry[slashing.ProposerIndex] = v.ExitValidator(
-				proposer,
-				beaconState.Slot,
-				true, /* penalize */
-			)
+		proposer := registry[slashing.GetProposerIndex()]
+		if proposer.GetPenalizedSlot() > beaconState.Slot {
+			beaconState, err = v.PenalizeValidator(beaconState, slashing.ProposerIndex)
+			if err != nil {
+				return nil, fmt.Errorf("could not penalize proposer index %d: %v",
+					slashing.ProposerIndex, err)
+			}
 		}
 	}
-	beaconState.ValidatorRegistry = registry
 	return beaconState, nil
 }
 
@@ -215,9 +208,8 @@ func verifyProposerSlashing(
 //     casper_slashing.votes_2.data.slot < casper_slashing.votes_1.data.slot
 //     or casper_slashing.votes_1.data.slot == casper_slashing.votes_2.data.slot.
 //   For each validator index i in intersection,
-//     if state.validator_registry[i].status does not equal
-//     EXITED_WITH_PENALTY, then run
-//     update_validator_status(state, i, new_status=EXITED_WITH_PENALTY)
+//     if state.validator_registry[i].penalized_slot > state.slot, then
+// 	   run penalize_validator(state, i)
 func ProcessCasperSlashings(
 	beaconState *pb.BeaconState,
 	block *pb.BeaconBlock,
@@ -241,21 +233,15 @@ func ProcessCasperSlashings(
 		}
 		for _, validatorIndex := range validatorIndices {
 			penalizedValidator := registry[validatorIndex]
-			if penalizedValidator.Status != pb.ValidatorRecord_EXITED_WITH_PENALTY {
-				// TODO(#781): Replace with update_validator_status(
-				//   state,
-				//   validatorIndex,
-				//   new_status=EXITED_WITH_PENALTY,
-				// ) after update_validator_status is implemented.
-				registry[validatorIndex] = v.ExitValidator(
-					penalizedValidator,
-					beaconState.Slot,
-					true, /* penalize */
-				)
+			if penalizedValidator.GetPenalizedSlot() > beaconState.Slot {
+				beaconState, err = v.PenalizeValidator(beaconState, validatorIndex)
+				if err != nil {
+					return nil, fmt.Errorf("could not penalize validator index %d: %v",
+						validatorIndex, err)
+				}
 			}
 		}
 	}
-	beaconState.ValidatorRegistry = registry
 	return beaconState, nil
 }
 
@@ -582,7 +568,7 @@ func ProcessValidatorDeposits(
 		// depositTimestamp [8]byte.
 		depositValue := depositData[len(depositData)-16 : len(depositData)-8]
 		// We then mutate the beacon state with the verified validator deposit.
-		beaconState, _, err = v.ProcessDeposit(
+		beaconState, err = v.ProcessDeposit(
 			beaconState,
 			depositInput.Pubkey,
 			binary.BigEndian.Uint64(depositValue),
@@ -672,7 +658,7 @@ func verifyDeposit(beaconState *pb.BeaconState, deposit *pb.Deposit) error {
 //
 //   For each exit in block.body.exits:
 //     Let validator = state.validator_registry[exit.validator_index].
-//     Verify that validator.status == ACTIVE.
+//     Verify that validator.exit_slot > state.slot + ENTRY_EXIT_DELAY.
 //     Verify that state.slot >= exit.slot.
 //     Verify that state.slot >= validator.latest_status_change_slot +
 //       SHARD_PERSISTENT_COMMITTEE_CHANGE_PERIOD.
@@ -682,8 +668,8 @@ func verifyDeposit(beaconState *pb.BeaconState, deposit *pb.Deposit) error {
 //       signature=exit.signature,
 //       domain=get_domain(state.fork_data, exit.slot, DOMAIN_EXIT),
 //     )
-//     Run update_validator_status(
-//       state, exit.validator_index, new_status=ACTIVE_PENDING_EXIT,
+//     Run initiate_validator_exit(
+//       state, exit.validator_index,
 //     )
 func ProcessValidatorExits(
 	beaconState *pb.BeaconState,
@@ -697,33 +683,24 @@ func ProcessValidatorExits(
 			params.BeaconConfig().MaxExits,
 		)
 	}
+
 	validatorRegistry := beaconState.ValidatorRegistry
 	for idx, exit := range exits {
 		if err := verifyExit(beaconState, exit); err != nil {
 			return nil, fmt.Errorf("could not verify exit #%d: %v", idx, err)
 		}
-		// TODO(#781): Replace with update_validator_status(
-		//   state,
-		//   validatorIndex,
-		//   new_status=ACTIVE_PENDING_EXIT,
-		// ) after update_validator_status is implemented.
-		validator := validatorRegistry[exit.ValidatorIndex]
-		validatorRegistry[exit.ValidatorIndex] = v.ExitValidator(
-			validator,
-			beaconState.Slot,
-			true, /* penalize */
-		)
+		beaconState = v.InitiateValidatorExit(beaconState, exit.GetValidatorIndex())
 	}
 	beaconState.ValidatorRegistry = validatorRegistry
 	return beaconState, nil
 }
 
 func verifyExit(beaconState *pb.BeaconState, exit *pb.Exit) error {
-	validator := beaconState.ValidatorRegistry[exit.ValidatorIndex]
-	if validator.Status != pb.ValidatorRecord_ACTIVE {
+	validator := beaconState.GetValidatorRegistry()[exit.GetValidatorIndex()]
+	if validator.GetExitSlot() <= beaconState.Slot+params.BeaconConfig().EntryExitDelay {
 		return fmt.Errorf(
-			"expected validator to have active status, received %v",
-			validator.Status,
+			"expected exit.Slot > state.Slot + EntryExitDelay, received %d < %d",
+			validator.GetExitSlot(), beaconState.Slot+params.BeaconConfig().EntryExitDelay,
 		)
 	}
 	if beaconState.Slot < exit.Slot {
@@ -733,13 +710,6 @@ func verifyExit(beaconState *pb.BeaconState, exit *pb.Exit) error {
 			exit.Slot,
 		)
 	}
-	persistentCommitteeSlot := validator.LatestStatusChangeSlot +
-		params.BeaconConfig().ShardPersistentCommitteeChangePeriod
-	if beaconState.Slot < persistentCommitteeSlot {
-		return errors.New(
-			"expected validator.LatestStatusChangeSlot + PersistentCommitteePeriod >= state.Slot",
-		)
-	}
 	// TODO(#258): Verify using BLS signature verification below:
 	// Verify that bls_verify(
 	//   pubkey=validator.pubkey,