# beacon_chain # Copyright (c) 2018-2021 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. {.push raises: [Defect].} import std/[algorithm, collections/heapqueue, math, options, sequtils, tables], stew/assign2, json_serialization/std/sets, chronicles, ../extras, ./datatypes/[phase0, altair, merge], "."/[eth2_merkleization, forks, signatures, validator], ../../nbench/bench_lab export extras, forks, validator # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#increase_balance func increase_balance*(balance: var Gwei, delta: Gwei) = balance += delta func increase_balance*( state: var ForkyBeaconState, index: ValidatorIndex, delta: Gwei) = ## Increase the validator balance at index ``index`` by ``delta``. if delta != 0: # avoid dirtying the balance cache if not needed increase_balance(state.balances[index], delta) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#decrease_balance func decrease_balance*(balance: var Gwei, delta: Gwei) = balance = if delta > balance: 0'u64 else: balance - delta func decrease_balance*( state: var ForkyBeaconState, index: ValidatorIndex, delta: Gwei) = ## Decrease the validator balance at index ``index`` by ``delta``, with ## underflow protection. if delta != 0: # avoid dirtying the balance cache if not needed decrease_balance(state.balances[index], delta) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#deposits # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/beacon-chain.md#modified-process_deposit func get_validator_from_deposit*(deposit: DepositData): Validator = let amount = deposit.amount effective_balance = min( amount - amount mod EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE) Validator( pubkey: deposit.pubkey, withdrawal_credentials: deposit.withdrawal_credentials, activation_eligibility_epoch: FAR_FUTURE_EPOCH, activation_epoch: FAR_FUTURE_EPOCH, exit_epoch: FAR_FUTURE_EPOCH, withdrawable_epoch: FAR_FUTURE_EPOCH, effective_balance: effective_balance ) # https://github.com/ethereum/consensus-specs/blob/v1.1.0/specs/phase0/beacon-chain.md#compute_activation_exit_epoch func compute_activation_exit_epoch*(epoch: Epoch): Epoch = ## Return the epoch during which validator activations and exits initiated in ## ``epoch`` take effect. epoch + 1 + MAX_SEED_LOOKAHEAD # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#get_validator_churn_limit func get_validator_churn_limit*( cfg: RuntimeConfig, state: ForkyBeaconState, cache: var StateCache): uint64 = ## Return the validator churn limit for the current epoch. max( cfg.MIN_PER_EPOCH_CHURN_LIMIT, count_active_validators( state, state.get_current_epoch(), cache) div cfg.CHURN_LIMIT_QUOTIENT) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#initiate_validator_exit func initiate_validator_exit*(cfg: RuntimeConfig, state: var ForkyBeaconState, index: ValidatorIndex, cache: var StateCache) = ## Initiate the exit of the validator with index ``index``. # Return if validator already initiated exit let validator = addr state.validators[index] if validator.exit_epoch != FAR_FUTURE_EPOCH: return trace "Validator exiting", index = index, num_validators = state.validators.len, current_epoch = get_current_epoch(state), validator_slashed = validator.slashed, validator_withdrawable_epoch = validator.withdrawable_epoch, validator_exit_epoch = validator.exit_epoch, validator_effective_balance = validator.effective_balance var exit_queue_epoch = compute_activation_exit_epoch(get_current_epoch(state)) # Compute max exit epoch for idx in 0.. exit_queue_epoch: exit_queue_epoch = exit_epoch var exit_queue_churn: int for idx in 0..= get_validator_churn_limit(cfg, state, cache): exit_queue_epoch += 1 # Set validator exit epoch and withdrawable epoch validator.exit_epoch = exit_queue_epoch validator.withdrawable_epoch = validator.exit_epoch + cfg.MIN_VALIDATOR_WITHDRAWABILITY_DELAY # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#slash_validator # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/beacon-chain.md#modified-slash_validator proc slash_validator*( cfg: RuntimeConfig, state: var ForkyBeaconState, slashed_index: ValidatorIndex, cache: var StateCache) = ## Slash the validator with index ``index``. let epoch = get_current_epoch(state) initiate_validator_exit(cfg, state, slashed_index, cache) let validator = addr state.validators[slashed_index] trace "slash_validator: ejecting validator via slashing (validator_leaving)", index = slashed_index, num_validators = state.validators.len, current_epoch = get_current_epoch(state), validator_slashed = validator.slashed, validator_withdrawable_epoch = validator.withdrawable_epoch, validator_exit_epoch = validator.exit_epoch, validator_effective_balance = validator.effective_balance validator.slashed = true validator.withdrawable_epoch = max(validator.withdrawable_epoch, epoch + EPOCHS_PER_SLASHINGS_VECTOR) state.slashings[int(epoch mod EPOCHS_PER_SLASHINGS_VECTOR)] += validator.effective_balance # TODO Consider whether this is better than splitting the functions apart; in # each case, tradeoffs. Here, it's just changing a couple of constants. when state is phase0.BeaconState: decrease_balance(state, slashed_index, validator.effective_balance div MIN_SLASHING_PENALTY_QUOTIENT) elif state is altair.BeaconState or state is merge.BeaconState: decrease_balance(state, slashed_index, validator.effective_balance div MIN_SLASHING_PENALTY_QUOTIENT_ALTAIR) else: raiseAssert "invalid BeaconState type" # The rest doesn't make sense without there being any proposer index, so skip let proposer_index = get_beacon_proposer_index(state, cache) if proposer_index.isNone: debug "No beacon proposer index and probably no active validators" return # Apply proposer and whistleblower rewards let # Spec has whistleblower_index as optional param, but it's never used. whistleblower_index = proposer_index.get whistleblower_reward = (validator.effective_balance div WHISTLEBLOWER_REWARD_QUOTIENT).Gwei proposer_reward = when state is phase0.BeaconState: whistleblower_reward div PROPOSER_REWARD_QUOTIENT elif state is altair.BeaconState or state is merge.BeaconState: whistleblower_reward * PROPOSER_WEIGHT div WEIGHT_DENOMINATOR else: raiseAssert "invalid BeaconState type" increase_balance(state, proposer_index.get, proposer_reward) # TODO: evaluate if spec bug / underflow can be triggered doAssert(whistleblower_reward >= proposer_reward, "Spec bug: underflow in slash_validator") increase_balance( state, whistleblower_index, whistleblower_reward - proposer_reward) func genesis_time_from_eth1_timestamp*(cfg: RuntimeConfig, eth1_timestamp: uint64): uint64 = eth1_timestamp + cfg.GENESIS_DELAY # https://github.com/ethereum/consensus-specs/blob/v1.0.1/specs/phase0/beacon-chain.md#genesis proc initialize_beacon_state_from_eth1*( cfg: RuntimeConfig, eth1_block_hash: Eth2Digest, eth1_timestamp: uint64, deposits: openArray[DepositData], flags: UpdateFlags = {}): phase0.BeaconStateRef {.nbench.} = ## Get the genesis ``BeaconState``. ## ## Before the beacon chain starts, validators will register in the Eth1 chain ## and deposit ETH. When enough many validators have registered, a ## `ChainStart` log will be emitted and the beacon chain can start beaconing. ## ## Because the state root hash is part of the genesis block, the beacon state ## must be calculated before creating the genesis block. # Induct validators # Not in spec: the system doesn't work unless there are at least SLOTS_PER_EPOCH # validators - there needs to be at least one member in each committee - # good to know for testing, though arguably the system is not that useful at # at that point :) doAssert deposits.lenu64 >= SLOTS_PER_EPOCH var state = phase0.BeaconStateRef( fork: genesisFork(cfg), genesis_time: genesis_time_from_eth1_timestamp(cfg, eth1_timestamp), eth1_data: Eth1Data(block_hash: eth1_block_hash, deposit_count: uint64(len(deposits))), latest_block_header: BeaconBlockHeader( body_root: hash_tree_root(default(phase0.BeaconBlockBody)))) # Seed RANDAO with Eth1 entropy state.randao_mixes.fill(eth1_block_hash) var merkleizer = createMerkleizer(2'i64^DEPOSIT_CONTRACT_TREE_DEPTH) for i, deposit in deposits: let htr = hash_tree_root(deposit) merkleizer.addChunk(htr.data) # This is already known in the Eth1 monitor, but it would be too # much work to refactor all the existing call sites in the test suite state.eth1_data.deposit_root = mixInLength(merkleizer.getFinalHash(), deposits.len) state.eth1_deposit_index = deposits.lenu64 var pubkeyToIndex = initTable[ValidatorPubKey, int]() for idx, deposit in deposits: let pubkey = deposit.pubkey amount = deposit.amount pubkeyToIndex.withValue(pubkey, foundIdx) do: # Increase balance by deposit amount increase_balance(state[], ValidatorIndex foundIdx[], amount) do: if skipBlsValidation in flags or verify_deposit_signature(cfg, deposit): pubkeyToIndex[pubkey] = state.validators.len if not state.validators.add(get_validator_from_deposit(deposit)): raiseAssert "too many validators" if not state.balances.add(amount): raiseAssert "same as validators" else: # Invalid deposits are perfectly possible trace "Skipping deposit with invalid signature", deposit = shortLog(deposit) # Process activations for validator_index in 0 ..< state.validators.len: let balance = state.balances.asSeq()[validator_index] validator = addr state.validators[validator_index] validator.effective_balance = min( balance - balance mod EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE) if validator.effective_balance == MAX_EFFECTIVE_BALANCE: validator.activation_eligibility_epoch = GENESIS_EPOCH validator.activation_epoch = GENESIS_EPOCH # Set genesis validators root for domain separation and chain versioning state.genesis_validators_root = hash_tree_root(state.validators) state proc initialize_hashed_beacon_state_from_eth1*( cfg: RuntimeConfig, eth1_block_hash: Eth2Digest, eth1_timestamp: uint64, deposits: openArray[DepositData], flags: UpdateFlags = {}): phase0.HashedBeaconState = let genesisState = initialize_beacon_state_from_eth1( cfg, eth1_block_hash, eth1_timestamp, deposits, flags) phase0.HashedBeaconState( data: genesisState[], root: hash_tree_root(genesisState[])) # https://github.com/ethereum/consensus-specs/blob/v1.1.0/specs/phase0/beacon-chain.md#genesis-block func get_initial_beacon_block*(state: phase0.BeaconState): phase0.TrustedSignedBeaconBlock = # The genesis block is implicitly trusted let message = phase0.TrustedBeaconBlock( slot: state.slot, state_root: hash_tree_root(state),) # parent_root, randao_reveal, eth1_data, signature, and body automatically # initialized to default values. phase0.TrustedSignedBeaconBlock( message: message, root: hash_tree_root(message)) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#get_block_root_at_slot func get_block_root_at_slot*(state: ForkyBeaconState, slot: Slot): Eth2Digest = ## Return the block root at a recent ``slot``. # Potential overflow/wrap shouldn't occur, as get_block_root_at_slot() called # from internally controlled sources, but flag this explicitly, in case. doAssert slot + SLOTS_PER_HISTORICAL_ROOT > slot doAssert state.slot <= slot + SLOTS_PER_HISTORICAL_ROOT doAssert slot < state.slot state.block_roots[slot mod SLOTS_PER_HISTORICAL_ROOT] func get_block_root_at_slot*(state: ForkedHashedBeaconState, slot: Slot): Eth2Digest = ## Return the block root at a recent ``slot``. withState(state): get_block_root_at_slot(state.data, slot) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#get_block_root func get_block_root*(state: ForkyBeaconState, epoch: Epoch): Eth2Digest = ## Return the block root at the start of a recent ``epoch``. get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch)) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#get_total_balance template get_total_balance( state: ForkyBeaconState, validator_indices: untyped): Gwei = ## Return the combined effective balance of the ``indices``. ## ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero. ## Math safe up to ~10B ETH, afterwhich this overflows uint64. var res = 0.Gwei for validator_index in validator_indices: res += state.validators.asSeq()[validator_index].effective_balance max(EFFECTIVE_BALANCE_INCREMENT, res) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#is_eligible_for_activation_queue func is_eligible_for_activation_queue*(validator: Validator): bool = ## Check if ``validator`` is eligible to be placed into the activation queue. validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH and validator.effective_balance == MAX_EFFECTIVE_BALANCE # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#is_eligible_for_activation func is_eligible_for_activation*(state: ForkyBeaconState, validator: Validator): bool = ## Check if ``validator`` is eligible for activation. # Placement in queue is finalized validator.activation_eligibility_epoch <= state.finalized_checkpoint.epoch and # Has not yet been activated validator.activation_epoch == FAR_FUTURE_EPOCH # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#is_valid_indexed_attestation proc is_valid_indexed_attestation*( state: ForkyBeaconState, indexed_attestation: SomeIndexedAttestation, flags: UpdateFlags): Result[void, cstring] = ## Check if ``indexed_attestation`` is not empty, has sorted and unique ## indices and has a valid aggregate signature. template is_sorted_and_unique(s: untyped): bool = var res = true for i in 1 ..< s.len: if s[i - 1].uint64 >= s[i].uint64: res = false break res if len(indexed_attestation.attesting_indices) == 0: return err("indexed_attestation: no attesting indices") # Not from spec, but this function gets used in front-line roles, not just # behind firewall. let num_validators = state.validators.lenu64 if anyIt(indexed_attestation.attesting_indices, it >= num_validators): return err("indexed attestation: not all indices valid validators") if not is_sorted_and_unique(indexed_attestation.attesting_indices): return err("indexed attestation: indices not sorted and unique") # Verify aggregate signature if not (skipBLSValidation in flags or indexed_attestation.signature is TrustedSig): let pubkeys = mapIt( indexed_attestation.attesting_indices, state.validators[it].pubkey) if not verify_attestation_signature( state.fork, state.genesis_validators_root, indexed_attestation.data, pubkeys, indexed_attestation.signature): return err("indexed attestation: signature verification failure") ok() # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#get_attesting_indices func get_attesting_indices*(state: ForkyBeaconState, data: AttestationData, bits: CommitteeValidatorsBits, cache: var StateCache): seq[ValidatorIndex] = ## Return the set of attesting indices corresponding to ``data`` and ``bits``. var res: seq[ValidatorIndex] # Can't be an iterator due to https://github.com/nim-lang/Nim/issues/18188 if bits.lenu64 != get_beacon_committee_len( state, data.slot, data.index.CommitteeIndex, cache): trace "get_attesting_indices: inconsistent aggregation and committee length" else: var i = 0 for index in get_beacon_committee( state, data.slot, data.index.CommitteeIndex, cache): if bits[i]: res.add index inc i res proc get_attesting_indices*(state: ForkedHashedBeaconState; data: AttestationData; bits: CommitteeValidatorsBits; cache: var StateCache): seq[ValidatorIndex] = # TODO when https://github.com/nim-lang/Nim/issues/18188 fixed, use an # iterator var idxBuf: seq[ValidatorIndex] withState(state): for vidx in state.data.get_attesting_indices(data, bits, cache): idxBuf.add vidx idxBuf proc is_valid_indexed_attestation*( state: ForkyBeaconState, attestation: SomeAttestation, flags: UpdateFlags, cache: var StateCache): Result[void, cstring] = # This is a variation on `is_valid_indexed_attestation` that works directly # with an attestation instead of first constructing an `IndexedAttestation` # and then validating it - for the purpose of validating the signature, the # order doesn't matter and we can proceed straight to validating the # signature instead let sigs = attestation.aggregation_bits.countOnes() if sigs == 0: return err("is_valid_indexed_attestation: no attesting indices") # Verify aggregate signature if not (skipBLSValidation in flags or attestation.signature is TrustedSig): var pubkeys = newSeqOfCap[ValidatorPubKey](sigs) for index in get_attesting_indices( state, attestation.data, attestation.aggregation_bits, cache): pubkeys.add(state.validators[index].pubkey) if not verify_attestation_signature( state.fork, state.genesis_validators_root, attestation.data, pubkeys, attestation.signature): return err("indexed attestation: signature verification failure") ok() # Attestation validation # ------------------------------------------------------------------------------------------ # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#attestations # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/p2p-interface.md#beacon_attestation_subnet_id func check_attestation_slot_target*(data: AttestationData): Result[void, cstring] = if not (data.target.epoch == compute_epoch_at_slot(data.slot)): return err("Target epoch doesn't match attestation slot") ok() func check_attestation_target_epoch( data: AttestationData, current_epoch: Epoch): Result[void, cstring] = if not (data.target.epoch == get_previous_epoch(current_epoch) or data.target.epoch == current_epoch): return err("Target epoch not current or previous epoch") ok() func check_attestation_inclusion(data: AttestationData, current_slot: Slot): Result[void, cstring] = # Check for overflow static: doAssert SLOTS_PER_EPOCH >= MIN_ATTESTATION_INCLUSION_DELAY if data.slot + SLOTS_PER_EPOCH <= data.slot: return err("attestation data.slot overflow, malicious?") if not (data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= current_slot): return err("Attestation too new") if not (current_slot <= data.slot + SLOTS_PER_EPOCH): return err("Attestation too old") ok() func check_attestation_index( data: AttestationData, committees_per_slot: uint64): Result[void, cstring] = if not (data.index < committees_per_slot): return err("Data index exceeds committee count") ok() # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/beacon-chain.md#get_attestation_participation_flag_indices func get_attestation_participation_flag_indices(state: altair.BeaconState | merge.BeaconState, data: AttestationData, inclusion_delay: uint64): seq[int] = ## Return the flag indices that are satisfied by an attestation. let justified_checkpoint = if data.target.epoch == get_current_epoch(state): state.current_justified_checkpoint else: state.previous_justified_checkpoint # Matching roots let is_matching_source = data.source == justified_checkpoint is_matching_target = is_matching_source and data.target.root == get_block_root(state, data.target.epoch) is_matching_head = is_matching_target and data.beacon_block_root == get_block_root_at_slot(state, data.slot) # TODO probably this needs to be robustly failable doAssert is_matching_source var participation_flag_indices: seq[int] if is_matching_source and inclusion_delay <= integer_squareroot(SLOTS_PER_EPOCH): participation_flag_indices.add(TIMELY_SOURCE_FLAG_INDEX) if is_matching_target and inclusion_delay <= SLOTS_PER_EPOCH: participation_flag_indices.add(TIMELY_TARGET_FLAG_INDEX) if is_matching_head and inclusion_delay == MIN_ATTESTATION_INCLUSION_DELAY: participation_flag_indices.add(TIMELY_HEAD_FLAG_INDEX) participation_flag_indices # TODO these aren't great here # TODO these duplicate some stuff in state_transition_epoch which uses TotalBalances # better to centralize around that if feasible # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/phase0/beacon-chain.md#get_total_active_balance func get_total_active_balance*(state: ForkyBeaconState, cache: var StateCache): Gwei = ## Return the combined effective balance of the active validators. # Note: ``get_total_balance`` returns ``EFFECTIVE_BALANCE_INCREMENT`` Gwei # minimum to avoid divisions by zero. let epoch = state.get_current_epoch() get_total_balance( state, cache.get_shuffled_active_validator_indices(state, epoch)) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/beacon-chain.md#get_base_reward_per_increment func get_base_reward_per_increment_sqrt*( total_active_balance_sqrt: uint64): Gwei = EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR div total_active_balance_sqrt func get_base_reward_per_increment*( total_active_balance: Gwei): Gwei = get_base_reward_per_increment_sqrt(integer_squareroot(total_active_balance)) # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/beacon-chain.md#get_base_reward func get_base_reward( state: altair.BeaconState | merge.BeaconState, index: ValidatorIndex, base_reward_per_increment: Gwei): Gwei = ## Return the base reward for the validator defined by ``index`` with respect ## to the current ``state``. let increments = state.validators[index].effective_balance div EFFECTIVE_BALANCE_INCREMENT increments * base_reward_per_increment # https://github.com/ethereum/consensus-specs/blob/v1.1.0/specs/phase0/beacon-chain.md#attestations proc check_attestation*( state: ForkyBeaconState, attestation: SomeAttestation, flags: UpdateFlags, cache: var StateCache): Result[void, cstring] = ## Check that an attestation follows the rules of being included in the state ## at the current slot. When acting as a proposer, the same rules need to ## be followed! let data = attestation.data ? check_attestation_target_epoch(data, state.get_current_epoch()) ? check_attestation_slot_target(data) ? check_attestation_inclusion(data, state.slot) ? check_attestation_index( data, get_committee_count_per_slot(state, data.target.epoch, cache)) let committee_len = get_beacon_committee_len( state, data.slot, data.index.CommitteeIndex, cache) if attestation.aggregation_bits.lenu64 != committee_len: return err("Inconsistent aggregation and committee length") if data.target.epoch == get_current_epoch(state): if not (data.source == state.current_justified_checkpoint): return err("FFG data not matching current justified epoch") else: if not (data.source == state.previous_justified_checkpoint): return err("FFG data not matching previous justified epoch") ? is_valid_indexed_attestation(state, attestation, flags, cache) ok() proc process_attestation*( state: var ForkyBeaconState, attestation: SomeAttestation, flags: UpdateFlags, base_reward_per_increment: Gwei, cache: var StateCache): Result[void, cstring] {.nbench.} = # In the spec, attestation validation is mixed with state mutation, so here # we've split it into two functions so that the validation logic can be # reused when looking for suitable blocks to include in attestations. # # TODO this should be two separate functions, but # https://github.com/nim-lang/Nim/issues/18202 means that this being called # by process_operations() in state_transition_block fails that way. let proposer_index = get_beacon_proposer_index(state, cache) if proposer_index.isNone: return err("process_attestation: no beacon proposer index and probably no active validators") ? check_attestation(state, attestation, flags, cache) # For phase0 template addPendingAttestation(attestations: typed) = # The genericSeqAssign generated by the compiler to copy the attestation # data sadly is a processing hotspot - the business with the addDefault # pointer is here simply to work around the poor codegen var pa = attestations.addDefault() if pa.isNil: return err("process_attestation: too many pending attestations") assign(pa[].aggregation_bits, attestation.aggregation_bits) pa[].data = attestation.data pa[].inclusion_delay = state.slot - attestation.data.slot pa[].proposer_index = proposer_index.get().uint64 # For Altair template updateParticipationFlags(epoch_participation: untyped) = var proposer_reward_numerator = 0'u64 # Participation flag indices let participation_flag_indices = get_attestation_participation_flag_indices( state, attestation.data, state.slot - attestation.data.slot) for index in get_attesting_indices(state, attestation.data, attestation.aggregation_bits, cache): for flag_index, weight in PARTICIPATION_FLAG_WEIGHTS: if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index): epoch_participation[index] = add_flag(epoch_participation[index], flag_index) proposer_reward_numerator += get_base_reward( state, index, base_reward_per_increment) * weight.uint64 # these are all valid, #TODO statically verify or do it type-safely # Reward proposer let # TODO use correct type at source proposer_reward_denominator = (WEIGHT_DENOMINATOR.uint64 - PROPOSER_WEIGHT.uint64) * WEIGHT_DENOMINATOR.uint64 div PROPOSER_WEIGHT.uint64 proposer_reward = Gwei(proposer_reward_numerator div proposer_reward_denominator) increase_balance(state, proposer_index.get, proposer_reward) when state is phase0.BeaconState: doAssert base_reward_per_increment == 0.Gwei if attestation.data.target.epoch == get_current_epoch(state): addPendingAttestation(state.current_epoch_attestations) else: addPendingAttestation(state.previous_epoch_attestations) elif state is altair.BeaconState or state is merge.BeaconState: doAssert base_reward_per_increment > 0.Gwei if attestation.data.target.epoch == get_current_epoch(state): updateParticipationFlags(state.current_epoch_participation) else: updateParticipationFlags(state.previous_epoch_participation) else: static: doAssert false ok() # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/beacon-chain.md#get_next_sync_committee_indices func get_next_sync_committee_keys(state: altair.BeaconState | merge.BeaconState): array[SYNC_COMMITTEE_SIZE, ValidatorPubKey] = ## Return the sequence of sync committee indices (which may include ## duplicate indices) for the next sync committee, given a ``state`` at a ## sync committee period boundary. let epoch = get_current_epoch(state) + 1 const MAX_RANDOM_BYTE = 255 let active_validator_indices = get_active_validator_indices(state, epoch) active_validator_count = uint64(len(active_validator_indices)) seed = get_seed(state, epoch, DOMAIN_SYNC_COMMITTEE) var i = 0'u64 index = 0 res: array[SYNC_COMMITTEE_SIZE, ValidatorPubKey] hash_buffer: array[40, byte] hash_buffer[0..31] = seed.data while index < SYNC_COMMITTEE_SIZE: hash_buffer[32..39] = uint_to_bytes8(uint64(i div 32)) let shuffled_index = compute_shuffled_index(uint64(i mod active_validator_count), active_validator_count, seed) candidate_index = active_validator_indices[shuffled_index] random_byte = eth2digest(hash_buffer).data[i mod 32] effective_balance = state.validators[candidate_index].effective_balance if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte: res[index] = state.validators[candidate_index].pubkey inc index i += 1'u64 res # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/beacon-chain.md#get_next_sync_committee proc get_next_sync_committee*(state: altair.BeaconState | merge.BeaconState): SyncCommittee = ## Return the *next* sync committee for a given ``state``. var res: SyncCommittee res.pubkeys.data = get_next_sync_committee_keys(state) # see signatures_batch, TODO shouldn't be here # Deposit processing ensures all keys are valid var attestersAgg: AggregatePublicKey attestersAgg.init(res.pubkeys.data[0].loadWithCache().get) for i in 1 ..< res.pubkeys.data.len: attestersAgg.aggregate(res.pubkeys.data[i].loadWithCache().get) res.aggregate_pubkey = finish(attestersAgg).toPubKey() res # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/altair/fork.md#upgrading-the-state func translate_participation( state: var altair.BeaconState, pending_attestations: openArray[phase0.PendingAttestation]) = var cache = StateCache() for attestation in pending_attestations: let data = attestation.data inclusion_delay = attestation.inclusion_delay # Translate attestation inclusion info to flag indices participation_flag_indices = get_attestation_participation_flag_indices(state, data, inclusion_delay) # Apply flags to all attesting validators for index in get_attesting_indices( state, data, attestation.aggregation_bits, cache): for flag_index in participation_flag_indices: state.previous_epoch_participation[index] = add_flag(state.previous_epoch_participation[index], flag_index) proc upgrade_to_altair*(cfg: RuntimeConfig, pre: phase0.BeaconState): ref altair.BeaconState = var empty_participation = HashList[ParticipationFlags, Limit VALIDATOR_REGISTRY_LIMIT]() inactivity_scores = HashList[uint64, Limit VALIDATOR_REGISTRY_LIMIT]() doAssert empty_participation.data.setLen(pre.validators.len) empty_participation.resetCache() doAssert inactivity_scores.data.setLen(pre.validators.len) inactivity_scores.resetCache() var post = (ref altair.BeaconState)( genesis_time: pre.genesis_time, genesis_validators_root: pre.genesis_validators_root, slot: pre.slot, fork: altairFork(cfg), # History latest_block_header: pre.latest_block_header, block_roots: pre.block_roots, state_roots: pre.state_roots, historical_roots: pre.historical_roots, # Eth1 eth1_data: pre.eth1_data, eth1_data_votes: pre.eth1_data_votes, eth1_deposit_index: pre.eth1_deposit_index, # Registry validators: pre.validators, balances: pre.balances, # Randomness randao_mixes: pre.randao_mixes, # Slashings slashings: pre.slashings, # Attestations previous_epoch_participation: empty_participation, current_epoch_participation: empty_participation, # 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, # Inactivity inactivity_scores: inactivity_scores ) # Fill in previous epoch participation from the pre state's pending # attestations translate_participation(post[], pre.previous_epoch_attestations.asSeq) # Fill in sync committees # Note: A duplicate committee is assigned for the current and next committee # at the fork boundary post[].current_sync_committee = get_next_sync_committee(post[]) post[].next_sync_committee = get_next_sync_committee(post[]) post # https://github.com/ethereum/consensus-specs/blob/v1.1.3/specs/merge/fork.md#upgrading-the-state func upgrade_to_merge*(cfg: RuntimeConfig, pre: altair.BeaconState): ref merge.BeaconState = let epoch = get_current_epoch(pre) (ref merge.BeaconState)( # Versioning genesis_time: pre.genesis_time, genesis_validators_root: pre.genesis_validators_root, slot: pre.slot, fork: Fork( previous_version: pre.fork.current_version, current_version: cfg.MERGE_FORK_VERSION, epoch: epoch, ), # History latest_block_header: pre.latest_block_header, block_roots: pre.block_roots, state_roots: pre.state_roots, historical_roots: pre.historical_roots, # Eth1 eth1_data: pre.eth1_data, eth1_data_votes: pre.eth1_data_votes, eth1_deposit_index: pre.eth1_deposit_index, # Registry validators: pre.validators, balances: pre.balances, # Randomness randao_mixes: pre.randao_mixes, # Slashings slashings: pre.slashings, # Participation previous_epoch_participation: pre.previous_epoch_participation, current_epoch_participation: pre.current_epoch_participation, # 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, # Inactivity inactivity_scores: pre.inactivity_scores, # Sync current_sync_committee: pre.current_sync_committee, next_sync_committee: pre.next_sync_committee, # Execution-layer latest_execution_payload_header: ExecutionPayloadHeader() )