Add altair epoch processing functions (#9404)

2026-01-10 16:08:26 -05:00 · 2021-08-20 16:55:42 -07:00
parent bdfdba1e23
commit cac1e94f04
3 changed files with 300 additions and 0 deletions
--- a/beacon-chain/core/altair/BUILD.bazel
+++ b/beacon-chain/core/altair/BUILD.bazel
@@ -7,6 +7,7 @@ go_library(
        "block.go",
        "deposit.go",
        "epoch_precompute.go",
+        "epoch_spec.go",
        "reward.go",
        "sync_committee.go",
        "upgrade.go",
@@ -46,6 +47,7 @@ go_test(
        "deposit_fuzz_test.go",
        "deposit_test.go",
        "epoch_precompute_test.go",
+        "epoch_spec_test.go",
        "reward_test.go",
        "sync_committee_test.go",
        "upgrade_test.go",
@@ -72,5 +74,6 @@ go_test(
        "@com_github_google_gofuzz//:go_default_library",
        "@com_github_prysmaticlabs_eth2_types//:go_default_library",
        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
    ],
 )
--- a/beacon-chain/core/altair/epoch_spec.go
+++ b/beacon-chain/core/altair/epoch_spec.go
@@ -0,0 +1,116 @@
+package altair
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/mathutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// ProcessSyncCommitteeUpdates  processes sync client committee updates for the beacon state.
+//
+// Spec code:
+// def process_sync_committee_updates(state: BeaconState) -> None:
+//    next_epoch = get_current_epoch(state) + Epoch(1)
+//    if next_epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0:
+//        state.current_sync_committee = state.next_sync_committee
+//        state.next_sync_committee = get_next_sync_committee(state)
+func ProcessSyncCommitteeUpdates(ctx context.Context, beaconState state.BeaconStateAltair) (state.BeaconStateAltair, error) {
+	nextEpoch := helpers.NextEpoch(beaconState)
+	if nextEpoch%params.BeaconConfig().EpochsPerSyncCommitteePeriod == 0 {
+		nextSyncCommittee, err := beaconState.NextSyncCommittee()
+		if err != nil {
+			return nil, err
+		}
+		if err := beaconState.SetCurrentSyncCommittee(nextSyncCommittee); err != nil {
+			return nil, err
+		}
+		nextSyncCommittee, err = NextSyncCommittee(ctx, beaconState)
+		if err != nil {
+			return nil, err
+		}
+		if err := beaconState.SetNextSyncCommittee(nextSyncCommittee); err != nil {
+			return nil, err
+		}
+		if err := helpers.UpdateSyncCommitteeCache(beaconState); err != nil {
+			return nil, err
+		}
+	}
+	return beaconState, nil
+}
+
+// ProcessParticipationFlagUpdates processes participation flag updates by rotating current to previous.
+//
+// Spec code:
+// def process_participation_flag_updates(state: BeaconState) -> None:
+//    state.previous_epoch_participation = state.current_epoch_participation
+//    state.current_epoch_participation = [ParticipationFlags(0b0000_0000) for _ in range(len(state.validators))]
+func ProcessParticipationFlagUpdates(beaconState state.BeaconStateAltair) (state.BeaconStateAltair, error) {
+	c, err := beaconState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	if err := beaconState.SetPreviousParticipationBits(c); err != nil {
+		return nil, err
+	}
+	if err := beaconState.SetCurrentParticipationBits(make([]byte, beaconState.NumValidators())); err != nil {
+		return nil, err
+	}
+	return beaconState, nil
+}
+
+// ProcessSlashings processes the slashed validators during epoch processing,
+// The function is modified to use PROPORTIONAL_SLASHING_MULTIPLIER_ALTAIR.
+//
+// Spec code:
+//  def process_slashings(state: BeaconState) -> None:
+//    epoch = get_current_epoch(state)
+//    total_balance = get_total_active_balance(state)
+//    adjusted_total_slashing_balance = min(sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER_ALTAIR, total_balance)
+//    for index, validator in enumerate(state.validators):
+//        if validator.slashed and epoch + EPOCHS_PER_SLASHINGS_VECTOR // 2 == validator.withdrawable_epoch:
+//            increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from penalty numerator to avoid uint64 overflow
+//            penalty_numerator = validator.effective_balance // increment * adjusted_total_slashing_balance
+//            penalty = penalty_numerator // total_balance * increment
+//            decrease_balance(state, ValidatorIndex(index), penalty)
+//            decrease_balance(state, ValidatorIndex(index), penalty)
+func ProcessSlashings(state state.BeaconState) (state.BeaconState, error) {
+	currentEpoch := helpers.CurrentEpoch(state)
+	totalBalance, err := helpers.TotalActiveBalance(state)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get total active balance")
+	}
+
+	// Compute slashed balances in the current epoch
+	exitLength := params.BeaconConfig().EpochsPerSlashingsVector
+
+	// Compute the sum of state slashings
+	slashings := state.Slashings()
+	totalSlashing := uint64(0)
+	for _, slashing := range slashings {
+		totalSlashing += slashing
+	}
+
+	// a callback is used here to apply the following actions  to all validators
+	// below equally.
+	increment := params.BeaconConfig().EffectiveBalanceIncrement
+	minSlashing := mathutil.Min(totalSlashing*params.BeaconConfig().ProportionalSlashingMultiplierAltair, totalBalance)
+	err = state.ApplyToEveryValidator(func(idx int, val *ethpb.Validator) (bool, *ethpb.Validator, error) {
+		correctEpoch := (currentEpoch + exitLength/2) == val.WithdrawableEpoch
+		if val.Slashed && correctEpoch {
+			penaltyNumerator := val.EffectiveBalance / increment * minSlashing
+			penalty := penaltyNumerator / totalBalance * increment
+			if err := helpers.DecreaseBalance(state, types.ValidatorIndex(idx), penalty); err != nil {
+				return false, val, err
+			}
+			return true, val, nil
+		}
+		return false, val, nil
+	})
+	return state, err
+}
--- a/beacon-chain/core/altair/epoch_spec_test.go
+++ b/beacon-chain/core/altair/epoch_spec_test.go
@@ -0,0 +1,181 @@
+package altair_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	stateAltair "github.com/prysmaticlabs/prysm/beacon-chain/state/v2"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/bytesutil"
+	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestProcessSyncCommitteeUpdates_CanRotate(t *testing.T) {
+	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	h := &ethpb.BeaconBlockHeader{
+		StateRoot:  bytesutil.PadTo([]byte{'a'}, 32),
+		ParentRoot: bytesutil.PadTo([]byte{'b'}, 32),
+		BodyRoot:   bytesutil.PadTo([]byte{'c'}, 32),
+	}
+	require.NoError(t, s.SetLatestBlockHeader(h))
+	postState, err := altair.ProcessSyncCommitteeUpdates(context.Background(), s)
+	require.NoError(t, err)
+	current, err := postState.CurrentSyncCommittee()
+	require.NoError(t, err)
+	next, err := postState.NextSyncCommittee()
+	require.NoError(t, err)
+	require.DeepEqual(t, current, next)
+
+	require.NoError(t, s.SetSlot(params.BeaconConfig().SlotsPerEpoch))
+	postState, err = altair.ProcessSyncCommitteeUpdates(context.Background(), s)
+	require.NoError(t, err)
+	c, err := postState.CurrentSyncCommittee()
+	require.NoError(t, err)
+	n, err := postState.NextSyncCommittee()
+	require.NoError(t, err)
+	require.DeepEqual(t, current, c)
+	require.DeepEqual(t, next, n)
+
+	require.NoError(t, s.SetSlot(types.Slot(params.BeaconConfig().EpochsPerSyncCommitteePeriod)*params.BeaconConfig().SlotsPerEpoch-1))
+	postState, err = altair.ProcessSyncCommitteeUpdates(context.Background(), s)
+	require.NoError(t, err)
+	c, err = postState.CurrentSyncCommittee()
+	require.NoError(t, err)
+	n, err = postState.NextSyncCommittee()
+	require.NoError(t, err)
+	require.NotEqual(t, current, c)
+	require.NotEqual(t, next, n)
+	require.DeepEqual(t, next, c)
+
+	// Test boundary condition.
+	slot := params.BeaconConfig().SlotsPerEpoch * types.Slot(helpers.CurrentEpoch(s)+params.BeaconConfig().EpochsPerSyncCommitteePeriod)
+	require.NoError(t, s.SetSlot(slot))
+	boundaryCommittee, err := altair.NextSyncCommittee(context.Background(), s)
+	require.NoError(t, err)
+	require.DeepNotEqual(t, boundaryCommittee, n)
+}
+
+func TestProcessParticipationFlagUpdates_CanRotate(t *testing.T) {
+	s, _ := testutil.DeterministicGenesisStateAltair(t, params.BeaconConfig().MaxValidatorsPerCommittee)
+	c, err := s.CurrentEpochParticipation()
+	require.NoError(t, err)
+	require.DeepEqual(t, make([]byte, params.BeaconConfig().MaxValidatorsPerCommittee), c)
+	p, err := s.PreviousEpochParticipation()
+	require.NoError(t, err)
+	require.DeepEqual(t, make([]byte, params.BeaconConfig().MaxValidatorsPerCommittee), p)
+
+	newC := []byte{'a'}
+	newP := []byte{'b'}
+	require.NoError(t, s.SetCurrentParticipationBits(newC))
+	require.NoError(t, s.SetPreviousParticipationBits(newP))
+	c, err = s.CurrentEpochParticipation()
+	require.NoError(t, err)
+	require.DeepEqual(t, newC, c)
+	p, err = s.PreviousEpochParticipation()
+	require.NoError(t, err)
+	require.DeepEqual(t, newP, p)
+
+	s, err = altair.ProcessParticipationFlagUpdates(s)
+	require.NoError(t, err)
+	c, err = s.CurrentEpochParticipation()
+	require.NoError(t, err)
+	require.DeepEqual(t, make([]byte, params.BeaconConfig().MaxValidatorsPerCommittee), c)
+	p, err = s.PreviousEpochParticipation()
+	require.NoError(t, err)
+	require.DeepEqual(t, newC, p)
+}
+
+func TestProcessSlashings_NotSlashed(t *testing.T) {
+	base := &ethpb.BeaconStateAltair{
+		Slot:       0,
+		Validators: []*ethpb.Validator{{Slashed: true}},
+		Balances:   []uint64{params.BeaconConfig().MaxEffectiveBalance},
+		Slashings:  []uint64{0, 1e9},
+	}
+	s, err := stateAltair.InitializeFromProto(base)
+	require.NoError(t, err)
+	newState, err := altair.ProcessSlashings(s)
+	require.NoError(t, err)
+	wanted := params.BeaconConfig().MaxEffectiveBalance
+	assert.Equal(t, wanted, newState.Balances()[0], "Unexpected slashed balance")
+}
+
+func TestProcessSlashings_SlashedLess(t *testing.T) {
+	tests := []struct {
+		state *ethpb.BeaconStateAltair
+		want  uint64
+	}{
+		{
+			state: &ethpb.BeaconStateAltair{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance}},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
+				Slashings: []uint64{0, 1e9},
+			},
+			want: uint64(30000000000),
+		},
+		{
+			state: &ethpb.BeaconStateAltair{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+				},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
+				Slashings: []uint64{0, 1e9},
+			},
+			want: uint64(31000000000),
+		},
+		{
+			state: &ethpb.BeaconStateAltair{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
+				},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
+				Slashings: []uint64{0, 2 * 1e9},
+			},
+			want: uint64(30000000000),
+		},
+		{
+			state: &ethpb.BeaconStateAltair{
+				Validators: []*ethpb.Validator{
+					{Slashed: true,
+						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
+					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement}},
+				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
+				Slashings: []uint64{0, 1e9},
+			},
+			want: uint64(29000000000),
+		},
+	}
+
+	for i, tt := range tests {
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
+			helpers.ClearCache()
+			original := proto.Clone(tt.state)
+			s, err := stateAltair.InitializeFromProto(tt.state)
+			require.NoError(t, err)
+			newState, err := altair.ProcessSlashings(s)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
+		})
+	}
+}