2018-08-21 16:21:45 +00:00
|
|
|
# beacon_chain
|
2020-01-27 11:36:17 +00:00
|
|
|
# Copyright (c) 2018-2020 Status Research & Development GmbH
|
2018-08-21 16:21:45 +00:00
|
|
|
# Licensed and distributed under either of
|
2019-11-25 15:30:02 +00:00
|
|
|
# * 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).
|
2018-08-21 16:21:45 +00:00
|
|
|
# at your option. This file may not be copied, modified, or distributed except according to those terms.
|
|
|
|
|
2018-12-04 18:45:30 +00:00
|
|
|
# State transition, as described in
|
|
|
|
# https://github.com/ethereum/eth2.0-specs/blob/master/specs/core/0_beacon-chain.md#beacon-chain-state-transition-function
|
2018-08-21 16:21:45 +00:00
|
|
|
#
|
2018-12-04 18:45:30 +00:00
|
|
|
# The purpose of this code right is primarily educational, to help piece
|
|
|
|
# together the mechanics of the beacon state and to discover potential problem
|
2020-03-05 12:52:10 +00:00
|
|
|
# areas. The entry point is `state_transition` which is at the bottom of the file!
|
2018-12-04 18:45:30 +00:00
|
|
|
#
|
|
|
|
# General notes about the code (TODO):
|
|
|
|
# * Weird styling - the sections taken from the spec use python styling while
|
|
|
|
# the others use NEP-1 - helps grepping identifiers in spec
|
|
|
|
# * We mix procedural and functional styles for no good reason, except that the
|
|
|
|
# spec does so also.
|
2019-01-29 04:15:00 +00:00
|
|
|
# * For indices, we get a mix of uint64, ValidatorIndex and int - this is currently
|
2018-12-04 18:45:30 +00:00
|
|
|
# swept under the rug with casts
|
|
|
|
# * Sane error handling is missing in most cases (yay, we'll get the chance to
|
|
|
|
# debate exceptions again!)
|
|
|
|
# When updating the code, add TODO sections to mark where there are clear
|
|
|
|
# improvements to be made - other than that, keep things similar to spec for
|
|
|
|
# now.
|
2018-08-21 16:21:45 +00:00
|
|
|
|
2020-04-22 05:53:02 +00:00
|
|
|
{.push raises: [Defect].}
|
|
|
|
|
2018-09-26 16:26:39 +00:00
|
|
|
import
|
2020-05-29 06:10:20 +00:00
|
|
|
tables,
|
2020-04-11 17:41:50 +00:00
|
|
|
chronicles,
|
2020-05-03 17:44:04 +00:00
|
|
|
stew/results,
|
2020-06-03 13:52:02 +00:00
|
|
|
./extras, ./ssz/merkleization, metrics,
|
2020-04-09 09:41:02 +00:00
|
|
|
./spec/[datatypes, crypto, digest, helpers, validator],
|
2019-12-20 16:14:43 +00:00
|
|
|
./spec/[state_transition_block, state_transition_epoch],
|
2020-06-08 18:53:51 +00:00
|
|
|
../nbench/bench_lab
|
2018-12-13 16:00:55 +00:00
|
|
|
|
2019-10-06 04:31:50 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-metrics/blob/master/metrics.md#additional-metrics
|
|
|
|
declareGauge beacon_current_validators, """Number of status="pending|active|exited|withdrawable" validators in current epoch""" # On epoch transition
|
|
|
|
declareGauge beacon_previous_validators, """Number of status="pending|active|exited|withdrawable" validators in previous epoch""" # On epoch transition
|
|
|
|
|
2020-05-14 22:54:10 +00:00
|
|
|
func get_epoch_validator_count(state: BeaconState): int64 {.nbench.} =
|
2019-10-06 04:31:50 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-metrics/blob/master/metrics.md#additional-metrics
|
|
|
|
#
|
|
|
|
# This O(n) loop doesn't add to the algorithmic complexity of the epoch
|
|
|
|
# transition -- registry update already does this. It is not great, but
|
|
|
|
# isn't new, either. If profiling shows issues some of this can be loop
|
|
|
|
# fusion'ed.
|
|
|
|
for index, validator in state.validators:
|
|
|
|
# These work primarily for the `beacon_current_validators` metric defined
|
|
|
|
# as 'Number of status="pending|active|exited|withdrawable" validators in
|
|
|
|
# current epoch'. This is, in principle, equivalent to checking whether a
|
|
|
|
# validator's either at less than MAX_EFFECTIVE_BALANCE, or has withdrawn
|
|
|
|
# already because withdrawable_epoch has passed, which more precisely has
|
|
|
|
# intuitive meaning of all-the-current-relevant-validators. So, check for
|
|
|
|
# not-(either (not-even-pending) or withdrawn). That is validators change
|
|
|
|
# from not-even-pending to pending to active to exited to withdrawable to
|
|
|
|
# withdrawn, and this avoids bugs on potential edge cases and off-by-1's.
|
|
|
|
if (validator.activation_epoch != FAR_FUTURE_EPOCH or
|
|
|
|
validator.effective_balance > MAX_EFFECTIVE_BALANCE) and
|
|
|
|
validator.withdrawable_epoch > get_current_epoch(state):
|
|
|
|
result += 1
|
|
|
|
|
2020-05-20 08:46:31 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-specs/blob/v0.11.3/specs/phase0/beacon-chain.md#verify_block_signature
|
2020-04-09 09:41:02 +00:00
|
|
|
proc verify_block_signature*(
|
|
|
|
state: BeaconState, signedBlock: SignedBeaconBlock): bool {.nbench.} =
|
|
|
|
if signedBlock.message.proposer_index >= state.validators.len.uint64:
|
|
|
|
notice "Invalid proposer index in block",
|
|
|
|
blck = shortLog(signedBlock.message)
|
|
|
|
return false
|
|
|
|
|
|
|
|
let
|
|
|
|
proposer = state.validators[signedBlock.message.proposer_index]
|
|
|
|
domain = get_domain(
|
|
|
|
state, DOMAIN_BEACON_PROPOSER,
|
|
|
|
compute_epoch_at_slot(signedBlock.message.slot))
|
|
|
|
signing_root = compute_signing_root(signedBlock.message, domain)
|
|
|
|
|
|
|
|
if not bls_verify(proposer.pubKey, signing_root.data, signedBlock.signature):
|
|
|
|
notice "Block: signature verification failed",
|
|
|
|
blck = shortLog(signedBlock),
|
|
|
|
signingRoot = shortLog(signing_root)
|
|
|
|
return false
|
|
|
|
|
|
|
|
true
|
|
|
|
|
2020-05-20 13:50:03 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-specs/blob/v0.11.3/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
2018-12-21 22:37:46 +00:00
|
|
|
proc verifyStateRoot(state: BeaconState, blck: BeaconBlock): bool =
|
2019-09-05 19:52:34 +00:00
|
|
|
# This is inlined in state_transition(...) in spec.
|
2019-03-25 16:46:31 +00:00
|
|
|
let state_root = hash_tree_root(state)
|
2018-12-21 22:37:46 +00:00
|
|
|
if state_root != blck.state_root:
|
2019-01-25 17:35:22 +00:00
|
|
|
notice "Block: root verification failed",
|
|
|
|
block_state_root = blck.state_root, state_root
|
2018-12-21 22:37:46 +00:00
|
|
|
false
|
|
|
|
else:
|
|
|
|
true
|
|
|
|
|
2020-04-26 19:13:33 +00:00
|
|
|
type
|
2020-04-28 08:08:32 +00:00
|
|
|
RollbackProc* = proc(v: var BeaconState) {.gcsafe, raises: [Defect].}
|
2020-04-26 19:13:33 +00:00
|
|
|
|
|
|
|
proc noRollback*(state: var BeaconState) =
|
|
|
|
trace "Skipping rollback of broken state"
|
|
|
|
|
2020-04-30 06:44:19 +00:00
|
|
|
type
|
|
|
|
RollbackHashedProc* = proc(state: var HashedBeaconState) {.gcsafe.}
|
2018-12-27 20:14:37 +00:00
|
|
|
|
2019-07-15 21:10:40 +00:00
|
|
|
# Hashed-state transition functions
|
|
|
|
# ---------------------------------------------------------------
|
2019-05-04 14:10:45 +00:00
|
|
|
|
2020-05-20 08:46:31 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-specs/blob/v0.11.3/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
2020-04-30 06:44:19 +00:00
|
|
|
func process_slot*(state: var HashedBeaconState) {.nbench.} =
|
2019-06-14 07:50:14 +00:00
|
|
|
# Cache state root
|
2019-05-04 14:10:45 +00:00
|
|
|
let previous_slot_state_root = state.root
|
2019-07-01 09:42:37 +00:00
|
|
|
state.data.state_roots[state.data.slot mod SLOTS_PER_HISTORICAL_ROOT] =
|
2019-05-04 14:10:45 +00:00
|
|
|
previous_slot_state_root
|
|
|
|
|
2019-06-14 07:50:14 +00:00
|
|
|
# Cache latest block header state root
|
2019-05-04 14:10:45 +00:00
|
|
|
if state.data.latest_block_header.state_root == ZERO_HASH:
|
|
|
|
state.data.latest_block_header.state_root = previous_slot_state_root
|
|
|
|
|
2019-06-14 07:50:14 +00:00
|
|
|
# Cache block root
|
2019-07-01 07:53:42 +00:00
|
|
|
state.data.block_roots[state.data.slot mod SLOTS_PER_HISTORICAL_ROOT] =
|
2019-12-16 18:08:50 +00:00
|
|
|
hash_tree_root(state.data.latest_block_header)
|
2019-05-04 14:10:45 +00:00
|
|
|
|
2020-05-20 08:46:31 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-specs/blob/v0.11.3/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
2020-05-09 12:43:15 +00:00
|
|
|
proc advance_slot*(state: var HashedBeaconState,
|
2020-06-01 07:44:50 +00:00
|
|
|
nextStateRoot: Opt[Eth2Digest], updateFlags: UpdateFlags,
|
|
|
|
epochCache: var StateCache) {.nbench.} =
|
2020-05-03 17:44:04 +00:00
|
|
|
# Special case version of process_slots that moves one slot at a time - can
|
|
|
|
# run faster if the state root is known already (for example when replaying
|
|
|
|
# existing slots)
|
|
|
|
process_slot(state)
|
|
|
|
let is_epoch_transition = (state.data.slot + 1).isEpoch
|
|
|
|
if is_epoch_transition:
|
|
|
|
# Note: Genesis epoch = 0, no need to test if before Genesis
|
2020-05-08 23:13:57 +00:00
|
|
|
beacon_previous_validators.set(get_epoch_validator_count(state.data))
|
2020-06-01 07:44:50 +00:00
|
|
|
process_epoch(state.data, updateFlags, epochCache)
|
2020-05-03 17:44:04 +00:00
|
|
|
state.data.slot += 1
|
|
|
|
if is_epoch_transition:
|
2020-05-08 23:13:57 +00:00
|
|
|
beacon_current_validators.set(get_epoch_validator_count(state.data))
|
2020-05-03 17:44:04 +00:00
|
|
|
|
|
|
|
if nextStateRoot.isSome:
|
|
|
|
state.root = nextStateRoot.get()
|
|
|
|
else:
|
|
|
|
state.root = hash_tree_root(state.data)
|
|
|
|
|
2020-05-19 14:37:29 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-specs/blob/v0.11.3/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
2020-05-09 12:43:15 +00:00
|
|
|
proc process_slots*(state: var HashedBeaconState, slot: Slot,
|
2020-05-19 14:37:29 +00:00
|
|
|
updateFlags: UpdateFlags = {}): bool {.nbench.} =
|
2020-05-03 17:44:04 +00:00
|
|
|
# TODO this function is not _really_ necessary: when replaying states, we
|
|
|
|
# advance slots one by one before calling `state_transition` - this way,
|
|
|
|
# we avoid the state root calculation - as such, instead of advancing
|
|
|
|
# slots "automatically" in `state_transition`, perhaps it would be better
|
|
|
|
# to keep a pre-condition that state must be at the right slot already?
|
2020-05-19 14:37:29 +00:00
|
|
|
if not (state.data.slot < slot):
|
2019-07-15 21:10:40 +00:00
|
|
|
notice(
|
|
|
|
"Unusual request for a slot in the past",
|
2020-02-05 12:04:22 +00:00
|
|
|
state_root = shortLog(state.root),
|
2019-07-15 21:10:40 +00:00
|
|
|
current_slot = state.data.slot,
|
|
|
|
target_slot = slot
|
|
|
|
)
|
2020-05-19 14:37:29 +00:00
|
|
|
return false
|
2019-07-15 21:10:40 +00:00
|
|
|
|
|
|
|
# Catch up to the target slot
|
2020-06-01 07:44:50 +00:00
|
|
|
var cache = get_empty_per_epoch_cache()
|
2019-07-15 21:10:40 +00:00
|
|
|
while state.data.slot < slot:
|
2020-06-01 07:44:50 +00:00
|
|
|
advance_slot(state, err(Opt[Eth2Digest]), updateFlags, cache)
|
2019-07-15 21:10:40 +00:00
|
|
|
|
2020-05-19 14:37:29 +00:00
|
|
|
true
|
|
|
|
|
2020-04-26 19:13:33 +00:00
|
|
|
proc noRollback*(state: var HashedBeaconState) =
|
|
|
|
trace "Skipping rollback of broken state"
|
2019-05-04 14:10:45 +00:00
|
|
|
|
2020-04-26 19:13:33 +00:00
|
|
|
proc state_transition*(
|
|
|
|
state: var HashedBeaconState, signedBlock: SignedBeaconBlock,
|
2020-05-29 06:10:20 +00:00
|
|
|
# TODO this is ... okay, but not perfect; align with EpochRef
|
|
|
|
stateCache: var StateCache,
|
2020-04-30 16:27:17 +00:00
|
|
|
flags: UpdateFlags, rollback: RollbackHashedProc): bool {.nbench.} =
|
2020-04-30 06:44:19 +00:00
|
|
|
## Time in the beacon chain moves by slots. Every time (haha.) that happens,
|
|
|
|
## we will update the beacon state. Normally, the state updates will be driven
|
|
|
|
## by the contents of a new block, but it may happen that the block goes
|
|
|
|
## missing - the state updates happen regardless.
|
|
|
|
##
|
|
|
|
## The flags are used to specify that certain validations should be skipped
|
|
|
|
## for the new block. This is done during block proposal, to create a state
|
|
|
|
## whose hash can be included in the new block.
|
|
|
|
##
|
|
|
|
## `rollback` is called if the transition fails and the given state has been
|
|
|
|
## partially changed. If a temporary state was given to `state_transition`,
|
|
|
|
## it is safe to use `noRollback` and leave it broken, else the state
|
|
|
|
## object should be rolled back to a consistent state. If the transition fails
|
|
|
|
## before the state has been updated, `rollback` will not be called.
|
|
|
|
#
|
|
|
|
# TODO this function can be written with a loop inside to handle all empty
|
|
|
|
# slots up to the slot of the new_block - but then again, why not eagerly
|
|
|
|
# update the state as time passes? Something to ponder...
|
|
|
|
# One reason to keep it this way is that you need to look ahead if you're
|
|
|
|
# the block proposer, though in reality we only need a partial update for
|
|
|
|
# that ===> Implemented as process_slots
|
|
|
|
# TODO There's a discussion about what this function should do, and when:
|
|
|
|
# https://github.com/ethereum/eth2.0-specs/issues/284
|
|
|
|
|
|
|
|
# TODO check to which extent this copy can be avoided (considering forks etc),
|
|
|
|
# for now, it serves as a reminder that we need to handle invalid blocks
|
|
|
|
# somewhere..
|
|
|
|
# many functions will mutate `state` partially without rolling back
|
|
|
|
# the changes in case of failure (look out for `var BeaconState` and
|
|
|
|
# bool return values...)
|
2020-04-26 19:13:33 +00:00
|
|
|
doAssert not rollback.isNil, "use noRollback if it's ok to mess up state"
|
2020-06-01 07:44:50 +00:00
|
|
|
doAssert stateCache.shuffled_active_validator_indices.hasKey(
|
|
|
|
state.data.slot.compute_epoch_at_slot)
|
2020-05-19 14:37:29 +00:00
|
|
|
|
|
|
|
if not process_slots(state, signedBlock.message.slot, flags):
|
|
|
|
rollback(state)
|
|
|
|
return false
|
2019-07-15 21:10:40 +00:00
|
|
|
|
2020-04-30 06:44:19 +00:00
|
|
|
# Block updates - these happen when there's a new block being suggested
|
|
|
|
# by the block proposer. Every actor in the network will update its state
|
|
|
|
# according to the contents of this block - but first they will validate
|
|
|
|
# that the block is sane.
|
|
|
|
# TODO what should happen if block processing fails?
|
|
|
|
# https://github.com/ethereum/eth2.0-specs/issues/293
|
2020-04-09 09:41:02 +00:00
|
|
|
if skipBLSValidation in flags or
|
2020-04-28 08:08:32 +00:00
|
|
|
verify_block_signature(state.data, signedBlock):
|
2020-04-09 09:41:02 +00:00
|
|
|
|
2020-05-29 06:10:20 +00:00
|
|
|
# TODO after checking scaffolding, remove this
|
2020-05-09 12:43:15 +00:00
|
|
|
trace "in state_transition: processing block, signature passed",
|
|
|
|
signature = signedBlock.signature,
|
|
|
|
blockRoot = hash_tree_root(signedBlock.message)
|
2020-05-29 06:10:20 +00:00
|
|
|
if processBlock(state.data, signedBlock.message, flags, stateCache):
|
2020-04-28 08:08:32 +00:00
|
|
|
if skipStateRootValidation in flags or verifyStateRoot(state.data, signedBlock.message):
|
2020-04-09 09:41:02 +00:00
|
|
|
# State root is what it should be - we're done!
|
2019-05-04 14:10:45 +00:00
|
|
|
|
2020-04-09 09:41:02 +00:00
|
|
|
# TODO when creating a new block, state_root is not yet set.. comparing
|
|
|
|
# with zero hash here is a bit fragile however, but this whole thing
|
|
|
|
# should go away with proper hash caching
|
2020-06-01 07:44:50 +00:00
|
|
|
# TODO shouldn't ever have to recalculate; verifyStateRoot() does it
|
2020-04-09 09:41:02 +00:00
|
|
|
state.root =
|
2020-04-28 08:08:32 +00:00
|
|
|
if signedBlock.message.state_root == Eth2Digest(): hash_tree_root(state.data)
|
2020-04-09 09:41:02 +00:00
|
|
|
else: signedBlock.message.state_root
|
2019-05-04 14:10:45 +00:00
|
|
|
|
2020-04-09 09:41:02 +00:00
|
|
|
return true
|
2019-05-04 14:10:45 +00:00
|
|
|
|
|
|
|
# Block processing failed, roll back changes
|
2020-04-26 19:13:33 +00:00
|
|
|
rollback(state)
|
|
|
|
|
2019-05-04 14:10:45 +00:00
|
|
|
false
|
2020-05-22 14:21:22 +00:00
|
|
|
|
2020-05-29 06:10:20 +00:00
|
|
|
proc state_transition*(
|
|
|
|
state: var HashedBeaconState, signedBlock: SignedBeaconBlock,
|
|
|
|
flags: UpdateFlags, rollback: RollbackHashedProc): bool {.nbench.} =
|
|
|
|
# TODO consider moving this to testutils or similar, since non-testing
|
|
|
|
# and fuzzing code should always be coming from blockpool which should
|
|
|
|
# always be providing cache or equivalent
|
|
|
|
var cache = get_empty_per_epoch_cache()
|
2020-06-01 07:44:50 +00:00
|
|
|
# TODO not here, but in blockpool, should fill in as far ahead towards
|
|
|
|
# block's slot as protocol allows to be known already
|
2020-05-29 06:10:20 +00:00
|
|
|
cache.shuffled_active_validator_indices[state.data.slot.compute_epoch_at_slot] =
|
|
|
|
get_shuffled_active_validator_indices(
|
|
|
|
state.data, state.data.slot.compute_epoch_at_slot)
|
|
|
|
state_transition(state, signedBlock, cache, flags, rollback)
|
|
|
|
|
2020-05-22 14:21:22 +00:00
|
|
|
# https://github.com/ethereum/eth2.0-specs/blob/v0.11.1/specs/phase0/validator.md
|
|
|
|
# TODO There's more to do here - the spec has helpers that deal set up some of
|
|
|
|
# the fields in here!
|
|
|
|
proc makeBeaconBlock*(
|
|
|
|
state: var HashedBeaconState,
|
|
|
|
proposer_index: ValidatorIndex,
|
|
|
|
parent_root: Eth2Digest,
|
|
|
|
randao_reveal: ValidatorSig,
|
|
|
|
eth1_data: Eth1Data,
|
|
|
|
graffiti: Eth2Digest,
|
|
|
|
attestations: seq[Attestation],
|
|
|
|
deposits: seq[Deposit],
|
2020-06-04 12:03:16 +00:00
|
|
|
rollback: RollbackHashedProc,
|
|
|
|
cache: var StateCache): Option[BeaconBlock] =
|
2020-05-22 14:21:22 +00:00
|
|
|
## Create a block for the given state. The last block applied to it must be
|
|
|
|
## the one identified by parent_root and process_slots must be called up to
|
|
|
|
## the slot for which a block is to be created.
|
|
|
|
|
|
|
|
# To create a block, we'll first apply a partial block to the state, skipping
|
|
|
|
# some validations.
|
|
|
|
|
|
|
|
var blck = BeaconBlock(
|
|
|
|
slot: state.data.slot,
|
|
|
|
proposer_index: proposer_index.uint64,
|
|
|
|
parent_root: parent_root,
|
|
|
|
body: BeaconBlockBody(
|
|
|
|
randao_reveal: randao_reveal,
|
|
|
|
eth1_data: eth1data,
|
|
|
|
graffiti: graffiti,
|
|
|
|
attestations: List[Attestation, MAX_ATTESTATIONS](attestations),
|
|
|
|
deposits: List[Deposit, MAX_DEPOSITS](deposits)))
|
|
|
|
|
|
|
|
let ok = process_block(state.data, blck, {skipBlsValidation}, cache)
|
|
|
|
|
|
|
|
if not ok:
|
|
|
|
warn "Unable to apply new block to state", blck = shortLog(blck)
|
|
|
|
rollback(state)
|
|
|
|
return
|
|
|
|
|
|
|
|
state.root = hash_tree_root(state.data)
|
|
|
|
blck.state_root = state.root
|
|
|
|
|
|
|
|
some(blck)
|