379 lines
14 KiB
Nim
379 lines
14 KiB
Nim
# beacon_chain
|
|
# Copyright (c) 2021-2022 Status Research & Development GmbH
|
|
# Licensed and distributed under either of
|
|
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
|
|
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
|
|
# at your option. This file may not be copied, modified, or distributed except according to those terms.
|
|
|
|
{.used.}
|
|
|
|
import
|
|
# Standard library
|
|
std/[algorithm, sequtils, sets],
|
|
# Status libraries
|
|
stew/bitops2,
|
|
# Beacon chain internals
|
|
../../../beacon_chain/spec/datatypes/altair,
|
|
../../../beacon_chain/spec/
|
|
[beaconstate, forks, helpers, light_client_sync, signatures,
|
|
state_transition],
|
|
# Mock helpers
|
|
../../mocking/mock_genesis,
|
|
# Test utilities
|
|
../../testutil, ../../testblockutil
|
|
|
|
# References to `vFuture` refer to the pre-release proposal of the libp2p based
|
|
# light client sync protocol. Conflicting release versions are not in use.
|
|
# https://github.com/ethereum/consensus-specs/pull/2802
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/vFuture/tests/core/pyspec/eth2spec/test/helpers/light_client.py#L63-L93
|
|
proc compute_aggregate_sync_committee_signature(
|
|
cfg: RuntimeConfig,
|
|
forked: ForkedHashedBeaconState,
|
|
signature_slot: Slot,
|
|
participants: openArray[ValidatorIndex],
|
|
block_root: Eth2Digest): ValidatorSig =
|
|
template state(): auto = forked.altairData.data
|
|
|
|
if len(participants) == 0:
|
|
return ValidatorSig.infinity
|
|
|
|
var
|
|
aggregateSig {.noinit.}: AggregateSignature
|
|
initialized = false
|
|
for validator_index in participants:
|
|
let
|
|
privkey = MockPrivKeys[validator_index]
|
|
signature = get_sync_committee_message_signature(
|
|
state.fork,
|
|
state.genesis_validators_root,
|
|
signature_slot,
|
|
block_root,
|
|
privkey)
|
|
if not initialized:
|
|
initialized = true
|
|
aggregateSig.init(signature)
|
|
else:
|
|
aggregateSig.aggregate(signature)
|
|
aggregateSig.finish.toValidatorSig
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/vFuture/tests/core/pyspec/eth2spec/test/helpers/light_client.py#L63-L93
|
|
proc get_sync_aggregate(
|
|
cfg: RuntimeConfig,
|
|
forked: ForkedHashedBeaconState,
|
|
num_participants = SYNC_COMMITTEE_SIZE.uint64,
|
|
signature_slot = FAR_FUTURE_SLOT): (SyncAggregate, Slot) =
|
|
template state(): auto = forked.altairData.data
|
|
|
|
let
|
|
block_root =
|
|
BeaconBlockHeader(
|
|
slot: state.latest_block_header.slot,
|
|
proposer_index: state.latest_block_header.proposer_index,
|
|
parent_root: state.latest_block_header.parent_root,
|
|
state_root: hash_tree_root(state),
|
|
body_root: state.latest_block_header.body_root
|
|
).hash_tree_root()
|
|
|
|
# By default, the sync committee signs the previous slot
|
|
sig_slot =
|
|
if signature_slot == FAR_FUTURE_SLOT:
|
|
state.slot + 1
|
|
else:
|
|
signature_slot
|
|
|
|
# Ensure correct sync committee and fork version are selected
|
|
var
|
|
signature_forked = assignClone(forked)
|
|
cache: StateCache
|
|
info: ForkedEpochInfo
|
|
template signature_state(): auto = signature_forked.altairData.data
|
|
process_slots(cfg, signature_forked[], sig_slot, cache, info, flags = {})
|
|
.expect("no failure")
|
|
|
|
# Fetch sync committee
|
|
let
|
|
all_pubkeys = signature_state.validators.mapIt(it.pubkey)
|
|
committee_indices = signature_state.current_sync_committee.pubkeys
|
|
.mapIt(all_pubkeys.find(it).ValidatorIndex)
|
|
committee_size = lenu64(committee_indices)
|
|
|
|
# By default, use full participation
|
|
doAssert committee_size == SYNC_COMMITTEE_SIZE
|
|
doAssert committee_size >= num_participants
|
|
|
|
# Compute sync aggregate
|
|
var sync_committee_bits: BitArray[SYNC_COMMITTEE_SIZE]
|
|
for i in 0 ..< num_participants:
|
|
sync_committee_bits[i] = true
|
|
let
|
|
sync_committee_signature = compute_aggregate_sync_committee_signature(
|
|
cfg,
|
|
signature_forked[],
|
|
sig_slot,
|
|
committee_indices[0 ..< num_participants],
|
|
block_root)
|
|
sync_aggregate = SyncAggregate(
|
|
sync_committee_bits: sync_committee_bits,
|
|
sync_committee_signature: sync_committee_signature
|
|
)
|
|
(sync_aggregate, sig_slot)
|
|
|
|
proc block_for_next_slot(
|
|
cfg: RuntimeConfig,
|
|
forked: var ForkedHashedBeaconState,
|
|
cache: var StateCache,
|
|
withAttestations = false): ForkedSignedBeaconBlock =
|
|
template state(): auto = forked.altairData.data
|
|
|
|
let attestations =
|
|
if withAttestations:
|
|
let block_root = withState(forked): state.latest_block_root
|
|
makeFullAttestations(forked, block_root, state.slot, cache)
|
|
else:
|
|
@[]
|
|
|
|
addTestBlock(
|
|
forked, cache, attestations = attestations, cfg = cfg)
|
|
|
|
let full_sync_committee_bits = block:
|
|
var res: BitArray[SYNC_COMMITTEE_SIZE]
|
|
res.bytes.fill(byte.high)
|
|
res
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.2.0-rc.1/tests/core/pyspec/eth2spec/test/helpers/light_client.py#L6-L15
|
|
func initialize_light_client_store(state: auto): LightClientStore =
|
|
LightClientStore(
|
|
finalized_header: BeaconBlockHeader(),
|
|
current_sync_committee: state.current_sync_committee,
|
|
next_sync_committee: state.next_sync_committee,
|
|
best_valid_update: none(altair.LightClientUpdate),
|
|
optimistic_header: BeaconBlockHeader(),
|
|
previous_max_active_participants: 0,
|
|
current_max_active_participants: 0,
|
|
)
|
|
|
|
suite "EF - Altair - Unittests - Sync protocol" & preset():
|
|
let
|
|
cfg = block:
|
|
var res = defaultRuntimeConfig
|
|
res.ALTAIR_FORK_EPOCH = GENESIS_EPOCH
|
|
res
|
|
genesisState = newClone(initGenesisState(cfg = cfg))
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/vFuture/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py#L25-L67
|
|
test "test_process_light_client_update_not_timeout":
|
|
let forked = assignClone(genesisState[])
|
|
template state(): auto = forked[].altairData.data
|
|
var store = initialize_light_client_store(state)
|
|
|
|
# Block at slot 1 doesn't increase sync committee period,
|
|
# so it won't update snapshot
|
|
var cache: StateCache
|
|
let
|
|
attested_block = block_for_next_slot(cfg, forked[], cache).altairData
|
|
attested_header = attested_block.toBeaconBlockHeader
|
|
|
|
# Sync committee signing the attested_header
|
|
(sync_aggregate, signature_slot) = get_sync_aggregate(cfg, forked[])
|
|
next_sync_committee = SyncCommittee()
|
|
next_sync_committee_branch = default(altair.NextSyncCommitteeBranch)
|
|
|
|
# Ensure that finality checkpoint is genesis
|
|
check state.finalized_checkpoint.epoch == 0
|
|
# Finality is unchanged
|
|
let
|
|
finality_header = BeaconBlockHeader()
|
|
finality_branch = default(altair.FinalityBranch)
|
|
|
|
update = altair.LightClientUpdate(
|
|
attested_header: attested_header,
|
|
next_sync_committee: next_sync_committee,
|
|
next_sync_committee_branch: next_sync_committee_branch,
|
|
finalized_header: finality_header,
|
|
finality_branch: finality_branch,
|
|
sync_aggregate: sync_aggregate,
|
|
signature_slot: signature_slot)
|
|
|
|
pre_store_finalized_header = store.finalized_header
|
|
|
|
res = process_light_client_update(
|
|
store, update, signature_slot, cfg, state.genesis_validators_root)
|
|
|
|
check:
|
|
res.isOk
|
|
store.finalized_header == pre_store_finalized_header
|
|
store.best_valid_update.get == update
|
|
store.optimistic_header == update.attested_header
|
|
store.current_max_active_participants > 0
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/vFuture/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py#L70-L116
|
|
test "test_process_light_client_update_at_period_boundary":
|
|
var forked = assignClone(genesisState[])
|
|
template state(): auto = forked[].altairData.data
|
|
var store = initialize_light_client_store(state)
|
|
|
|
# Forward to slot before next sync committee period so that next block is
|
|
# final one in period
|
|
var
|
|
cache: StateCache
|
|
info: ForkedEpochInfo
|
|
process_slots(
|
|
cfg, forked[], Slot(UPDATE_TIMEOUT - 2), cache, info, flags = {}
|
|
).expect("no failure")
|
|
let
|
|
store_period = sync_committee_period(store.optimistic_header.slot)
|
|
update_period = sync_committee_period(state.slot)
|
|
check: store_period == update_period
|
|
|
|
let
|
|
attested_block = block_for_next_slot(cfg, forked[], cache).altairData
|
|
attested_header = attested_block.toBeaconBlockHeader
|
|
|
|
# Sync committee signing the attested_header
|
|
(sync_aggregate, signature_slot) = get_sync_aggregate(cfg, forked[])
|
|
next_sync_committee = SyncCommittee()
|
|
next_sync_committee_branch = default(altair.NextSyncCommitteeBranch)
|
|
|
|
# Finality is unchanged
|
|
finality_header = BeaconBlockHeader()
|
|
finality_branch = default(altair.FinalityBranch)
|
|
|
|
update = altair.LightClientUpdate(
|
|
attested_header: attested_header,
|
|
next_sync_committee: next_sync_committee,
|
|
next_sync_committee_branch: next_sync_committee_branch,
|
|
finalized_header: finality_header,
|
|
finality_branch: finality_branch,
|
|
sync_aggregate: sync_aggregate,
|
|
signature_slot: signature_slot)
|
|
|
|
pre_store_finalized_header = store.finalized_header
|
|
|
|
res = process_light_client_update(
|
|
store, update, signature_slot, cfg, state.genesis_validators_root)
|
|
|
|
check:
|
|
res.isOk
|
|
store.finalized_header == pre_store_finalized_header
|
|
store.best_valid_update.get == update
|
|
store.optimistic_header == update.attested_header
|
|
store.current_max_active_participants > 0
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/vFuture/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py#L119-L166
|
|
test "process_light_client_update_timeout":
|
|
let forked = assignClone(genesisState[])
|
|
template state(): auto = forked[].altairData.data
|
|
var store = initialize_light_client_store(state)
|
|
|
|
# Forward to next sync committee period
|
|
var
|
|
cache: StateCache
|
|
info: ForkedEpochInfo
|
|
process_slots(
|
|
cfg, forked[], Slot(UPDATE_TIMEOUT), cache, info, flags = {}
|
|
).expect("no failure")
|
|
let
|
|
store_period = sync_committee_period(store.optimistic_header.slot)
|
|
update_period = sync_committee_period(state.slot)
|
|
check: store_period + 1 == update_period
|
|
|
|
let
|
|
attested_block = block_for_next_slot(cfg, forked[], cache).altairData
|
|
attested_header = attested_block.toBeaconBlockHeader
|
|
|
|
# Sync committee signing the attested_header
|
|
(sync_aggregate, signature_slot) = get_sync_aggregate(cfg, forked[])
|
|
|
|
# Sync committee is updated
|
|
template next_sync_committee(): auto = state.next_sync_committee
|
|
let
|
|
next_sync_committee_branch =
|
|
state.build_proof(altair.NEXT_SYNC_COMMITTEE_INDEX).get
|
|
|
|
# Finality is unchanged
|
|
finality_header = BeaconBlockHeader()
|
|
finality_branch = default(altair.FinalityBranch)
|
|
|
|
update = altair.LightClientUpdate(
|
|
attested_header: attested_header,
|
|
next_sync_committee: next_sync_committee,
|
|
next_sync_committee_branch: next_sync_committee_branch,
|
|
finalized_header: finality_header,
|
|
finality_branch: finality_branch,
|
|
sync_aggregate: sync_aggregate,
|
|
signature_slot: signature_slot)
|
|
|
|
pre_store_finalized_header = store.finalized_header
|
|
|
|
res = process_light_client_update(
|
|
store, update, signature_slot, cfg, state.genesis_validators_root)
|
|
|
|
check:
|
|
res.isOk
|
|
store.finalized_header == pre_store_finalized_header
|
|
store.best_valid_update.get == update
|
|
store.optimistic_header == update.attested_header
|
|
store.current_max_active_participants > 0
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/vFuture/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py#L169-L223
|
|
test "process_light_client_update_finality_updated":
|
|
let forked = assignClone(genesisState[])
|
|
template state(): auto = forked[].altairData.data
|
|
var store = initialize_light_client_store(state)
|
|
|
|
# Change finality
|
|
var
|
|
cache: StateCache
|
|
info: ForkedEpochInfo
|
|
blocks = newSeq[ForkedSignedBeaconBlock]()
|
|
process_slots(
|
|
cfg, forked[], Slot(SLOTS_PER_EPOCH * 2), cache, info, flags = {}).expect("no failure")
|
|
for slot in 0 ..< 3 * SLOTS_PER_EPOCH:
|
|
blocks.add block_for_next_slot(cfg, forked[], cache,
|
|
withAttestations = true)
|
|
# Ensure that finality checkpoint has changed
|
|
check: state.finalized_checkpoint.epoch == 3
|
|
# Ensure that it's same period
|
|
let
|
|
store_period = sync_committee_period(store.optimistic_header.slot)
|
|
update_period = sync_committee_period(state.slot)
|
|
check: store_period == update_period
|
|
|
|
let
|
|
attested_block = blocks[^1].altairData
|
|
attested_header = attested_block.toBeaconBlockHeader
|
|
|
|
# Sync committee signing the attested_header
|
|
(sync_aggregate, signature_slot) = get_sync_aggregate(cfg, forked[])
|
|
|
|
# Updated sync_committee and finality
|
|
next_sync_committee = SyncCommittee()
|
|
next_sync_committee_branch = default(altair.NextSyncCommitteeBranch)
|
|
finalized_block = blocks[SLOTS_PER_EPOCH - 1].altairData
|
|
finalized_header = finalized_block.toBeaconBlockHeader
|
|
check:
|
|
finalized_header.slot == start_slot(state.finalized_checkpoint.epoch)
|
|
finalized_header.hash_tree_root() == state.finalized_checkpoint.root
|
|
let
|
|
finality_branch = state.build_proof(altair.FINALIZED_ROOT_INDEX).get
|
|
|
|
update = altair.LightClientUpdate(
|
|
attested_header: attested_header,
|
|
next_sync_committee: next_sync_committee,
|
|
next_sync_committee_branch: next_sync_committee_branch,
|
|
finalized_header: finalized_header,
|
|
finality_branch: finality_branch,
|
|
sync_aggregate: sync_aggregate,
|
|
signature_slot: signature_slot)
|
|
|
|
res = process_light_client_update(
|
|
store, update, signature_slot, cfg, state.genesis_validators_root)
|
|
|
|
check:
|
|
res.isOk
|
|
store.finalized_header == update.finalized_header
|
|
store.best_valid_update.isNone
|
|
store.optimistic_header == update.attested_header
|
|
store.current_max_active_participants > 0
|