651 lines
27 KiB
Nim
651 lines
27 KiB
Nim
# 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.
|
|
|
|
# State transition, as described in
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.1.2/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
|
#
|
|
# The entry point is `state_transition` which is at the bottom of the file!
|
|
#
|
|
# General notes about the code:
|
|
# * Weird styling - the sections taken from the spec use python styling while
|
|
# the others use NEP-1 - helps grepping identifiers in spec
|
|
# * 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 unless
|
|
# motivated by security or performance considerations
|
|
#
|
|
# Performance notes:
|
|
# * The state transition is used in two contexts: to verify that incoming blocks
|
|
# are correct and to replay existing blocks from database. Incoming blocks
|
|
# are processed one-by-one while replay happens multiple blocks at a time.
|
|
# * Although signature verification is the slowest operation in the state
|
|
# state transition, we skip it during replay - this is also when we repeatedly
|
|
# call the state transition, making the non-signature part of the code
|
|
# important from a performance point of view.
|
|
# * It's important to start with a prefilled cache - generating the shuffled
|
|
# list of active validators is generally very slow.
|
|
# * Throughout, the code is affected by inefficient for loop codegen, meaning
|
|
# that we have to iterate over indices and pick out the value manually:
|
|
# https://github.com/nim-lang/Nim/issues/14421
|
|
# * Throughout, we're affected by inefficient `let` borrowing, meaning we
|
|
# often have to take the address of a sequence item due to the above - look
|
|
# for `let ... = unsafeAddr sequence[idx]`
|
|
# * Throughout, we're affected by the overloading rules that prefer a `var`
|
|
# overload to a non-var overload - look for `asSeq()` - when the `var`
|
|
# overload is used, the hash tree cache is cleared, which, aside from being
|
|
# slow itself, causes additional processing to recalculate the merkle tree.
|
|
|
|
{.push raises: [Defect].}
|
|
|
|
import
|
|
std/tables,
|
|
chronicles,
|
|
stew/results,
|
|
metrics,
|
|
../extras,
|
|
./datatypes/[phase0, altair, merge],
|
|
"."/[
|
|
beaconstate, eth2_merkleization, forks, helpers, signatures,
|
|
state_transition_block, state_transition_epoch, validator],
|
|
../../nbench/bench_lab
|
|
|
|
export extras, phase0, altair
|
|
|
|
type Foo = phase0.SignedBeaconBlock | altair.SignedBeaconBlock | phase0.TrustedSignedBeaconBlock | altair.TrustedSignedBeaconBlock | phase0.SigVerifiedSignedBeaconBlock | altair.SigVerifiedSignedBeaconBlock | merge.TrustedSignedBeaconBlock | merge.SigVerifiedSignedBeaconBlock | merge.SignedBeaconBlock
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.1.0/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
|
proc verify_block_signature(
|
|
#state: SomeBeaconState, signed_block: SomeSomeSignedBeaconBlock): bool {.nbench.} =
|
|
state: SomeBeaconState, signed_block: Foo): bool {.nbench.} =
|
|
#state: SomeBeaconState, signed_block: phase0.SomeSignedBeaconBlock | altair.SomeSignedBeaconBlock): bool {.nbench.} =
|
|
let
|
|
proposer_index = signed_block.message.proposer_index
|
|
if proposer_index >= state.validators.lenu64:
|
|
notice "Invalid proposer index in block",
|
|
blck = shortLog(signed_block.message)
|
|
return false
|
|
|
|
if not verify_block_signature(
|
|
state.fork, state.genesis_validators_root, signed_block.message.slot,
|
|
signed_block.message, state.validators[proposer_index].pubkey,
|
|
signed_block.signature):
|
|
notice "Block: signature verification failed",
|
|
blck = shortLog(signedBlock)
|
|
return false
|
|
|
|
true
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.1.2/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
|
proc verifyStateRoot(state: SomeBeaconState, blck: phase0.BeaconBlock or phase0.SigVerifiedBeaconBlock or altair.BeaconBlock or altair.SigVerifiedBeaconBlock or merge.BeaconBlock or merge.SigVerifiedBeaconBlock or merge.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
let state_root = hash_tree_root(state)
|
|
if state_root != blck.state_root:
|
|
notice "Block: root verification failed",
|
|
block_state_root = shortLog(blck.state_root), state_root = shortLog(state_root)
|
|
false
|
|
else:
|
|
true
|
|
|
|
func verifyStateRoot(state: phase0.BeaconState, blck: phase0.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
true
|
|
|
|
func verifyStateRoot(state: altair.BeaconState, blck: altair.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
true
|
|
|
|
func verifyStateRoot(state: merge.BeaconState, blck: merge.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
true
|
|
|
|
# one of these can happen on the fork block itself (it's a phase 0 block which
|
|
# creates an Altair state)
|
|
func verifyStateRoot(state: altair.BeaconState, blck: phase0.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
true
|
|
|
|
func verifyStateRoot(state: merge.BeaconState, blck: phase0.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
true
|
|
|
|
func verifyStateRoot(state: merge.BeaconState, blck: altair.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
true
|
|
|
|
func verifyStateRoot(state: phase0.BeaconState, blck: altair.TrustedBeaconBlock): bool =
|
|
# This is inlined in state_transition(...) in spec.
|
|
true
|
|
|
|
type
|
|
RollbackProc* = proc() {.gcsafe, raises: [Defect].}
|
|
|
|
func noRollback*() =
|
|
trace "Skipping rollback of broken state"
|
|
|
|
type
|
|
RollbackHashedProc* = proc(state: var phase0.HashedBeaconState) {.gcsafe, raises: [Defect].}
|
|
RollbackAltairHashedProc* = proc(state: var altair.HashedBeaconState) {.gcsafe, raises: [Defect].}
|
|
RollbackMergeHashedProc* = proc(state: var merge.HashedBeaconState) {.gcsafe, raises: [Defect].}
|
|
|
|
# Hashed-state transition functions
|
|
# ---------------------------------------------------------------
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.1.2/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
|
func process_slot*(
|
|
state: var SomeBeaconState, pre_state_root: Eth2Digest) {.nbench.} =
|
|
# `process_slot` is the first stage of per-slot processing - it is run for
|
|
# every slot, including epoch slots - it does not however update the slot
|
|
# number! `pre_state_root` refers to the state root of the incoming
|
|
# state before any slot processing has been done.
|
|
|
|
# Cache state root
|
|
state.state_roots[state.slot mod SLOTS_PER_HISTORICAL_ROOT] = pre_state_root
|
|
|
|
# Cache latest block header state root
|
|
if state.latest_block_header.state_root == ZERO_HASH:
|
|
state.latest_block_header.state_root = pre_state_root
|
|
|
|
# Cache block root
|
|
state.block_roots[state.slot mod SLOTS_PER_HISTORICAL_ROOT] =
|
|
hash_tree_root(state.latest_block_header)
|
|
|
|
func clear_epoch_from_cache(cache: var StateCache, epoch: Epoch) =
|
|
cache.shuffled_active_validator_indices.del epoch
|
|
let
|
|
start_slot = epoch.compute_start_slot_at_epoch
|
|
end_slot = (epoch + 1).compute_start_slot_at_epoch
|
|
|
|
for i in start_slot ..< end_slot:
|
|
cache.beacon_proposer_indices.del i
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.0.1/specs/phase0/beacon-chain.md#beacon-chain-state-transition-function
|
|
proc advance_slot(
|
|
cfg: RuntimeConfig,
|
|
state: var SomeBeaconState, previous_slot_state_root: Eth2Digest,
|
|
flags: UpdateFlags, cache: var StateCache, info: var ForkyEpochInfo) {.nbench.} =
|
|
# Do the per-slot and potentially the per-epoch processing, then bump the
|
|
# slot number - we've now arrived at the slot state on top of which a block
|
|
# optionally can be applied.
|
|
process_slot(state, previous_slot_state_root)
|
|
|
|
info.clear()
|
|
|
|
let is_epoch_transition = (state.slot + 1).isEpoch
|
|
if is_epoch_transition:
|
|
# Note: Genesis epoch = 0, no need to test if before Genesis
|
|
process_epoch(cfg, state, flags, cache, info)
|
|
clear_epoch_from_cache(cache, (state.slot + 1).compute_epoch_at_slot)
|
|
|
|
state.slot += 1
|
|
|
|
func noRollback*(state: var phase0.HashedBeaconState) =
|
|
trace "Skipping rollback of broken phase 0 state"
|
|
|
|
func noRollback*(state: var altair.HashedBeaconState) =
|
|
trace "Skipping rollback of broken Altair state"
|
|
|
|
func noRollback*(state: var merge.HashedBeaconState) =
|
|
trace "Skipping rollback of broken Merge state"
|
|
|
|
proc maybeUpgradeStateToAltair(
|
|
cfg: RuntimeConfig, state: var ForkedHashedBeaconState) =
|
|
# Both process_slots() and state_transition_block() call this, so only run it
|
|
# once by checking for existing fork.
|
|
if getStateField(state, slot).epoch == cfg.ALTAIR_FORK_EPOCH and
|
|
state.beaconStateFork == forkPhase0:
|
|
var newState = upgrade_to_altair(cfg, state.hbsPhase0.data)
|
|
state = (ref ForkedHashedBeaconState)(
|
|
beaconStateFork: forkAltair,
|
|
hbsAltair: altair.HashedBeaconState(
|
|
root: hash_tree_root(newState[]), data: newState[]))[]
|
|
|
|
func maybeUpgradeStateToMerge(
|
|
cfg: RuntimeConfig, state: var ForkedHashedBeaconState) =
|
|
# Both process_slots() and state_transition_block() call this, so only run it
|
|
# once by checking for existing fork.
|
|
if getStateField(state, slot).epoch == cfg.MERGE_FORK_EPOCH and
|
|
state.beaconStateFork == forkAltair:
|
|
var newState = upgrade_to_merge(cfg, state.hbsAltair.data)
|
|
state = (ref ForkedHashedBeaconState)(
|
|
beaconStateFork: forkMerge,
|
|
hbsMerge: merge.HashedBeaconState(
|
|
root: hash_tree_root(newState[]), data: newState[]))[]
|
|
|
|
proc maybeUpgradeState*(
|
|
cfg: RuntimeConfig, state: var ForkedHashedBeaconState) =
|
|
cfg.maybeUpgradeStateToAltair(state)
|
|
cfg.maybeUpgradeStateToMerge(state)
|
|
|
|
proc process_slots*(
|
|
cfg: RuntimeConfig, state: var ForkedHashedBeaconState, slot: Slot,
|
|
cache: var StateCache, info: var ForkedEpochInfo, flags: UpdateFlags): bool {.nbench.} =
|
|
if not (getStateField(state, slot) < slot):
|
|
if slotProcessed notin flags or getStateField(state, slot) != slot:
|
|
notice "Unusual request for a slot in the past",
|
|
state_root = shortLog(getStateRoot(state)),
|
|
current_slot = getStateField(state, slot),
|
|
target_slot = slot
|
|
return false
|
|
|
|
# Update the state so its slot matches that of the block
|
|
while getStateField(state, slot) < slot:
|
|
withState(state):
|
|
withEpochInfo(state.data, info):
|
|
advance_slot(
|
|
cfg, state.data, state.root, flags, cache, info)
|
|
|
|
if skipLastStateRootCalculation notin flags or
|
|
state.data.slot < slot:
|
|
# Don't update state root for the slot of the block if going to process
|
|
# block after
|
|
state.root = hash_tree_root(state.data)
|
|
|
|
maybeUpgradeState(cfg, state)
|
|
|
|
true
|
|
|
|
proc state_transition_block_aux(
|
|
cfg: RuntimeConfig,
|
|
state: var SomeHashedBeaconState,
|
|
signedBlock: phase0.SignedBeaconBlock | phase0.SigVerifiedSignedBeaconBlock |
|
|
phase0.TrustedSignedBeaconBlock | altair.SignedBeaconBlock |
|
|
altair.SigVerifiedSignedBeaconBlock | altair.TrustedSignedBeaconBlock |
|
|
merge.TrustedSignedBeaconBlock | merge.SigVerifiedSignedBeaconBlock |
|
|
merge.SignedBeaconBlock,
|
|
cache: var StateCache, flags: UpdateFlags): bool {.nbench.} =
|
|
# 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.
|
|
if not (skipBLSValidation in flags or
|
|
verify_block_signature(state.data, signedBlock)):
|
|
return false
|
|
|
|
trace "state_transition: processing block, signature passed",
|
|
signature = shortLog(signedBlock.signature),
|
|
blockRoot = shortLog(signedBlock.root)
|
|
|
|
let res = process_block(cfg, state.data, signedBlock.message, flags, cache)
|
|
|
|
if not res.isOk():
|
|
debug "state_transition: process_block failed",
|
|
blck = shortLog(signedBlock.message),
|
|
slot = state.data.slot,
|
|
eth1_deposit_index = state.data.eth1_deposit_index,
|
|
deposit_root = shortLog(state.data.eth1_data.deposit_root),
|
|
error = res.error
|
|
return false
|
|
|
|
if not (skipStateRootValidation in flags or
|
|
verifyStateRoot(state.data, signedBlock.message)):
|
|
return false
|
|
|
|
# only blocks currently being produced have an empty state root - we use a
|
|
# separate function for those
|
|
doAssert signedBlock.message.state_root != Eth2Digest(),
|
|
"see makeBeaconBlock for block production"
|
|
state.root = signedBlock.message.state_root
|
|
|
|
true
|
|
|
|
type
|
|
RollbackForkedHashedProc* =
|
|
proc(state: var ForkedHashedBeaconState) {.gcsafe, raises: [Defect].}
|
|
|
|
func noRollback*(state: var ForkedHashedBeaconState) =
|
|
trace "Skipping rollback of broken state"
|
|
|
|
proc state_transition_block*(
|
|
cfg: RuntimeConfig,
|
|
state: var ForkedHashedBeaconState,
|
|
signedBlock: phase0.SignedBeaconBlock | phase0.SigVerifiedSignedBeaconBlock |
|
|
phase0.TrustedSignedBeaconBlock |
|
|
altair.SignedBeaconBlock | altair.SigVerifiedSignedBeaconBlock |
|
|
altair.TrustedSignedBeaconBlock | merge.TrustedSignedBeaconBlock |
|
|
merge.SigVerifiedSignedBeaconBlock | merge.SignedBeaconBlock,
|
|
cache: var StateCache, flags: UpdateFlags,
|
|
rollback: RollbackForkedHashedProc): bool {.nbench.} =
|
|
## `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.
|
|
doAssert not rollback.isNil, "use noRollback if it's ok to mess up state"
|
|
|
|
# Ensure state_transition_block()-only callers trigger this
|
|
maybeUpgradeStateToAltair(cfg, state)
|
|
|
|
let success = withState(state):
|
|
state_transition_block_aux(cfg, state, signedBlock, cache, flags)
|
|
|
|
if not success:
|
|
rollback(state)
|
|
return false
|
|
|
|
true
|
|
|
|
proc state_transition*(
|
|
cfg: RuntimeConfig,
|
|
state: var ForkedHashedBeaconState,
|
|
signedBlock: phase0.SignedBeaconBlock | phase0.SigVerifiedSignedBeaconBlock |
|
|
phase0.TrustedSignedBeaconBlock | altair.SignedBeaconBlock |
|
|
altair.TrustedSignedBeaconBlock | merge.TrustedSignedBeaconBlock |
|
|
merge.SignedBeaconBlock,
|
|
cache: var StateCache, info: var ForkedEpochInfo, flags: UpdateFlags,
|
|
rollback: RollbackForkedHashedProc): bool {.nbench.} =
|
|
## Apply a block to the state, advancing the slot counter as necessary. The
|
|
## given state must be of a lower slot, or, in case the `slotProcessed` flag
|
|
## is set, can be the slot state of the same slot as the block (where the
|
|
## slot state is the state without any block applied). To create a slot state,
|
|
## advance the state corresponding to the the parent block using
|
|
## `process_slots`.
|
|
##
|
|
## To run the state transition function in preparation for block production,
|
|
## use `makeBeaconBlock` instead.
|
|
##
|
|
## `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.
|
|
if not process_slots(
|
|
cfg, state, signedBlock.message.slot, cache, info,
|
|
flags + {skipLastStateRootCalculation}):
|
|
return false
|
|
state_transition_block(
|
|
cfg, state, signedBlock, cache, flags, rollback)
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.0.1/specs/phase0/validator.md#preparing-for-a-beaconblock
|
|
template partialBeaconBlock(
|
|
cfg: RuntimeConfig,
|
|
state: var phase0.HashedBeaconState,
|
|
proposer_index: ValidatorIndex,
|
|
parent_root: Eth2Digest,
|
|
randao_reveal: ValidatorSig,
|
|
eth1_data: Eth1Data,
|
|
graffiti: GraffitiBytes,
|
|
attestations: seq[Attestation],
|
|
deposits: seq[Deposit],
|
|
proposerSlashings: seq[ProposerSlashing],
|
|
attesterSlashings: seq[AttesterSlashing],
|
|
voluntaryExits: seq[SignedVoluntaryExit],
|
|
sync_aggregate: SyncAggregate,
|
|
executionPayload: ExecutionPayload): phase0.BeaconBlock =
|
|
phase0.BeaconBlock(
|
|
slot: state.data.slot,
|
|
proposer_index: proposer_index.uint64,
|
|
parent_root: parent_root,
|
|
body: phase0.BeaconBlockBody(
|
|
randao_reveal: randao_reveal,
|
|
eth1_data: eth1data,
|
|
graffiti: graffiti,
|
|
proposer_slashings: List[ProposerSlashing, Limit MAX_PROPOSER_SLASHINGS](
|
|
proposerSlashings),
|
|
attester_slashings: List[AttesterSlashing, Limit MAX_ATTESTER_SLASHINGS](
|
|
attesterSlashings),
|
|
attestations: List[Attestation, Limit MAX_ATTESTATIONS](attestations),
|
|
deposits: List[Deposit, Limit MAX_DEPOSITS](deposits),
|
|
voluntary_exits:
|
|
List[SignedVoluntaryExit, Limit MAX_VOLUNTARY_EXITS](voluntaryExits)))
|
|
|
|
proc makeBeaconBlock*(
|
|
cfg: RuntimeConfig,
|
|
state: var phase0.HashedBeaconState,
|
|
proposer_index: ValidatorIndex,
|
|
parent_root: Eth2Digest,
|
|
randao_reveal: ValidatorSig,
|
|
eth1_data: Eth1Data,
|
|
graffiti: GraffitiBytes,
|
|
attestations: seq[Attestation],
|
|
deposits: seq[Deposit],
|
|
proposerSlashings: seq[ProposerSlashing],
|
|
attesterSlashings: seq[AttesterSlashing],
|
|
voluntaryExits: seq[SignedVoluntaryExit],
|
|
sync_aggregate: SyncAggregate,
|
|
executionPayload: ExecutionPayload,
|
|
rollback: RollbackHashedProc,
|
|
cache: var StateCache): Result[phase0.BeaconBlock, string] =
|
|
## 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 = partialBeaconBlock(cfg, state, proposer_index, parent_root,
|
|
randao_reveal, eth1_data, graffiti, attestations, deposits,
|
|
proposerSlashings, attesterSlashings, voluntaryExits,
|
|
sync_aggregate, executionPayload)
|
|
|
|
let res = process_block(cfg, state.data, blck, {skipBlsValidation}, cache)
|
|
|
|
if res.isErr:
|
|
warn "Unable to apply new block to state",
|
|
blck = shortLog(blck),
|
|
slot = state.data.slot,
|
|
eth1_deposit_index = state.data.eth1_deposit_index,
|
|
deposit_root = shortLog(state.data.eth1_data.deposit_root),
|
|
error = res.error
|
|
rollback(state)
|
|
return err("Unable to apply new block to state: " & $res.error())
|
|
|
|
state.root = hash_tree_root(state.data)
|
|
blck.state_root = state.root
|
|
ok(blck)
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.1.2/specs/altair/validator.md#preparing-a-beaconblock
|
|
template partialBeaconBlock(
|
|
cfg: RuntimeConfig,
|
|
state: var altair.HashedBeaconState,
|
|
proposer_index: ValidatorIndex,
|
|
parent_root: Eth2Digest,
|
|
randao_reveal: ValidatorSig,
|
|
eth1_data: Eth1Data,
|
|
graffiti: GraffitiBytes,
|
|
attestations: seq[Attestation],
|
|
deposits: seq[Deposit],
|
|
proposerSlashings: seq[ProposerSlashing],
|
|
attesterSlashings: seq[AttesterSlashing],
|
|
voluntaryExits: seq[SignedVoluntaryExit],
|
|
sync_aggregate: SyncAggregate,
|
|
executionPayload: ExecutionPayload): altair.BeaconBlock =
|
|
altair.BeaconBlock(
|
|
slot: state.data.slot,
|
|
proposer_index: proposer_index.uint64,
|
|
parent_root: parent_root,
|
|
body: altair.BeaconBlockBody(
|
|
randao_reveal: randao_reveal,
|
|
eth1_data: eth1data,
|
|
graffiti: graffiti,
|
|
proposer_slashings: List[ProposerSlashing, Limit MAX_PROPOSER_SLASHINGS](
|
|
proposerSlashings),
|
|
attester_slashings: List[AttesterSlashing, Limit MAX_ATTESTER_SLASHINGS](
|
|
attesterSlashings),
|
|
attestations: List[Attestation, Limit MAX_ATTESTATIONS](attestations),
|
|
deposits: List[Deposit, Limit MAX_DEPOSITS](deposits),
|
|
voluntary_exits:
|
|
List[SignedVoluntaryExit, Limit MAX_VOLUNTARY_EXITS](voluntaryExits),
|
|
sync_aggregate: sync_aggregate))
|
|
|
|
proc makeBeaconBlock*(
|
|
cfg: RuntimeConfig,
|
|
state: var altair.HashedBeaconState,
|
|
proposer_index: ValidatorIndex,
|
|
parent_root: Eth2Digest,
|
|
randao_reveal: ValidatorSig,
|
|
eth1_data: Eth1Data,
|
|
graffiti: GraffitiBytes,
|
|
attestations: seq[Attestation],
|
|
deposits: seq[Deposit],
|
|
proposerSlashings: seq[ProposerSlashing],
|
|
attesterSlashings: seq[AttesterSlashing],
|
|
voluntaryExits: seq[SignedVoluntaryExit],
|
|
sync_aggregate: SyncAggregate,
|
|
executionPayload: ExecutionPayload,
|
|
rollback: RollbackAltairHashedProc,
|
|
cache: var StateCache): Result[altair.BeaconBlock, string] =
|
|
## 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 = partialBeaconBlock(cfg, state, proposer_index, parent_root,
|
|
randao_reveal, eth1_data, graffiti, attestations, deposits,
|
|
proposerSlashings, attesterSlashings, voluntaryExits,
|
|
sync_aggregate, executionPayload)
|
|
|
|
let res = process_block(cfg, state.data, blck, {skipBlsValidation}, cache)
|
|
|
|
if res.isErr:
|
|
warn "Unable to apply new block to state",
|
|
blck = shortLog(blck),
|
|
slot = state.data.slot,
|
|
eth1_deposit_index = state.data.eth1_deposit_index,
|
|
deposit_root = shortLog(state.data.eth1_data.deposit_root),
|
|
error = res.error
|
|
rollback(state)
|
|
return err("Unable to apply new block to state: " & $res.error())
|
|
|
|
state.root = hash_tree_root(state.data)
|
|
blck.state_root = state.root
|
|
ok(blck)
|
|
|
|
# https://github.com/ethereum/consensus-specs/blob/v1.1.0/specs/merge/validator.md#block-proposal
|
|
template partialBeaconBlock(
|
|
cfg: RuntimeConfig,
|
|
state: var merge.HashedBeaconState,
|
|
proposer_index: ValidatorIndex,
|
|
parent_root: Eth2Digest,
|
|
randao_reveal: ValidatorSig,
|
|
eth1_data: Eth1Data,
|
|
graffiti: GraffitiBytes,
|
|
attestations: seq[Attestation],
|
|
deposits: seq[Deposit],
|
|
proposerSlashings: seq[ProposerSlashing],
|
|
attesterSlashings: seq[AttesterSlashing],
|
|
voluntaryExits: seq[SignedVoluntaryExit],
|
|
sync_aggregate: SyncAggregate,
|
|
executionPayload: ExecutionPayload): merge.BeaconBlock =
|
|
merge.BeaconBlock(
|
|
slot: state.data.slot,
|
|
proposer_index: proposer_index.uint64,
|
|
parent_root: parent_root,
|
|
body: merge.BeaconBlockBody(
|
|
randao_reveal: randao_reveal,
|
|
eth1_data: eth1data,
|
|
graffiti: graffiti,
|
|
proposer_slashings: List[ProposerSlashing, Limit MAX_PROPOSER_SLASHINGS](
|
|
proposerSlashings),
|
|
attester_slashings: List[AttesterSlashing, Limit MAX_ATTESTER_SLASHINGS](
|
|
attesterSlashings),
|
|
attestations: List[Attestation, Limit MAX_ATTESTATIONS](attestations),
|
|
deposits: List[Deposit, Limit MAX_DEPOSITS](deposits),
|
|
voluntary_exits:
|
|
List[SignedVoluntaryExit, Limit MAX_VOLUNTARY_EXITS](voluntaryExits),
|
|
sync_aggregate: sync_aggregate,
|
|
execution_payload: executionPayload))
|
|
|
|
proc makeBeaconBlock*(
|
|
cfg: RuntimeConfig,
|
|
state: var merge.HashedBeaconState,
|
|
proposer_index: ValidatorIndex,
|
|
parent_root: Eth2Digest,
|
|
randao_reveal: ValidatorSig,
|
|
eth1_data: Eth1Data,
|
|
graffiti: GraffitiBytes,
|
|
attestations: seq[Attestation],
|
|
deposits: seq[Deposit],
|
|
proposerSlashings: seq[ProposerSlashing],
|
|
attesterSlashings: seq[AttesterSlashing],
|
|
voluntaryExits: seq[SignedVoluntaryExit],
|
|
sync_aggregate: SyncAggregate,
|
|
executionPayload: ExecutionPayload,
|
|
rollback: RollbackMergeHashedProc,
|
|
cache: var StateCache): Result[merge.BeaconBlock, string] =
|
|
## 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 = partialBeaconBlock(cfg, state, proposer_index, parent_root,
|
|
randao_reveal, eth1_data, graffiti, attestations, deposits,
|
|
proposerSlashings, attesterSlashings, voluntaryExits,
|
|
sync_aggregate, executionPayload)
|
|
|
|
let res = process_block(cfg, state.data, blck, {skipBlsValidation}, cache)
|
|
|
|
if res.isErr:
|
|
warn "Unable to apply new block to state",
|
|
blck = shortLog(blck),
|
|
slot = state.data.slot,
|
|
eth1_deposit_index = state.data.eth1_deposit_index,
|
|
deposit_root = shortLog(state.data.eth1_data.deposit_root),
|
|
error = res.error
|
|
rollback(state)
|
|
return err("Unable to apply new block to state: " & $res.error())
|
|
|
|
state.root = hash_tree_root(state.data)
|
|
blck.state_root = state.root
|
|
ok(blck)
|
|
|
|
proc makeBeaconBlock*(
|
|
cfg: RuntimeConfig,
|
|
state: var ForkedHashedBeaconState,
|
|
proposer_index: ValidatorIndex,
|
|
parent_root: Eth2Digest,
|
|
randao_reveal: ValidatorSig,
|
|
eth1_data: Eth1Data,
|
|
graffiti: GraffitiBytes,
|
|
attestations: seq[Attestation],
|
|
deposits: seq[Deposit],
|
|
proposerSlashings: seq[ProposerSlashing],
|
|
attesterSlashings: seq[AttesterSlashing],
|
|
voluntaryExits: seq[SignedVoluntaryExit],
|
|
sync_aggregate: SyncAggregate,
|
|
executionPayload: ExecutionPayload,
|
|
rollback: RollbackForkedHashedProc,
|
|
cache: var StateCache): Result[ForkedBeaconBlock, string] =
|
|
## 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.
|
|
|
|
template makeBeaconBlock(kind: untyped): Result[ForkedBeaconBlock, string] =
|
|
# To create a block, we'll first apply a partial block to the state, skipping
|
|
# some validations.
|
|
|
|
var blck =
|
|
ForkedBeaconBlock.init(
|
|
partialBeaconBlock(cfg, state.`hbs kind`, proposer_index, parent_root,
|
|
randao_reveal, eth1_data, graffiti, attestations, deposits,
|
|
proposerSlashings, attesterSlashings, voluntaryExits,
|
|
sync_aggregate, executionPayload))
|
|
|
|
let res = process_block(cfg, state.`hbs kind`.data, blck.`kind Block`,
|
|
{skipBlsValidation}, cache)
|
|
|
|
if res.isErr:
|
|
warn "Unable to apply new block to state",
|
|
blck = shortLog(blck),
|
|
slot = state.`hbs kind`.data.slot,
|
|
eth1_deposit_index = state.`hbs kind`.data.eth1_deposit_index,
|
|
deposit_root = shortLog(state.`hbs kind`.data.eth1_data.deposit_root),
|
|
error = res.error
|
|
rollback(state)
|
|
return err("Unable to apply new block to state: " & $res.error())
|
|
|
|
state.`hbs kind`.root = hash_tree_root(state.`hbs kind`.data)
|
|
blck.`kind Block`.state_root = state.`hbs kind`.root
|
|
ok(blck)
|
|
|
|
case state.beaconStateFork
|
|
of forkPhase0: makeBeaconBlock(phase0)
|
|
of forkAltair: makeBeaconBlock(altair)
|
|
of forkMerge: makeBeaconBlock(merge)
|