diff --git a/configs/mainnet/lightclient_patch.yaml b/configs/mainnet/lightclient_patch.yaml index a9ddc16f6..b151f5cdb 100644 --- a/configs/mainnet/lightclient_patch.yaml +++ b/configs/mainnet/lightclient_patch.yaml @@ -18,6 +18,8 @@ HF1_PROPORTIONAL_SLASHING_MULTIPLIER: 2 SYNC_COMMITTEE_SIZE: 1024 # 2**6 (=64) SYNC_SUBCOMMITTEE_SIZE: 64 +# 2**2 (=4) +LEAK_SCORE_BIAS: 4 # Time parameters diff --git a/configs/minimal/lightclient_patch.yaml b/configs/minimal/lightclient_patch.yaml index 56ce34591..cbdbaf8a7 100644 --- a/configs/minimal/lightclient_patch.yaml +++ b/configs/minimal/lightclient_patch.yaml @@ -18,6 +18,8 @@ HF1_PROPORTIONAL_SLASHING_MULTIPLIER: 2 SYNC_COMMITTEE_SIZE: 32 # [customized] SYNC_SUBCOMMITTEE_SIZE: 16 +# 2**2 (=4) +LEAK_SCORE_BIAS: 4 # Time parameters diff --git a/specs/lightclient/beacon-chain.md b/specs/lightclient/beacon-chain.md index c49e34c6c..5bebc8836 100644 --- a/specs/lightclient/beacon-chain.md +++ b/specs/lightclient/beacon-chain.md @@ -18,7 +18,7 @@ - [Time parameters](#time-parameters) - [Domain types](#domain-types) - [Containers](#containers) - - [Extended containers](#extended-containers) + - [Modified containers](#modified-containers) - [`BeaconBlockBody`](#beaconblockbody) - [`BeaconState`](#beaconstate) - [New containers](#new-containers) @@ -135,10 +135,7 @@ This patch updates a few configuration values to move penalty constants toward t ## Containers -### Extended containers - -*Note*: Extended SSZ containers inherit all fields from the parent in the original -order and append any additional fields to the end. +### Modified containers #### `BeaconBlockBody` @@ -195,7 +192,7 @@ class BeaconState(Container): current_sync_committee: SyncCommittee next_sync_committee: SyncCommittee # Leak - leak_scores: List[uint64, VALIDATOR_REGISTRY_LIMIT] + leak_scores: List[uint64, VALIDATOR_REGISTRY_LIMIT] # [New in HF1] ``` ### New containers diff --git a/specs/lightclient/lightclient-fork.md b/specs/lightclient/lightclient-fork.md index 157e67dc9..17a65793a 100644 --- a/specs/lightclient/lightclient-fork.md +++ b/specs/lightclient/lightclient-fork.md @@ -42,6 +42,7 @@ After `process_slots` of Phase 0 finishes, if `state.slot == LIGHTCLIENT_PATCH_F def upgrade_to_lightclient_patch(pre: phase0.BeaconState) -> BeaconState: epoch = get_current_epoch(pre) post = BeaconState( + # Versioning genesis_time=pre.genesis_time, genesis_validators_root=pre.genesis_validators_root, slot=pre.slot, @@ -67,13 +68,15 @@ def upgrade_to_lightclient_patch(pre: phase0.BeaconState) -> BeaconState: # Slashings slashings=pre.slashings, # Participation - previous_epoch_participation=[ParticipationFlags(0) for _ in range(len(pre.validators))], - current_epoch_participation=[ParticipationFlags(0) for _ in range(len(pre.validators))], + previous_epoch_participation=[ParticipationFlags(0b0000_0000) for _ in range(len(pre.validators))], + current_epoch_participation=[ParticipationFlags(0b0000_0000) for _ in range(len(pre.validators))], # Finality justification_bits=pre.justification_bits, previous_justified_checkpoint=pre.previous_justified_checkpoint, current_justified_checkpoint=pre.current_justified_checkpoint, finalized_checkpoint=pre.finalized_checkpoint, + # Leak + leak_scores=[0 for _ in range(len(pre.validators))], ) # Fill in sync committees post.current_sync_committee = get_sync_committee(post, get_current_epoch(post)) diff --git a/tests/core/pyspec/eth2spec/test/helpers/rewards.py b/tests/core/pyspec/eth2spec/test/helpers/rewards.py index 19ed3f691..a92a59458 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/rewards.py +++ b/tests/core/pyspec/eth2spec/test/helpers/rewards.py @@ -34,7 +34,8 @@ def run_deltas(spec, state): - source deltas ('source_deltas') - target deltas ('target_deltas') - head deltas ('head_deltas') - - inclusion delay deltas ('inclusion_delay_deltas') + - not if is_post_lightclient_patch(spec) + - inclusion delay deltas ('inclusion_delay_deltas') - inactivity penalty deltas ('inactivity_penalty_deltas') """ yield 'pre', state @@ -70,7 +71,8 @@ def run_deltas(spec, state): spec.get_matching_head_attestations, 'head_deltas', ) - yield from run_get_inclusion_delay_deltas(spec, state) + if not is_post_lightclient_patch(spec): + yield from run_get_inclusion_delay_deltas(spec, state) yield from run_get_inactivity_penalty_deltas(spec, state) @@ -219,7 +221,8 @@ def run_get_inactivity_penalty_deltas(spec, state): def transition_state_to_leak(spec, state, epochs=None): if epochs is None: - epochs = spec.MIN_EPOCHS_TO_INACTIVITY_PENALTY + # +1 to trigger leak_score transitions + epochs = spec.MIN_EPOCHS_TO_INACTIVITY_PENALTY + 1 assert epochs >= spec.MIN_EPOCHS_TO_INACTIVITY_PENALTY for _ in range(epochs): diff --git a/tests/core/pyspec/eth2spec/test/lightclient_patch/sanity/test_blocks.py b/tests/core/pyspec/eth2spec/test/lightclient_patch/sanity/test_blocks.py index 9033a0f15..3689c0783 100644 --- a/tests/core/pyspec/eth2spec/test/lightclient_patch/sanity/test_blocks.py +++ b/tests/core/pyspec/eth2spec/test/lightclient_patch/sanity/test_blocks.py @@ -2,9 +2,11 @@ import random from eth2spec.test.helpers.state import ( state_transition_and_sign_block, next_epoch, + next_epoch_via_block, ) from eth2spec.test.helpers.block import ( build_empty_block_for_next_slot, + build_empty_block, ) from eth2spec.test.helpers.sync_committee import ( compute_aggregate_sync_committee_signature, @@ -73,3 +75,25 @@ def test_half_sync_committee_committee_genesis(spec, state): @spec_state_test def test_empty_sync_committee_committee_genesis(spec, state): yield from run_sync_committee_sanity_test(spec, state, fraction_full=0.0) + + +@with_all_phases_except([PHASE0, PHASE1]) +@spec_state_test +def test_leak_scores(spec, state): + for _ in range(spec.MIN_EPOCHS_TO_INACTIVITY_PENALTY + 2): + next_epoch_via_block(spec, state) + + assert spec.is_in_inactivity_leak(state) + previous_leak_scores = state.leak_scores.copy() + + yield 'pre', state + + # Block transition to next epoch + block = build_empty_block(spec, state, slot=state.slot + spec.SLOTS_PER_EPOCH) + signed_block = state_transition_and_sign_block(spec, state, block) + + yield 'blocks', [signed_block] + yield 'post', state + + for pre, post in zip(previous_leak_scores, state.leak_scores): + assert post == pre + spec.LEAK_SCORE_BIAS diff --git a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py index 21d9363f7..7345e62ba 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py +++ b/tests/core/pyspec/eth2spec/test/phase0/block_processing/test_process_attester_slashing.py @@ -1,5 +1,9 @@ +import random + from eth2spec.test.context import ( - spec_state_test, expect_assertion_error, always_bls, with_all_phases + spec_state_test, expect_assertion_error, always_bls, with_all_phases, + with_custom_state, spec_test, single_phase, + low_balances, misc_balances, ) from eth2spec.test.helpers.attestations import sign_indexed_attestation from eth2spec.test.helpers.attester_slashings import get_valid_attester_slashing, \ @@ -32,15 +36,19 @@ def run_attester_slashing_processing(spec, state, attester_slashing, valid=True) proposer_index = spec.get_beacon_proposer_index(state) pre_proposer_balance = get_balance(state, proposer_index) - pre_slashings = {slashed_index: get_balance(state, slashed_index) for slashed_index in slashed_indices} + pre_slashing_balances = {slashed_index: get_balance(state, slashed_index) for slashed_index in slashed_indices} + pre_slashing_effectives = { + slashed_index: state.validators[slashed_index].effective_balance + for slashed_index in slashed_indices + } pre_withdrawalable_epochs = { slashed_index: state.validators[slashed_index].withdrawable_epoch for slashed_index in slashed_indices } total_proposer_rewards = sum( - balance // spec.WHISTLEBLOWER_REWARD_QUOTIENT - for balance in pre_slashings.values() + effective_balance // spec.WHISTLEBLOWER_REWARD_QUOTIENT + for effective_balance in pre_slashing_effectives.values() ) # Process slashing @@ -61,7 +69,7 @@ def run_attester_slashing_processing(spec, state, attester_slashing, valid=True) assert slashed_validator.withdrawable_epoch == expected_withdrawable_epoch else: assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH - assert get_balance(state, slashed_index) < pre_slashings[slashed_index] + assert get_balance(state, slashed_index) < pre_slashing_balances[slashed_index] if proposer_index not in slashed_indices: # gained whistleblower reward @@ -71,7 +79,7 @@ def run_attester_slashing_processing(spec, state, attester_slashing, valid=True) expected_balance = ( pre_proposer_balance + total_proposer_rewards - - pre_slashings[proposer_index] // get_min_slashing_penalty_quotient(spec) + - pre_slashing_effectives[proposer_index] // get_min_slashing_penalty_quotient(spec) ) assert get_balance(state, proposer_index) == expected_balance @@ -118,6 +126,41 @@ def test_success_already_exited_recent(spec, state): yield from run_attester_slashing_processing(spec, state, attester_slashing) +@with_all_phases +@with_custom_state(balances_fn=low_balances, threshold_fn=lambda spec: spec.EJECTION_BALANCE) +@spec_test +@single_phase +def test_success_low_balances(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) + + yield from run_attester_slashing_processing(spec, state, attester_slashing) + + +@with_all_phases +@with_custom_state(balances_fn=misc_balances, threshold_fn=lambda spec: spec.EJECTION_BALANCE) +@spec_test +@single_phase +def test_success_misc_balances(spec, state): + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) + + yield from run_attester_slashing_processing(spec, state, attester_slashing) + + +@with_all_phases +@with_custom_state(balances_fn=misc_balances, threshold_fn=lambda spec: spec.EJECTION_BALANCE) +@spec_test +@single_phase +def test_success_with_effective_balance_disparity(spec, state): + # Jitter balances to be different from effective balances + for i in range(len(state.balances)): + pre = int(state.balances[i]) + state.balances[i] += random.randrange(max(pre - 5000, 0), pre + 5000) + + attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True) + + yield from run_attester_slashing_processing(spec, state, attester_slashing) + + @with_all_phases @spec_state_test @always_bls diff --git a/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_effective_balance_updates.py b/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_effective_balance_updates.py index 93411f657..dc4c047a2 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_effective_balance_updates.py +++ b/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_effective_balance_updates.py @@ -1,11 +1,5 @@ from eth2spec.test.context import spec_state_test, with_all_phases -from eth2spec.test.helpers.epoch_processing import ( - run_epoch_processing_with, run_epoch_processing_to -) - - -def run_process_effective_balance_updates(spec, state): - yield from run_epoch_processing_with(spec, state, 'process_effective_balance_updates') +from eth2spec.test.helpers.epoch_processing import run_epoch_processing_to @with_all_phases @@ -44,7 +38,9 @@ def test_effective_balance_hysteresis(spec, state): state.validators[i].effective_balance = pre_eff state.balances[i] = bal - yield from run_process_effective_balance_updates(spec, state) + yield 'pre', state + spec.process_effective_balance_updates(state) + yield 'post', state for i, (_, _, post_eff, name) in enumerate(cases): assert state.validators[i].effective_balance == post_eff, name diff --git a/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_rewards_and_penalties.py b/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_rewards_and_penalties.py index 7bb86b45e..2de054505 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_rewards_and_penalties.py +++ b/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_rewards_and_penalties.py @@ -27,6 +27,31 @@ def run_process_rewards_and_penalties(spec, state): yield from run_epoch_processing_with(spec, state, 'process_rewards_and_penalties') +def validate_resulting_balances(spec, pre_state, post_state, attestations): + attesting_indices = spec.get_unslashed_attesting_indices(post_state, attestations) + current_epoch = spec.get_current_epoch(post_state) + + for index in range(len(pre_state.validators)): + if not spec.is_active_validator(pre_state.validators[index], current_epoch): + assert post_state.balances[index] == pre_state.balances[index] + elif not is_post_lightclient_patch(spec): + proposer_indices = [a.proposer_index for a in post_state.previous_epoch_attestations] + if spec.is_in_inactivity_leak(post_state): + # Proposers can still make money during a leak before LIGHTCLIENT_PATCH + if index in proposer_indices and index in attesting_indices: + assert post_state.balances[index] > pre_state.balances[index] + elif index in attesting_indices: + # If not proposer but participated optimally, should have exactly neutral balance + assert post_state.balances[index] == pre_state.balances[index] + else: + assert post_state.balances[index] < pre_state.balances[index] + else: + if index in attesting_indices: + assert post_state.balances[index] > pre_state.balances[index] + else: + assert post_state.balances[index] < pre_state.balances[index] + + @with_all_phases @spec_state_test def test_genesis_epoch_no_attestations_no_penalties(spec, state): @@ -100,19 +125,10 @@ def test_full_attestations_misc_balances(spec, state): yield from run_process_rewards_and_penalties(spec, state) - attesting_indices = spec.get_unslashed_attesting_indices(state, attestations) - assert len(attesting_indices) > 0 - assert len(attesting_indices) != len(pre_state.validators) - assert any(v.effective_balance != spec.MAX_EFFECTIVE_BALANCE for v in state.validators) - for index in range(len(pre_state.validators)): - if index in attesting_indices: - assert state.balances[index] > pre_state.balances[index] - elif spec.is_active_validator(pre_state.validators[index], spec.compute_epoch_at_slot(state.slot)): - assert state.balances[index] < pre_state.balances[index] - else: - assert state.balances[index] == pre_state.balances[index] + validate_resulting_balances(spec, pre_state, state, attestations) # Check if base rewards are consistent with effective balance. brs = {} + attesting_indices = spec.get_unslashed_attesting_indices(state, attestations) for index in attesting_indices: br = spec.get_base_reward(state, index) if br in brs: @@ -146,8 +162,7 @@ def test_no_attestations_all_penalties(spec, state): yield from run_process_rewards_and_penalties(spec, state) - for index in range(len(pre_state.validators)): - assert state.balances[index] < pre_state.balances[index] + validate_resulting_balances(spec, pre_state, state, []) def run_with_participation(spec, state, participation_fn): @@ -161,35 +176,12 @@ def run_with_participation(spec, state, participation_fn): attestations = prepare_state_with_attestations(spec, state, participation_fn=participation_tracker) pre_state = state.copy() - if not is_post_lightclient_patch(spec): - proposer_indices = [a.proposer_index for a in state.previous_epoch_attestations] - else: - sync_committee_indices = spec.get_sync_committee_indices(state, spec.get_current_epoch(state)) - yield from run_process_rewards_and_penalties(spec, state) attesting_indices = spec.get_unslashed_attesting_indices(state, attestations) assert len(attesting_indices) == len(participated) - for index in range(len(pre_state.validators)): - if spec.is_in_inactivity_leak(state): - # Proposers can still make money during a leak before LIGHTCLIENT_PATCH - if not is_post_lightclient_patch(spec) and index in proposer_indices and index in participated: - assert state.balances[index] > pre_state.balances[index] - elif index in attesting_indices: - if is_post_lightclient_patch(spec) and index in sync_committee_indices: - # The sync committee reward has not been canceled, so the sync committee participants still earn it - assert state.balances[index] >= pre_state.balances[index] - else: - # If not proposer but participated optimally, should have exactly neutral balance - assert state.balances[index] == pre_state.balances[index] - else: - assert state.balances[index] < pre_state.balances[index] - else: - if index in participated: - assert state.balances[index] > pre_state.balances[index] - else: - assert state.balances[index] < pre_state.balances[index] + validate_resulting_balances(spec, pre_state, state, attestations) @with_all_phases @@ -438,10 +430,4 @@ def test_attestations_some_slashed(spec, state): attesting_indices = spec.get_unslashed_attesting_indices(state, attestations) assert len(attesting_indices) > 0 assert len(attesting_indices_before_slashings) - len(attesting_indices) == spec.MIN_PER_EPOCH_CHURN_LIMIT - for index in range(len(pre_state.validators)): - if index in attesting_indices: - # non-slashed attester should gain reward - assert state.balances[index] > pre_state.balances[index] - else: - # Slashed non-proposer attester should have penalty - assert state.balances[index] < pre_state.balances[index] + validate_resulting_balances(spec, pre_state, state, attestations)