From 9a4ab417615462d6d428a98b21ccc615f9177810 Mon Sep 17 00:00:00 2001 From: terence tsao Date: Tue, 13 Jul 2021 13:12:53 -0700 Subject: [PATCH] `BaseReward` test only (#9189) * Move baseward to test only * Update BUILD.bazel Co-authored-by: Raul Jordan --- beacon-chain/core/epoch/epoch_processing.go | 26 --------------- .../core/epoch/epoch_processing_test.go | 25 -------------- .../core/epoch/precompute/BUILD.bazel | 2 ++ .../epoch/precompute/reward_penalty_test.go | 33 ++++++++++++++++--- 4 files changed, 31 insertions(+), 55 deletions(-) diff --git a/beacon-chain/core/epoch/epoch_processing.go b/beacon-chain/core/epoch/epoch_processing.go index 7fb9b98fc8..d82ec20540 100644 --- a/beacon-chain/core/epoch/epoch_processing.go +++ b/beacon-chain/core/epoch/epoch_processing.go @@ -497,29 +497,3 @@ func UnslashedAttestingIndices(state iface.ReadOnlyBeaconState, atts []*pb.Pendi return setIndices, nil } - -// BaseReward takes state and validator index and calculate -// individual validator's base reward quotient. -// -// Note: Adjusted quotient is calculated of base reward because it's too inefficient -// to repeat the same calculation for every validator versus just doing it once. -// -// Spec pseudocode definition: -// def get_base_reward(state: BeaconState, index: ValidatorIndex) -> Gwei: -// total_balance = get_total_active_balance(state) -// effective_balance = state.validators[index].effective_balance -// return Gwei(effective_balance * BASE_REWARD_FACTOR // integer_squareroot(total_balance) // BASE_REWARDS_PER_EPOCH) -func BaseReward(state iface.ReadOnlyBeaconState, index types.ValidatorIndex) (uint64, error) { - totalBalance, err := helpers.TotalActiveBalance(state) - if err != nil { - return 0, errors.Wrap(err, "could not calculate active balance") - } - val, err := state.ValidatorAtIndexReadOnly(index) - if err != nil { - return 0, err - } - effectiveBalance := val.EffectiveBalance() - baseReward := effectiveBalance * params.BeaconConfig().BaseRewardFactor / - mathutil.IntegerSquareRoot(totalBalance) / params.BeaconConfig().BaseRewardsPerEpoch - return baseReward, nil -} diff --git a/beacon-chain/core/epoch/epoch_processing_test.go b/beacon-chain/core/epoch/epoch_processing_test.go index fac696592a..9f73883a37 100644 --- a/beacon-chain/core/epoch/epoch_processing_test.go +++ b/beacon-chain/core/epoch/epoch_processing_test.go @@ -144,31 +144,6 @@ func TestAttestingBalance_CorrectBalance(t *testing.T) { assert.Equal(t, wanted, balance) } -func TestBaseReward_AccurateRewards(t *testing.T) { - tests := []struct { - a uint64 - b uint64 - c uint64 - }{ - {params.BeaconConfig().MinDepositAmount, params.BeaconConfig().MinDepositAmount, 505976}, - {30 * 1e9, 30 * 1e9, 2771282}, - {params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance, 2862174}, - {40 * 1e9, params.BeaconConfig().MaxEffectiveBalance, 2862174}, - } - for _, tt := range tests { - base := &pb.BeaconState{ - Validators: []*ethpb.Validator{ - {ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: tt.b}}, - Balances: []uint64{tt.a}, - } - beaconState, err := v1.InitializeFromProto(base) - require.NoError(t, err) - c, err := epoch.BaseReward(beaconState, 0) - require.NoError(t, err) - assert.Equal(t, tt.c, c, "epoch.BaseReward(%d)", tt.a) - } -} - func TestProcessSlashings_NotSlashed(t *testing.T) { base := &pb.BeaconState{ Slot: 0, diff --git a/beacon-chain/core/epoch/precompute/BUILD.bazel b/beacon-chain/core/epoch/precompute/BUILD.bazel index 3d63ad2d7d..9fea2afe82 100644 --- a/beacon-chain/core/epoch/precompute/BUILD.bazel +++ b/beacon-chain/core/epoch/precompute/BUILD.bazel @@ -43,6 +43,7 @@ go_test( deps = [ "//beacon-chain/core/epoch:go_default_library", "//beacon-chain/core/helpers:go_default_library", + "//beacon-chain/state/interface:go_default_library", "//beacon-chain/state/v1:go_default_library", "//proto/beacon/p2p/v1:go_default_library", "//proto/eth/v1alpha1:go_default_library", @@ -52,6 +53,7 @@ go_test( "//shared/testutil:go_default_library", "//shared/testutil/assert:go_default_library", "//shared/testutil/require:go_default_library", + "@com_github_pkg_errors//: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", diff --git a/beacon-chain/core/epoch/precompute/reward_penalty_test.go b/beacon-chain/core/epoch/precompute/reward_penalty_test.go index 9d7268104e..310889d0b7 100644 --- a/beacon-chain/core/epoch/precompute/reward_penalty_test.go +++ b/beacon-chain/core/epoch/precompute/reward_penalty_test.go @@ -4,10 +4,12 @@ import ( "context" "testing" + "github.com/pkg/errors" types "github.com/prysmaticlabs/eth2-types" "github.com/prysmaticlabs/go-bitfield" "github.com/prysmaticlabs/prysm/beacon-chain/core/epoch" "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers" + iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface" "github.com/prysmaticlabs/prysm/beacon-chain/state/v1" pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1" @@ -105,7 +107,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) { attestedIndices := []types.ValidatorIndex{55, 1339, 1746, 1811, 1569} for _, i := range attestedIndices { - base, err := epoch.BaseReward(beaconState, i) + base, err := baseReward(beaconState, i) require.NoError(t, err, "Could not get base reward") // Base rewards for getting source right @@ -122,7 +124,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) { } for _, i := range slashedAttestedIndices { - base, err := epoch.BaseReward(beaconState, i) + base, err := baseReward(beaconState, i) assert.NoError(t, err, "Could not get base reward") assert.Equal(t, uint64(0), rewards[i], "Unexpected slashed indices reward balance") assert.Equal(t, 3*base, penalties[i], "Unexpected slashed indices penalty balance") @@ -130,7 +132,7 @@ func TestAttestationDeltaPrecompute(t *testing.T) { nonAttestedIndices := []types.ValidatorIndex{434, 677, 872, 791} for _, i := range nonAttestedIndices { - base, err := epoch.BaseReward(beaconState, i) + base, err := baseReward(beaconState, i) assert.NoError(t, err, "Could not get base reward") wanted := 3 * base // Since all these validators did not attest, they shouldn't get rewarded. @@ -246,7 +248,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing. finalityDelay := helpers.PrevEpoch(beaconState) - beaconState.FinalizedCheckpointEpoch() for _, i := range slashedAttestedIndices { - base, err := epoch.BaseReward(beaconState, i) + base, err := baseReward(beaconState, i) require.NoError(t, err, "Could not get base reward") penalty := 3 * base proposerReward := base / params.BeaconConfig().ProposerRewardQuotient @@ -350,3 +352,26 @@ func TestProposerDeltaPrecompute_SlashedCase(t *testing.T) { require.NoError(t, err) assert.Equal(t, uint64(0), r[proposerIndex], "Unexpected proposer reward for slashed") } + +// BaseReward takes state and validator index and calculate +// individual validator's base reward quotient. +// +// Spec pseudocode definition: +// def get_base_reward(state: BeaconState, index: ValidatorIndex) -> Gwei: +// total_balance = get_total_active_balance(state) +// effective_balance = state.validators[index].effective_balance +// return Gwei(effective_balance * BASE_REWARD_FACTOR // integer_squareroot(total_balance) // BASE_REWARDS_PER_EPOCH) +func baseReward(state iface.ReadOnlyBeaconState, index types.ValidatorIndex) (uint64, error) { + totalBalance, err := helpers.TotalActiveBalance(state) + if err != nil { + return 0, errors.Wrap(err, "could not calculate active balance") + } + val, err := state.ValidatorAtIndexReadOnly(index) + if err != nil { + return 0, err + } + effectiveBalance := val.EffectiveBalance() + baseReward := effectiveBalance * params.BeaconConfig().BaseRewardFactor / + mathutil.IntegerSquareRoot(totalBalance) / params.BeaconConfig().BaseRewardsPerEpoch + return baseReward, nil +}