status-im
/
nimbus-eth2
mirror of https://github.com/status-im/nimbus-eth2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

clean up fork enum and field names 

* single naming strategy
* simplify some fork code
* simplify forked block production
This commit is contained in:
Jacek Sieka 2021-10-18 18:37:27 +02:00 committed by zah
parent ecf2dbbcf3
commit c40cc6cec1
51 changed files with 504 additions and 544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
beacon_chain/beacon_node_common.nim
View File

@ -19,7 +19,8 @@ import
./gossip_processing/[eth2_processor, block_processor, consensus_manager],
./networking/eth2_network,
./eth1/eth1_monitor,
./consensus_object_pools/[blockchain_dag, block_quarantine, attestation_pool],
./consensus_object_pools/[
blockchain_dag, block_quarantine, exit_pool, attestation_pool],
./spec/datatypes/base,
./sync/[sync_manager, request_manager],
./validators/action_tracker
@ -28,7 +29,7 @@ export
osproc, chronos, httpserver, presto, action_tracker, beacon_clock,
beacon_chain_db, conf, attestation_pool, eth2_network, beacon_node_types,
eth1_monitor, request_manager, sync_manager, eth2_processor, blockchain_dag,
block_quarantine, base
block_quarantine, base, exit_pool
type
RpcServer* = RpcHttpServer

31
beacon_chain/beacon_node_types.nim
View File

@ -8,7 +8,7 @@
{.push raises: [Defect].}
import
std/[deques, intsets, streams, tables, hashes, options],
std/[deques, streams, tables, hashes, options],
stew/endians2,
./spec/datatypes/[phase0, altair],
./spec/keystore,
@ -113,35 +113,6 @@ type
SyncCommitteeMsgPoolRef* = ref SyncCommitteeMsgPool
OnVoluntaryExitCallback* =
proc(data: SignedVoluntaryExit) {.gcsafe, raises: [Defect].}
ExitPool* = object
## The exit pool tracks attester slashings, proposer slashings, and
## voluntary exits that could be added to a proposed block.
attester_slashings*: Deque[AttesterSlashing] ## \
## Not a function of chain DAG branch; just used as a FIFO queue for blocks
proposer_slashings*: Deque[ProposerSlashing] ## \
## Not a function of chain DAG branch; just used as a FIFO queue for blocks
voluntary_exits*: Deque[SignedVoluntaryExit] ## \
## Not a function of chain DAG branch; just used as a FIFO queue for blocks
prior_seen_attester_slashed_indices*: IntSet ## \
## Records attester-slashed indices seen.
prior_seen_proposer_slashed_indices*: IntSet ## \
## Records proposer-slashed indices seen.
prior_seen_voluntary_exit_indices*: IntSet ##\
## Records voluntary exit indices seen.
dag*: ChainDAGRef
onVoluntaryExitReceived*: OnVoluntaryExitCallback
# #############################################
#
# Validator Pool

54
beacon_chain/consensus_object_pools/blockchain_dag.nim
View File

@ -344,23 +344,23 @@ proc getStateData(
return false
case cfg.stateForkAtEpoch(bs.slot.epoch)
of forkMerge:
if state.data.beaconStateFork != forkMerge:
state.data = (ref ForkedHashedBeaconState)(beaconStateFork: forkMerge)[]
of BeaconStateFork.Merge:
if state.data.kind != BeaconStateFork.Merge:
state.data = (ref ForkedHashedBeaconState)(kind: BeaconStateFork.Merge)[]
if not db.getMergeState(root.get(), state.data.hbsMerge.data, rollback):
if not db.getMergeState(root.get(), state.data.mergeData.data, rollback):
return false
of forkAltair:
if state.data.beaconStateFork != forkAltair:
state.data = (ref ForkedHashedBeaconState)(beaconStateFork: forkAltair)[]
of BeaconStateFork.Altair:
if state.data.kind != BeaconStateFork.Altair:
state.data = (ref ForkedHashedBeaconState)(kind: BeaconStateFork.Altair)[]
if not db.getAltairState(root.get(), state.data.hbsAltair.data, rollback):
if not db.getAltairState(root.get(), state.data.altairData.data, rollback):
return false
of forkPhase0:
if state.data.beaconStateFork != forkPhase0:
state.data = (ref ForkedHashedBeaconState)(beaconStateFork: forkPhase0)[]
of BeaconStateFork.Phase0:
if state.data.kind != BeaconStateFork.Phase0:
state.data = (ref ForkedHashedBeaconState)(kind: BeaconStateFork.Phase0)[]
if not db.getState(root.get(), state.data.hbsPhase0.data, rollback):
if not db.getState(root.get(), state.data.phase0Data.data, rollback):
return false
state.blck = bs.blck
@ -457,23 +457,23 @@ proc init*(T: type ChainDAGRef, cfg: RuntimeConfig, db: BeaconChainDB,
# would be a good recovery model?
raiseAssert "No state found in head history, database corrupt?"
case tmpState.data.beaconStateFork
of forkPhase0:
if tmpState.data.hbsPhase0.data.fork != genesisFork(cfg):
case tmpState.data.kind
of BeaconStateFork.Phase0:
if tmpState.data.phase0Data.data.fork != genesisFork(cfg):
error "State from database does not match network, check --network parameter",
stateFork = tmpState.data.hbsPhase0.data.fork,
stateFork = tmpState.data.phase0Data.data.fork,
configFork = genesisFork(cfg)
quit 1
of forkAltair:
if tmpState.data.hbsAltair.data.fork != altairFork(cfg):
of BeaconStateFork.Altair:
if tmpState.data.altairData.data.fork != altairFork(cfg):
error "State from database does not match network, check --network parameter",
stateFork = tmpState.data.hbsAltair.data.fork,
stateFork = tmpState.data.altairData.data.fork,
configFork = altairFork(cfg)
quit 1
of forkMerge:
if tmpState.data.hbsMerge.data.fork != mergeFork(cfg):
of BeaconStateFork.Merge:
if tmpState.data.mergeData.data.fork != mergeFork(cfg):
error "State from database does not match network, check --network parameter",
stateFork = tmpState.data.hbsMerge.data.fork,
stateFork = tmpState.data.mergeData.data.fork,
configFork = mergeFork(cfg)
quit 1
@ -602,9 +602,9 @@ template forkAtEpoch*(dag: ChainDAGRef, epoch: Epoch): Fork =
proc forkDigestAtEpoch*(dag: ChainDAGRef, epoch: Epoch): ForkDigest =
case dag.cfg.stateForkAtEpoch(epoch)
of forkMerge: dag.forkDigests.merge
of forkAltair: dag.forkDigests.altair
of forkPhase0: dag.forkDigests.phase0
of BeaconStateFork.Merge: dag.forkDigests.merge
of BeaconStateFork.Altair: dag.forkDigests.altair
of BeaconStateFork.Phase0: dag.forkDigests.phase0
proc getState(dag: ChainDAGRef, state: var StateData, bs: BlockSlot): bool =
## Load a state from the database given a block and a slot - this will first
@ -1051,7 +1051,7 @@ func syncCommitteeParticipants*(dagParam: ChainDAGRef,
slot = slotParam
withState(dag.headState.data):
when stateFork >= forkAltair:
when stateFork >= BeaconStateFork.Altair:
let
headSlot = state.data.slot
headCommitteePeriod = syncCommitteePeriod(headSlot)
@ -1089,7 +1089,7 @@ func getSubcommitteePositions*(dag: ChainDAGRef,
committeeIdx: SyncCommitteeIndex,
validatorIdx: uint64): seq[uint64] =
withState(dag.headState.data):
when stateFork >= forkAltair:
when stateFork >= BeaconStateFork.Altair:
let
headSlot = state.data.slot
headCommitteePeriod = syncCommitteePeriod(headSlot)

110
beacon_chain/consensus_object_pools/exit_pool.nim
View File

@ -9,23 +9,51 @@
import
# Standard libraries
std/[deques, intsets, tables],
std/[deques, sets, intsets],
# Status libraries
chronicles,
# Internal
../spec/[forks, helpers],
../spec/datatypes/base,
"."/[blockchain_dag],
../beacon_node_types
../spec/helpers,
../spec/datatypes/[phase0, altair, merge],
./blockchain_dag
export beacon_node_types, base, intsets, deques
export phase0, altair, merge, deques, intsets, sets, blockchain_dag
logScope: topics = "exitpool"
const
ATTESTER_SLASHINGS_BOUND* = MAX_ATTESTER_SLASHINGS * 2
PROPOSER_SLASHINGS_BOUND* = MAX_PROPOSER_SLASHINGS * 2
VOLUNTARY_EXITS_BOUND* = MAX_VOLUNTARY_EXITS * 2
ATTESTER_SLASHINGS_BOUND* = MAX_ATTESTER_SLASHINGS * 4
PROPOSER_SLASHINGS_BOUND* = MAX_PROPOSER_SLASHINGS * 4
VOLUNTARY_EXITS_BOUND* = MAX_VOLUNTARY_EXITS * 4
type
OnVoluntaryExitCallback* =
proc(data: SignedVoluntaryExit) {.gcsafe, raises: [Defect].}
ExitPool* = object
## The exit pool tracks attester slashings, proposer slashings, and
## voluntary exits that could be added to a proposed block.
attester_slashings*: Deque[AttesterSlashing] ## \
## Not a function of chain DAG branch; just used as a FIFO queue for blocks
proposer_slashings*: Deque[ProposerSlashing] ## \
## Not a function of chain DAG branch; just used as a FIFO queue for blocks
voluntary_exits*: Deque[SignedVoluntaryExit] ## \
## Not a function of chain DAG branch; just used as a FIFO queue for blocks
prior_seen_attester_slashed_indices*: IntSet ## \
## Records attester-slashed indices seen.
prior_seen_proposer_slashed_indices*: IntSet ## \
## Records proposer-slashed indices seen.
prior_seen_voluntary_exit_indices*: IntSet ##\
## Records voluntary exit indices seen.
dag*: ChainDAGRef
onVoluntaryExitReceived*: OnVoluntaryExitCallback
proc init*(T: type ExitPool, dag: ChainDAGRef,
onVoluntaryExit: OnVoluntaryExitCallback = nil): T =
@ -70,19 +98,8 @@ iterator getValidatorIndices(proposer_slashing: ProposerSlashing): uint64 =
iterator getValidatorIndices(voluntary_exit: SignedVoluntaryExit): uint64 =
yield voluntary_exit.message.validator_index
# TODO stew/sequtils2
template allIt(s, pred: untyped): bool =
# https://github.com/nim-lang/Nim/blob/version-1-2/lib/pure/collections/sequtils.nim#L640-L662
# without the items(...)
var result = true
for it {.inject.} in s:
if not pred:
result = false
break
result
func getExitMessagesForBlock[T](
subpool: var Deque[T], pool: var ExitPool, bound: uint64): seq[T] =
func getExitMessagesForBlock(
subpool: var Deque, validators: auto, seen: var HashSet, output: var List) =
# Approach taken here is to simply collect messages, effectively, a circular
# buffer and only re-validate that they haven't already found themselves out
# of the network eventually via some exit message at block construction time
@ -103,39 +120,36 @@ func getExitMessagesForBlock[T](
# this occurs, only validating after the fact ensures that we still broadcast
# out those exit messages that were in orphaned block X by not having eagerly
# removed them, if we have the chance.
while true:
if subpool.len == 0 or result.lenu64 >= bound:
break
while subpool.len > 0 and output.len < output.maxLen:
# Prefer recent messages
let exit_message = subpool.popLast()
if allIt(
getValidatorIndices(exit_message),
getStateField(pool.dag.headState.data, validators)[it].exit_epoch !=
FAR_FUTURE_EPOCH):
# A beacon block exit message already targeted all these validators
for slashed_index in getValidatorIndices(exit_message):
if validators.lenu64 <= slashed_index:
continue
if validators[slashed_index].exit_epoch != FAR_FUTURE_EPOCH:
continue
if seen.containsOrIncl(slashed_index):
continue
result.add exit_message
if not output.add exit_message:
break
subpool.clear()
doAssert result.lenu64 <= bound
func getAttesterSlashingsForBlock*(pool: var ExitPool):
seq[AttesterSlashing] =
## Retrieve attester slashings that may be added to a new block
getExitMessagesForBlock[AttesterSlashing](
pool.attester_slashings, pool, MAX_ATTESTER_SLASHINGS)
func getBeaconBlockExits*(pool: var ExitPool, state: SomeBeaconState): BeaconBlockExits =
var
indices: HashSet[uint64]
res: BeaconBlockExits
func getProposerSlashingsForBlock*(pool: var ExitPool):
seq[ProposerSlashing] =
## Retrieve proposer slashings that may be added to a new block
getExitMessagesForBlock[ProposerSlashing](
pool.proposer_slashings, pool, MAX_PROPOSER_SLASHINGS)
getExitMessagesForBlock(
pool.attester_slashings, state.validators.asSeq(), indices,
res.attester_slashings)
getExitMessagesForBlock(
pool.proposer_slashings, state.validators.asSeq(), indices,
res.proposer_slashings)
getExitMessagesForBlock(
pool.voluntary_exits, state.validators.asSeq(), indices,
res.voluntary_exits)
func getVoluntaryExitsForBlock*(pool: var ExitPool):
seq[SignedVoluntaryExit] =
## Retrieve voluntary exits that may be added to a new block
getExitMessagesForBlock[SignedVoluntaryExit](
pool.voluntary_exits, pool, MAX_VOLUNTARY_EXITS)
res

8
beacon_chain/consensus_object_pools/forkedbeaconstate_dbhelpers.nim
View File

@ -12,7 +12,7 @@ import
../beacon_chain_db
proc putState*(db: BeaconChainDB, state: ForkedHashedBeaconState) =
case state.beaconStateFork:
of forkPhase0: db.putState(getStateRoot(state), state.hbsPhase0.data)
of forkAltair: db.putState(getStateRoot(state), state.hbsAltair.data)
of forkMerge: db.putState(getStateRoot(state), state.hbsMerge.data)
case state.kind:
of BeaconStateFork.Phase0: db.putState(getStateRoot(state), state.phase0Data.data)
of BeaconStateFork.Altair: db.putState(getStateRoot(state), state.altairData.data)
of BeaconStateFork.Merge: db.putState(getStateRoot(state), state.mergeData.data)

12
beacon_chain/networking/eth2_network.nim
View File

@ -2130,9 +2130,9 @@ proc updateForkId*(node: Eth2Node, epoch: Epoch, genesisValidatorsRoot: Eth2Dige
func forkDigestAtEpoch(node: Eth2Node, epoch: Epoch): ForkDigest =
case node.cfg.stateForkAtEpoch(epoch)
of forkMerge: node.forkDigests.merge
of forkAltair: node.forkDigests.altair
of forkPhase0: node.forkDigests.phase0
of BeaconStateFork.Merge: node.forkDigests.merge
of BeaconStateFork.Altair: node.forkDigests.altair
of BeaconStateFork.Phase0: node.forkDigests.phase0
proc getWallEpoch(node: Eth2Node): Epoch =
node.getBeaconTime().slotOrZero.epoch
@ -2174,13 +2174,13 @@ proc broadcastBeaconBlock*(node: Eth2Node, forked: ForkedSignedBeaconBlock) =
case forked.kind
of BeaconBlockFork.Phase0:
let topic = getBeaconBlocksTopic(node.forkDigests.phase0)
node.broadcast(topic, forked.phase0Block)
node.broadcast(topic, forked.phase0Data)
of BeaconBlockFork.Altair:
let topic = getBeaconBlocksTopic(node.forkDigests.altair)
node.broadcast(topic, forked.altairBlock)
node.broadcast(topic, forked.altairData)
of BeaconBlockFork.Merge:
let topic = getBeaconBlocksTopic(node.forkDigests.merge)
node.broadcast(topic, forked.mergeBlock)
node.broadcast(topic, forked.mergeData)
proc broadcastSyncCommitteeMessage*(
node: Eth2Node, msg: SyncCommitteeMessage, committeeIdx: SyncCommitteeIndex) =

10
beacon_chain/rpc/rest_beacon_api.nim
View File

@ -816,9 +816,9 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
of BeaconBlockFork.Phase0:
case contentType
of "application/octet-stream":
RestApiResponse.sszResponse(bdata.data.phase0Block)
RestApiResponse.sszResponse(bdata.data.phase0Data)
of "application/json":
RestApiResponse.jsonResponse(bdata.data.phase0Block)
RestApiResponse.jsonResponse(bdata.data.phase0Data)
else:
RestApiResponse.jsonError(Http500, InvalidAcceptError)
of BeaconBlockFork.Altair, BeaconBlockFork.Merge:
@ -848,11 +848,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
of "application/octet-stream":
case bdata.data.kind
of BeaconBlockFork.Phase0:
RestApiResponse.sszResponse(bdata.data.phase0Block)
RestApiResponse.sszResponse(bdata.data.phase0Data)
of BeaconBlockFork.Altair:
RestApiResponse.sszResponse(bdata.data.altairBlock)
RestApiResponse.sszResponse(bdata.data.altairData)
of BeaconBlockFork.Merge:
RestApiResponse.sszResponse(bdata.data.mergeBlock)
RestApiResponse.sszResponse(bdata.data.mergeData)
of "application/json":
RestApiResponse.jsonResponsePlain(bdata.data.asSigned())
else:

10
beacon_chain/rpc/rest_debug_api.nim
View File

@ -37,16 +37,16 @@ proc installDebugApiHandlers*(router: var RestRouter, node: BeaconNode) =
res.get()
node.withStateForBlockSlot(bslot):
return
case stateData.data.beaconStateFork
of BeaconStateFork.forkPhase0:
case stateData.data.kind
of BeaconStateFork.Phase0:
case contentType
of "application/octet-stream":
RestApiResponse.sszResponse(stateData.data.hbsPhase0.data)
RestApiResponse.sszResponse(stateData.data.phase0Data.data)
of "application/json":
RestApiResponse.jsonResponse(stateData.data.hbsPhase0.data)
RestApiResponse.jsonResponse(stateData.data.phase0Data.data)
else:
RestApiResponse.jsonError(Http500, InvalidAcceptError)
of BeaconStateFork.forkAltair, BeaconStateFork.forkMerge:
of BeaconStateFork.Altair, BeaconStateFork.Merge:
RestApiResponse.jsonError(Http404, StateNotFoundError)
return RestApiResponse.jsonError(Http404, StateNotFoundError)

2
beacon_chain/rpc/rest_utils.nim
View File

@ -324,7 +324,7 @@ proc toValidatorIndex*(value: RestValidatorIndex): Result[ValidatorIndex,
func syncCommitteeParticipants*(forkedState: ForkedHashedBeaconState,
epoch: Epoch): Result[seq[ValidatorPubKey], cstring] =
withState(forkedState):
when stateFork >= forkAltair:
when stateFork >= BeaconStateFork.Altair:
let
headSlot = state.data.slot
epochPeriod = syncCommitteePeriod(epoch.compute_start_slot_at_epoch())

2
beacon_chain/rpc/rest_validator_api.nim
View File

@ -307,7 +307,7 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
return
case message.kind
of BeaconBlockFork.Phase0:
RestApiResponse.jsonResponse(message.phase0Block)
RestApiResponse.jsonResponse(message.phase0Data)
else:
RestApiResponse.jsonError(Http400,
"Unable to produce block for altair fork")

2
beacon_chain/rpc/rpc_beacon_api.nim
View File

@ -428,7 +428,7 @@ proc installBeaconApiHandlers*(rpcServer: RpcServer, node: BeaconNode) {.
blockId: string) -> phase0.TrustedSignedBeaconBlock:
let blck = node.getBlockDataFromBlockId(blockId).data
if blck.kind == BeaconBlockFork.Phase0:
return blck.phase0Block
return blck.phase0Data
else:
raiseNoAltairSupport()

4
beacon_chain/rpc/rpc_debug_api.nim
View File

@ -26,8 +26,8 @@ proc installDebugApiHandlers*(rpcServer: RpcServer, node: BeaconNode) {.
rpcServer.rpc("get_v1_debug_beacon_states_stateId") do (
stateId: string) -> phase0.BeaconState:
withStateForStateId(stateId):
if stateData.data.beaconStateFork == forkPhase0:
return stateData.data.hbsPhase0.data
if stateData.data.kind == BeaconStateFork.Phase0:
return stateData.data.phase0Data.data
else:
raiseNoAltairSupport()

2
beacon_chain/rpc/rpc_validator_api.nim
View File

@ -49,7 +49,7 @@ proc installValidatorApiHandlers*(rpcServer: RpcServer, node: BeaconNode) {.
let blck = message.get()
case blck.kind
of BeaconBlockFork.Phase0:
return blck.phase0Block
return blck.phase0Data
else:
raiseNoAltairSupport()

6
beacon_chain/spec/datatypes/base.nim
View File

@ -475,6 +475,12 @@ type
current_justified_checkpoint*: Checkpoint
finalized_checkpoint*: Checkpoint
BeaconBlockExits* = object
# Collection of exits that are suitable for block production
proposer_slashings*: List[ProposerSlashing, Limit MAX_PROPOSER_SLASHINGS]
attester_slashings*: List[AttesterSlashing, Limit MAX_ATTESTER_SLASHINGS]
voluntary_exits*: List[SignedVoluntaryExit, Limit MAX_VOLUNTARY_EXITS]
type
# Caches for computing justificiation, rewards and penalties - based on
# implementation in Lighthouse:

46
beacon_chain/spec/eth2_apis/eth2_rest_serialization.nim
View File

@ -683,15 +683,15 @@ proc writeValue*(writer: var JsonWriter[RestJson], value: ForkedBeaconBlock) {.
case value.kind
of BeaconBlockFork.Phase0:
writer.writeField("version", "phase0")
writer.writeField("data", value.phase0Block)
writer.writeField("data", value.phase0Data)
of BeaconBlockFork.Altair:
writer.writeField("version", "altair")
writer.writeField("data", value.altairBlock)
writer.writeField("data", value.altairData)
of BeaconBlockFork.Merge:
writer.writeField("version", "merge")
when false:
# TODO SerializationError
writer.writeField("data", value.mergeBlock)
writer.writeField("data", value.mergeData)
writer.endRecord()
## ForkedSignedBeaconBlock
@ -770,15 +770,15 @@ proc writeValue*(writer: var JsonWriter[RestJson],
case value.kind
of BeaconBlockFork.Phase0:
writer.writeField("version", "phase0")
writer.writeField("data", value.phase0Block)
writer.writeField("data", value.phase0Data)
of BeaconBlockFork.Altair:
writer.writeField("version", "altair")
writer.writeField("data", value.altairBlock)
writer.writeField("data", value.altairData)
of BeaconBlockFork.Merge:
writer.writeField("version", "merge")
when false:
# TODO SerializationError
writer.writeField("data", value.mergeBlock)
writer.writeField("data", value.mergeData)
writer.endRecord()
# ForkedBeaconState
@ -796,15 +796,11 @@ proc readValue*(reader: var JsonReader[RestJson],
reader.raiseUnexpectedField("Multiple version fields found",
"ForkedBeaconState")
let vres = reader.readValue(string)
case vres
of "phase0":
version = some(BeaconStateFork.forkPhase0)
of "altair":
version = some(BeaconStateFork.forkAltair)
of "merge":
version = some(BeaconStateFork.forkMerge)
else:
reader.raiseUnexpectedValue("Incorrect version field value")
version = case vres
of "phase0": some(BeaconStateFork.Phase0)
of "altair": some(BeaconStateFork.Altair)
of "merge": some(BeaconStateFork.Merge)
else: reader.raiseUnexpectedValue("Incorrect version field value")
of "data":
if data.isSome():
reader.raiseUnexpectedField("Multiple data fields found",
@ -819,7 +815,7 @@ proc readValue*(reader: var JsonReader[RestJson],
reader.raiseUnexpectedValue("Field data is missing")
case version.get():
of BeaconStateFork.forkPhase0:
of BeaconStateFork.Phase0:
let res =
try:
some(RestJson.decode(string(data.get()), phase0.BeaconState,
@ -829,7 +825,7 @@ proc readValue*(reader: var JsonReader[RestJson],
if res.isNone():
reader.raiseUnexpectedValue("Incorrect phase0 beacon state format")
value = ForkedBeaconState.init(res.get())
of BeaconStateFork.forkAltair:
of BeaconStateFork.Altair:
let res =
try:
some(RestJson.decode(string(data.get()), altair.BeaconState,
@ -839,7 +835,7 @@ proc readValue*(reader: var JsonReader[RestJson],
if res.isNone():
reader.raiseUnexpectedValue("Incorrect altair beacon state format")
value = ForkedBeaconState.init(res.get())
of BeaconStateFork.forkMerge:
of BeaconStateFork.Merge:
let res =
try:
some(RestJson.decode(string(data.get()), merge.BeaconState,
@ -853,18 +849,18 @@ proc readValue*(reader: var JsonReader[RestJson],
proc writeValue*(writer: var JsonWriter[RestJson], value: ForkedBeaconState) {.
raises: [IOError, Defect].} =
writer.beginRecord()
case value.beaconStateFork
of BeaconStateFork.forkPhase0:
case value.kind
of BeaconStateFork.Phase0:
writer.writeField("version", "phase0")
writer.writeField("data", value.bsPhase0)
of BeaconStateFork.forkAltair:
writer.writeField("data", value.phase0Data)
of BeaconStateFork.Altair:
writer.writeField("version", "altair")
writer.writeField("data", value.bsAltair)
of BeaconStateFork.forkMerge:
writer.writeField("data", value.altairData)
of BeaconStateFork.Merge:
writer.writeField("version", "merge")
when false:
# TODO SerializationError
writer.writeField("data", value.bsMerge)
writer.writeField("data", value.mergeData)
writer.endRecord()
# SyncCommitteeIndex

224
beacon_chain/spec/forks.nim
View File

@ -19,22 +19,22 @@ import
export extras, phase0, altair, eth2_merkleization
type
BeaconStateFork* = enum
forkPhase0,
forkAltair,
forkMerge
BeaconStateFork* {.pure.} = enum
Phase0,
Altair,
Merge
ForkedHashedBeaconState* = object
case beaconStateFork*: BeaconStateFork
of forkPhase0: hbsPhase0*: phase0.HashedBeaconState
of forkAltair: hbsAltair*: altair.HashedBeaconState
of forkMerge: hbsMerge*: merge.HashedBeaconState
case kind*: BeaconStateFork
of BeaconStateFork.Phase0: phase0Data*: phase0.HashedBeaconState
of BeaconStateFork.Altair: altairData*: altair.HashedBeaconState
of BeaconStateFork.Merge: mergeData*: merge.HashedBeaconState
ForkedBeaconState* = object
case beaconStateFork*: BeaconStateFork
of forkPhase0: bsPhase0*: phase0.BeaconState
of forkAltair: bsAltair*: altair.BeaconState
of forkMerge: bsMerge*: merge.BeaconState
case kind*: BeaconStateFork
of BeaconStateFork.Phase0: phase0Data*: phase0.BeaconState
of BeaconStateFork.Altair: altairData*: altair.BeaconState
of BeaconStateFork.Merge: mergeData*: merge.BeaconState
BeaconBlockFork* {.pure.} = enum
Phase0
@ -44,29 +44,29 @@ type
ForkedBeaconBlock* = object
case kind*: BeaconBlockFork
of BeaconBlockFork.Phase0:
phase0Block*: phase0.BeaconBlock
phase0Data*: phase0.BeaconBlock
of BeaconBlockFork.Altair:
altairBlock*: altair.BeaconBlock
altairData*: altair.BeaconBlock
of BeaconBlockFork.Merge:
mergeBlock*: merge.BeaconBlock
mergeData*: merge.BeaconBlock
ForkedSignedBeaconBlock* = object
case kind*: BeaconBlockFork
of BeaconBlockFork.Phase0:
phase0Block*: phase0.SignedBeaconBlock
phase0Data*: phase0.SignedBeaconBlock
of BeaconBlockFork.Altair:
altairBlock*: altair.SignedBeaconBlock
altairData*: altair.SignedBeaconBlock
of BeaconBlockFork.Merge:
mergeBlock*: merge.SignedBeaconBlock
mergeData*: merge.SignedBeaconBlock
ForkedTrustedSignedBeaconBlock* = object
case kind*: BeaconBlockFork
of BeaconBlockFork.Phase0:
phase0Block*: phase0.TrustedSignedBeaconBlock
phase0Data*: phase0.TrustedSignedBeaconBlock
of BeaconBlockFork.Altair:
altairBlock*: altair.TrustedSignedBeaconBlock
altairData*: altair.TrustedSignedBeaconBlock
of BeaconBlockFork.Merge:
mergeBlock*: merge.TrustedSignedBeaconBlock
mergeData*: merge.TrustedSignedBeaconBlock
EpochInfoFork* {.pure.} = enum
Phase0
@ -75,9 +75,9 @@ type
ForkedEpochInfo* = object
case kind*: EpochInfoFork
of EpochInfoFork.Phase0:
phase0Info*: phase0.EpochInfo
phase0Data*: phase0.EpochInfo
of EpochInfoFork.Altair:
altairInfo*: altair.EpochInfo
altairData*: altair.EpochInfo
ForkyEpochInfo* = phase0.EpochInfo | altair.EpochInfo
@ -89,117 +89,117 @@ type
ForkDigestsRef* = ref ForkDigests
template init*(T: type ForkedBeaconBlock, blck: phase0.BeaconBlock): T =
T(kind: BeaconBlockFork.Phase0, phase0Block: blck)
T(kind: BeaconBlockFork.Phase0, phase0Data: blck)
template init*(T: type ForkedBeaconBlock, blck: altair.BeaconBlock): T =
T(kind: BeaconBlockFork.Altair, altairBlock: blck)
T(kind: BeaconBlockFork.Altair, altairData: blck)
template init*(T: type ForkedBeaconBlock, blck: merge.BeaconBlock): T =
T(kind: BeaconBlockFork.Merge, mergeBlock: blck)
T(kind: BeaconBlockFork.Merge, mergeData: blck)
template init*(T: type ForkedSignedBeaconBlock, blck: phase0.SignedBeaconBlock): T =
T(kind: BeaconBlockFork.Phase0, phase0Block: blck)
T(kind: BeaconBlockFork.Phase0, phase0Data: blck)
template init*(T: type ForkedSignedBeaconBlock, blck: altair.SignedBeaconBlock): T =
T(kind: BeaconBlockFork.Altair, altairBlock: blck)
T(kind: BeaconBlockFork.Altair, altairData: blck)
template init*(T: type ForkedSignedBeaconBlock, blck: merge.SignedBeaconBlock): T =
T(kind: BeaconBlockFork.Merge, mergeBlock: blck)
T(kind: BeaconBlockFork.Merge, mergeData: blck)
template init*(T: type ForkedBeaconState, state: phase0.BeaconState): T =
T(beaconStateFork: BeaconStateFork.forkPhase0, bsPhase0: state)
T(kind: BeaconStateFork.Phase0, phase0Data: state)
template init*(T: type ForkedBeaconState, state: altair.BeaconState): T =
T(beaconStateFork: BeaconStateFork.forkAltair, bsAltair: state)
T(kind: BeaconStateFork.Altair, altairData: state)
template init*(T: type ForkedBeaconState, state: merge.BeaconState): T =
T(beaconStateFork: BeaconStateFork.forkMerge, bsMerge: state)
T(kind: BeaconStateFork.Merge, mergeData: state)
template init*(T: type ForkedBeaconState, state: ForkedHashedBeaconState): T =
case state.beaconStateFork
of BeaconStateFork.forkPhase0:
T(beaconStateFork: BeaconStateFork.forkPhase0,
bsPhase0: state.hbsPhase0.data)
of BeaconStateFork.forkAltair:
T(beaconStateFork: BeaconStateFork.forkAltair,
bsAltair: state.hbsAltair.data)
of BeaconStateFork.forkMerge:
T(beaconStateFork: BeaconStateFork.forkMerge,
bsMerge: state.hbsMerge.data)
case state.kind
of BeaconStateFork.Phase0:
T(kind: BeaconStateFork.Phase0,
phase0Data: state.phase0Data.data)
of BeaconStateFork.Altair:
T(kind: BeaconStateFork.Altair,
altairData: state.altairData.data)
of BeaconStateFork.Merge:
T(kind: BeaconStateFork.Merge,
mergeData: state.mergeData.data)
template init*(T: type ForkedSignedBeaconBlock, forked: ForkedBeaconBlock,
blockRoot: Eth2Digest, signature: ValidatorSig): T =
case forked.kind
of BeaconBlockFork.Phase0:
T(kind: BeaconBlockFork.Phase0,
phase0Block: phase0.SignedBeaconBlock(message: forked.phase0Block,
phase0Data: phase0.SignedBeaconBlock(message: forked.phase0Data,
root: blockRoot,
signature: signature))
of BeaconBlockFork.Altair:
T(kind: BeaconBlockFork.Altair,
altairBlock: altair.SignedBeaconBlock(message: forked.altairBlock,
altairData: altair.SignedBeaconBlock(message: forked.altairData,
root: blockRoot,
signature: signature))
of BeaconBlockFork.Merge:
T(kind: BeaconBlockFork.Merge,
mergeBlock: merge.SignedBeaconBlock(message: forked.mergeBlock,
mergeData: merge.SignedBeaconBlock(message: forked.mergeData,
root: blockRoot,
signature: signature))
template init*(T: type ForkedTrustedSignedBeaconBlock, blck: phase0.TrustedSignedBeaconBlock): T =
T(kind: BeaconBlockFork.Phase0, phase0Block: blck)
T(kind: BeaconBlockFork.Phase0, phase0Data: blck)
template init*(T: type ForkedTrustedSignedBeaconBlock, blck: altair.TrustedSignedBeaconBlock): T =
T(kind: BeaconBlockFork.Altair, altairBlock: blck)
T(kind: BeaconBlockFork.Altair, altairData: blck)
template init*(T: type ForkedTrustedSignedBeaconBlock, blck: merge.TrustedSignedBeaconBlock): T =
T(kind: BeaconBlockFork.Merge, mergeBlock: blck)
T(kind: BeaconBlockFork.Merge, mergeData: blck)
template init*(T: type ForkedEpochInfo, info: phase0.EpochInfo): T =
T(kind: EpochInfoFork.Phase0, phase0Info: info)
T(kind: EpochInfoFork.Phase0, phase0Data: info)
template init*(T: type ForkedEpochInfo, info: altair.EpochInfo): T =
T(kind: EpochInfoFork.Altair, altairInfo: info)
T(kind: EpochInfoFork.Altair, altairData: info)
# State-related functionality based on ForkedHashedBeaconState instead of HashedBeaconState
template withState*(x: ForkedHashedBeaconState, body: untyped): untyped =
case x.beaconStateFork
of forkMerge:
const stateFork {.inject.} = forkMerge
template state: untyped {.inject.} = x.hbsMerge
case x.kind
of BeaconStateFork.Merge:
const stateFork {.inject.} = BeaconStateFork.Merge
template state: untyped {.inject.} = x.mergeData
body
of forkAltair:
const stateFork {.inject.} = forkAltair
template state: untyped {.inject.} = x.hbsAltair
of BeaconStateFork.Altair:
const stateFork {.inject.} = BeaconStateFork.Altair
template state: untyped {.inject.} = x.altairData
body
of forkPhase0:
const stateFork {.inject.} = forkPhase0
template state: untyped {.inject.} = x.hbsPhase0
of BeaconStateFork.Phase0:
const stateFork {.inject.} = BeaconStateFork.Phase0
template state: untyped {.inject.} = x.phase0Data
body
template withEpochInfo*(x: ForkedEpochInfo, body: untyped): untyped =
case x.kind
of EpochInfoFork.Phase0:
template info: untyped {.inject.} = x.phase0Info
template info: untyped {.inject.} = x.phase0Data
body
of EpochInfoFork.Altair:
template info: untyped {.inject.} = x.altairInfo
template info: untyped {.inject.} = x.altairData
body
template withEpochInfo*(
state: phase0.BeaconState, x: var ForkedEpochInfo, body: untyped): untyped =
x.kind = EpochInfoFork.Phase0
template info: untyped {.inject.} = x.phase0Info
template info: untyped {.inject.} = x.phase0Data
body
template withEpochInfo*(
state: altair.BeaconState | merge.BeaconState, x: var ForkedEpochInfo,
body: untyped): untyped =
x.kind = EpochInfoFork.Altair
template info: untyped {.inject.} = x.altairInfo
template info: untyped {.inject.} = x.altairData
body
# Dispatch functions
func assign*(tgt: var ForkedHashedBeaconState, src: ForkedHashedBeaconState) =
if tgt.beaconStateFork == src.beaconStateFork:
case tgt.beaconStateFork
of forkMerge:
assign(tgt.hbsMerge, src.hbsMerge):
of forkAltair:
assign(tgt.hbsAltair, src.hbsAltair):
of forkPhase0:
assign(tgt.hbsPhase0, src.hbsPhase0):
if tgt.kind == src.kind:
case tgt.kind
of BeaconStateFork.Merge:
assign(tgt.mergeData, src.mergeData):
of BeaconStateFork.Altair:
assign(tgt.altairData, src.altairData):
of BeaconStateFork.Phase0:
assign(tgt.phase0Data, src.phase0Data):
else:
# Ensure case object and discriminator get updated simultaneously, even
# with nimOldCaseObjects. This is infrequent.
@ -211,10 +211,10 @@ template getStateField*(x: ForkedHashedBeaconState, y: untyped): untyped =
# for index, validator in getStateField(stateData.data, validators).pairs():
# ```
# Without `unsafeAddr`, the `validators` list would be copied to a temporary variable.
(case x.beaconStateFork
of forkMerge: unsafeAddr x.hbsMerge.data.y
of forkAltair: unsafeAddr x.hbsAltair.data.y
of forkPhase0: unsafeAddr x.hbsPhase0.data.y)[]
(case x.kind
of BeaconStateFork.Merge: unsafeAddr x.mergeData.data.y
of BeaconStateFork.Altair: unsafeAddr x.altairData.data.y
of BeaconStateFork.Phase0: unsafeAddr x.phase0Data.data.y)[]
func getStateRoot*(x: ForkedHashedBeaconState): Eth2Digest =
withState(x): state.root
@ -312,13 +312,13 @@ proc check_voluntary_exit*(
func stateForkAtEpoch*(cfg: RuntimeConfig, epoch: Epoch): BeaconStateFork =
## Return the current fork for the given epoch.
static:
doAssert forkMerge > forkAltair
doAssert forkAltair > forkPhase0
doAssert BeaconStateFork.Merge > BeaconStateFork.Altair
doAssert BeaconStateFork.Altair > BeaconStateFork.Phase0
doAssert GENESIS_EPOCH == 0
if epoch >= cfg.MERGE_FORK_EPOCH: forkMerge
elif epoch >= cfg.ALTAIR_FORK_EPOCH: forkAltair
else: forkPhase0
if epoch >= cfg.MERGE_FORK_EPOCH: BeaconStateFork.Merge
elif epoch >= cfg.ALTAIR_FORK_EPOCH: BeaconStateFork.Altair
else: BeaconStateFork.Phase0
func blockForkAtEpoch*(cfg: RuntimeConfig, epoch: Epoch): BeaconBlockFork =
## Return the current fork for the given epoch.
@ -384,16 +384,16 @@ template withBlck*(
body: untyped): untyped =
case x.kind
of BeaconBlockFork.Phase0:
const stateFork {.inject.} = forkPhase0
template blck: untyped {.inject.} = x.phase0Block
const stateFork {.inject.} = BeaconStateFork.Phase0
template blck: untyped {.inject.} = x.phase0Data
body
of BeaconBlockFork.Altair:
const stateFork {.inject.} = forkAltair
template blck: untyped {.inject.} = x.altairBlock
const stateFork {.inject.} = BeaconStateFork.Altair
template blck: untyped {.inject.} = x.altairData
body
of BeaconBlockFork.Merge:
const stateFork {.inject.} = forkMerge
template blck: untyped {.inject.} = x.mergeBlock
const stateFork {.inject.} = BeaconStateFork.Merge
template blck: untyped {.inject.} = x.mergeData
body
func proposer_index*(x: ForkedBeaconBlock): uint64 =
@ -405,9 +405,9 @@ func hash_tree_root*(x: ForkedBeaconBlock): Eth2Digest =
template getForkedBlockField*(x: ForkedSignedBeaconBlock | ForkedTrustedSignedBeaconBlock, y: untyped): untyped =
# unsafeAddr avoids a copy of the field in some cases
(case x.kind
of BeaconBlockFork.Phase0: unsafeAddr x.phase0Block.message.y
of BeaconBlockFork.Altair: unsafeAddr x.altairBlock.message.y
of BeaconBlockFork.Merge: unsafeAddr x.mergeBlock.message.y)[]
of BeaconBlockFork.Phase0: unsafeAddr x.phase0Data.message.y
of BeaconBlockFork.Altair: unsafeAddr x.altairData.message.y
of BeaconBlockFork.Merge: unsafeAddr x.mergeData.message.y)[]
template signature*(x: ForkedSignedBeaconBlock): ValidatorSig =
withBlck(x): blck.signature
@ -436,40 +436,40 @@ template withStateAndBlck*(
b: ForkedBeaconBlock | ForkedSignedBeaconBlock |
ForkedTrustedSignedBeaconBlock,
body: untyped): untyped =
case s.beaconStateFork
of forkMerge:
const stateFork {.inject.} = forkMerge
template state: untyped {.inject.} = s.hbsMerge
template blck: untyped {.inject.} = b.mergeBlock
case s.kind
of BeaconStateFork.Merge:
const stateFork {.inject.} = BeaconStateFork.Merge
template state: untyped {.inject.} = s.mergeData
template blck: untyped {.inject.} = b.mergeData
body
of forkAltair:
const stateFork {.inject.} = forkAltair
template state: untyped {.inject.} = s.hbsAltair
template blck: untyped {.inject.} = b.altairBlock
of BeaconStateFork.Altair:
const stateFork {.inject.} = BeaconStateFork.Altair
template state: untyped {.inject.} = s.altairData
template blck: untyped {.inject.} = b.altairData
body
of forkPhase0:
const stateFork {.inject.} = forkPhase0
template state: untyped {.inject.} = s.hbsPhase0
template blck: untyped {.inject.} = b.phase0Block
of BeaconStateFork.Phase0:
const stateFork {.inject.} = BeaconStateFork.Phase0
template state: untyped {.inject.} = s.phase0Data
template blck: untyped {.inject.} = b.phase0Data
body
proc forkAtEpoch*(cfg: RuntimeConfig, epoch: Epoch): Fork =
case cfg.stateForkAtEpoch(epoch)
of forkMerge: cfg.mergeFork
of forkAltair: cfg.altairFork
of forkPhase0: cfg.genesisFork
of BeaconStateFork.Merge: cfg.mergeFork
of BeaconStateFork.Altair: cfg.altairFork
of BeaconStateFork.Phase0: cfg.genesisFork
proc forkVersionAtEpoch*(cfg: RuntimeConfig, epoch: Epoch): Version =
case cfg.stateForkAtEpoch(epoch)
of forkMerge: cfg.MERGE_FORK_VERSION
of forkAltair: cfg.ALTAIR_FORK_VERSION
of forkPhase0: cfg.GENESIS_FORK_VERSION
of BeaconStateFork.Merge: cfg.MERGE_FORK_VERSION
of BeaconStateFork.Altair: cfg.ALTAIR_FORK_VERSION
of BeaconStateFork.Phase0: cfg.GENESIS_FORK_VERSION
proc nextForkEpochAtEpoch*(cfg: RuntimeConfig, epoch: Epoch): Epoch =
case cfg.stateForkAtEpoch(epoch)
of forkMerge: FAR_FUTURE_EPOCH
of forkAltair: cfg.MERGE_FORK_EPOCH
of forkPhase0: cfg.ALTAIR_FORK_EPOCH
of BeaconStateFork.Merge: FAR_FUTURE_EPOCH
of BeaconStateFork.Altair: cfg.MERGE_FORK_EPOCH
of BeaconStateFork.Phase0: cfg.ALTAIR_FORK_EPOCH
func getForkSchedule*(cfg: RuntimeConfig): array[2, Fork] =
## This procedure returns list of known and/or scheduled forks.

105
beacon_chain/spec/state_transition.nim
View File

@ -195,11 +195,11 @@ proc maybeUpgradeStateToAltair(
# 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.kind == BeaconStateFork.Phase0:
var newState = upgrade_to_altair(cfg, state.phase0Data.data)
state = (ref ForkedHashedBeaconState)(
beaconStateFork: forkAltair,
hbsAltair: altair.HashedBeaconState(
kind: BeaconStateFork.Altair,
altairData: altair.HashedBeaconState(
root: hash_tree_root(newState[]), data: newState[]))[]
func maybeUpgradeStateToMerge(
@ -207,11 +207,11 @@ func maybeUpgradeStateToMerge(
# 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.kind == BeaconStateFork.Altair:
var newState = upgrade_to_merge(cfg, state.altairData.data)
state = (ref ForkedHashedBeaconState)(
beaconStateFork: forkMerge,
hbsMerge: merge.HashedBeaconState(
kind: BeaconStateFork.Merge,
mergeData: merge.HashedBeaconState(
root: hash_tree_root(newState[]), data: newState[]))[]
proc maybeUpgradeState*(
@ -369,9 +369,7 @@ template partialBeaconBlock(
graffiti: GraffitiBytes,
attestations: seq[Attestation],
deposits: seq[Deposit],
proposerSlashings: seq[ProposerSlashing],
attesterSlashings: seq[AttesterSlashing],
voluntaryExits: seq[SignedVoluntaryExit],
exits: BeaconBlockExits,
sync_aggregate: SyncAggregate,
executionPayload: ExecutionPayload): phase0.BeaconBlock =
phase0.BeaconBlock(
@ -382,14 +380,11 @@ template partialBeaconBlock(
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),
proposer_slashings: exits.proposer_slashings,
attester_slashings: exits.attester_slashings,
attestations: List[Attestation, Limit MAX_ATTESTATIONS](attestations),
deposits: List[Deposit, Limit MAX_DEPOSITS](deposits),
voluntary_exits:
List[SignedVoluntaryExit, Limit MAX_VOLUNTARY_EXITS](voluntaryExits)))
voluntary_exits: exits.voluntary_exits))
proc makeBeaconBlock*(
cfg: RuntimeConfig,
@ -401,9 +396,7 @@ proc makeBeaconBlock*(
graffiti: GraffitiBytes,
attestations: seq[Attestation],
deposits: seq[Deposit],
proposerSlashings: seq[ProposerSlashing],
attesterSlashings: seq[AttesterSlashing],
voluntaryExits: seq[SignedVoluntaryExit],
exits: BeaconBlockExits,
sync_aggregate: SyncAggregate,
executionPayload: ExecutionPayload,
rollback: RollbackHashedProc,
@ -417,8 +410,7 @@ proc makeBeaconBlock*(
var blck = partialBeaconBlock(cfg, state, proposer_index, parent_root,
randao_reveal, eth1_data, graffiti, attestations, deposits,
proposerSlashings, attesterSlashings, voluntaryExits,
sync_aggregate, executionPayload)
exits, sync_aggregate, executionPayload)
let res = process_block(cfg, state.data, blck, {skipBlsValidation}, cache)
@ -447,9 +439,7 @@ template partialBeaconBlock(
graffiti: GraffitiBytes,
attestations: seq[Attestation],
deposits: seq[Deposit],
proposerSlashings: seq[ProposerSlashing],
attesterSlashings: seq[AttesterSlashing],
voluntaryExits: seq[SignedVoluntaryExit],
exits: BeaconBlockExits,
sync_aggregate: SyncAggregate,
executionPayload: ExecutionPayload): altair.BeaconBlock =
altair.BeaconBlock(
@ -460,14 +450,11 @@ template partialBeaconBlock(
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),
proposer_slashings: exits.proposer_slashings,
attester_slashings: exits.attester_slashings,
attestations: List[Attestation, Limit MAX_ATTESTATIONS](attestations),
deposits: List[Deposit, Limit MAX_DEPOSITS](deposits),
voluntary_exits:
List[SignedVoluntaryExit, Limit MAX_VOLUNTARY_EXITS](voluntaryExits),
voluntary_exits: exits.voluntary_exits,
sync_aggregate: sync_aggregate))
proc makeBeaconBlock*(
@ -480,9 +467,7 @@ proc makeBeaconBlock*(
graffiti: GraffitiBytes,
attestations: seq[Attestation],
deposits: seq[Deposit],
proposerSlashings: seq[ProposerSlashing],
attesterSlashings: seq[AttesterSlashing],
voluntaryExits: seq[SignedVoluntaryExit],
exits: BeaconBlockExits,
sync_aggregate: SyncAggregate,
executionPayload: ExecutionPayload,
rollback: RollbackAltairHashedProc,
@ -496,8 +481,7 @@ proc makeBeaconBlock*(
var blck = partialBeaconBlock(cfg, state, proposer_index, parent_root,
randao_reveal, eth1_data, graffiti, attestations, deposits,
proposerSlashings, attesterSlashings, voluntaryExits,
sync_aggregate, executionPayload)
exits, sync_aggregate, executionPayload)
let res = process_block(cfg, state.data, blck, {skipBlsValidation}, cache)
@ -526,9 +510,7 @@ template partialBeaconBlock(
graffiti: GraffitiBytes,
attestations: seq[Attestation],
deposits: seq[Deposit],
proposerSlashings: seq[ProposerSlashing],
attesterSlashings: seq[AttesterSlashing],
voluntaryExits: seq[SignedVoluntaryExit],
exits: BeaconBlockExits,
sync_aggregate: SyncAggregate,
executionPayload: ExecutionPayload): merge.BeaconBlock =
merge.BeaconBlock(
@ -539,14 +521,11 @@ template partialBeaconBlock(
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),
proposer_slashings: exits.proposer_slashings,
attester_slashings: exits.attester_slashings,
attestations: List[Attestation, Limit MAX_ATTESTATIONS](attestations),
deposits: List[Deposit, Limit MAX_DEPOSITS](deposits),
voluntary_exits:
List[SignedVoluntaryExit, Limit MAX_VOLUNTARY_EXITS](voluntaryExits),
voluntary_exits: exits.voluntary_exits,
sync_aggregate: sync_aggregate,
execution_payload: executionPayload))
@ -560,9 +539,7 @@ proc makeBeaconBlock*(
graffiti: GraffitiBytes,
attestations: seq[Attestation],
deposits: seq[Deposit],
proposerSlashings: seq[ProposerSlashing],
attesterSlashings: seq[AttesterSlashing],
voluntaryExits: seq[SignedVoluntaryExit],
exits: BeaconBlockExits,
sync_aggregate: SyncAggregate,
executionPayload: ExecutionPayload,
rollback: RollbackMergeHashedProc,
@ -576,8 +553,7 @@ proc makeBeaconBlock*(
var blck = partialBeaconBlock(cfg, state, proposer_index, parent_root,
randao_reveal, eth1_data, graffiti, attestations, deposits,
proposerSlashings, attesterSlashings, voluntaryExits,
sync_aggregate, executionPayload)
exits, sync_aggregate, executionPayload)
let res = process_block(cfg, state.data, blck, {skipBlsValidation}, cache)
@ -605,9 +581,7 @@ proc makeBeaconBlock*(
graffiti: GraffitiBytes,
attestations: seq[Attestation],
deposits: seq[Deposit],
proposerSlashings: seq[ProposerSlashing],
attesterSlashings: seq[AttesterSlashing],
voluntaryExits: seq[SignedVoluntaryExit],
exits: BeaconBlockExits,
sync_aggregate: SyncAggregate,
executionPayload: ExecutionPayload,
rollback: RollbackForkedHashedProc,
@ -622,29 +596,28 @@ proc makeBeaconBlock*(
var blck =
ForkedBeaconBlock.init(
partialBeaconBlock(cfg, state.`hbs kind`, proposer_index, parent_root,
partialBeaconBlock(cfg, state.`kind Data`, proposer_index, parent_root,
randao_reveal, eth1_data, graffiti, attestations, deposits,
proposerSlashings, attesterSlashings, voluntaryExits,
sync_aggregate, executionPayload))
exits, sync_aggregate, executionPayload))
let res = process_block(cfg, state.`hbs kind`.data, blck.`kind Block`,
let res = process_block(cfg, state.`kind Data`.data, blck.`kind Data`,
{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),
slot = state.`kind Data`.data.slot,
eth1_deposit_index = state.`kind Data`.data.eth1_deposit_index,
deposit_root = shortLog(state.`kind Data`.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
state.`kind Data`.root = hash_tree_root(state.`kind Data`.data)
blck.`kind Data`.state_root = state.`kind Data`.root
ok(blck)
case state.beaconStateFork
of forkPhase0: makeBeaconBlock(phase0)
of forkAltair: makeBeaconBlock(altair)
of forkMerge: makeBeaconBlock(merge)
case state.kind
of BeaconStateFork.Phase0: makeBeaconBlock(phase0)
of BeaconStateFork.Altair: makeBeaconBlock(altair)
of BeaconStateFork.Merge: makeBeaconBlock(merge)

10
beacon_chain/sync/sync_protocol.nim
View File

@ -95,15 +95,15 @@ proc sendResponseChunk*(response: UntypedResponse,
case val.kind
of BeaconBlockFork.Phase0:
response.stream.writeChunk(some ResponseCode.Success,
SSZ.encode(val.phase0Block),
SSZ.encode(val.phase0Data),
response.peer.network.forkDigests.phase0.bytes)
of BeaconBlockFork.Altair:
response.stream.writeChunk(some ResponseCode.Success,
SSZ.encode(val.altairBlock),
SSZ.encode(val.altairData),
response.peer.network.forkDigests.altair.bytes)
of BeaconBlockFork.Merge:
response.stream.writeChunk(some ResponseCode.Success,
SSZ.encode(val.mergeBlock),
SSZ.encode(val.mergeData),
response.peer.network.forkDigests.merge.bytes)
func shortLog*(s: StatusMsg): auto =
@ -232,7 +232,7 @@ p2pProtocol BeaconSync(version = 1,
let blk = dag.get(blocks[i]).data
case blk.kind
of BeaconBlockFork.Phase0:
await response.write(blk.phase0Block.asSigned)
await response.write(blk.phase0Data.asSigned)
of BeaconBlockFork.Altair, BeaconBlockFork.Merge:
# Skipping all subsequent blocks should be OK because the spec says:
# "Clients MAY limit the number of blocks in the response."
@ -271,7 +271,7 @@ p2pProtocol BeaconSync(version = 1,
let blk = dag.get(blockRef).data
case blk.kind
of BeaconBlockFork.Phase0:
await response.write(blk.phase0Block.asSigned)
await response.write(blk.phase0Data.asSigned)
inc found
of BeaconBlockFork.Altair, BeaconBlockFork.Merge:
# Skipping this block should be fine because the spec says:

6
beacon_chain/validator_client/api.nim
View File

@ -767,13 +767,13 @@ proc publishBlock*(vc: ValidatorClientRef,
vc.firstSuccessTimeout(RestPlainResponse, SlotDuration):
case data.kind
of BeaconBlockFork.Phase0:
publishBlock(it, data.phase0Block)
publishBlock(it, data.phase0Data)
of BeaconBlockFork.Altair:
publishBlock(it, data.altairBlock)
publishBlock(it, data.altairData)
of BeaconBlockFork.Merge:
raiseAssert "trying to publish merge block"
# TODO this doesn't build due to some nim-presto error
# publishBlock(it, data.mergeBlock)
# publishBlock(it, data.mergeData)
do:
if apiResponse.isErr():
debug "Unable to publish block", endpoint = node,

26
beacon_chain/validators/validator_duties.nim
View File

@ -264,7 +264,7 @@ proc sendSyncCommitteeMessages*(node: BeaconNode,
let (pending, indices) =
withState(node.dag.headState.data):
when stateFork >= forkAltair:
when stateFork >= BeaconStateFork.Altair:
var resFutures: seq[Future[SendResult]]
var resIndices: seq[int]
for committeeIdx in allSyncCommittees():
@ -419,6 +419,8 @@ proc makeBeaconBlockForHeadAndSlot*(node: BeaconNode,
doAssert v.addr == addr proposalStateAddr.data
assign(proposalStateAddr[], poolPtr.headState)
let exits = withState(stateData.data):
node.exitPool[].getBeaconBlockExits(state.data)
return makeBeaconBlock(
node.dag.cfg,
stateData.data,
@ -429,9 +431,7 @@ proc makeBeaconBlockForHeadAndSlot*(node: BeaconNode,
graffiti,
node.attestationPool[].getAttestationsForBlock(stateData.data, cache),
eth1Proposal.deposits,
node.exitPool[].getProposerSlashingsForBlock(),
node.exitPool[].getAttesterSlashingsForBlock(),
node.exitPool[].getVoluntaryExitsForBlock(),
exits,
if slot.epoch < node.dag.cfg.ALTAIR_FORK_EPOCH:
SyncAggregate.init()
else:
@ -448,7 +448,7 @@ proc proposeSignedBlock*(node: BeaconNode,
let newBlockRef =
case newBlock.kind:
of BeaconBlockFork.Phase0:
node.dag.addRawBlock(node.quarantine, newBlock.phase0Block) do (
node.dag.addRawBlock(node.quarantine, newBlock.phase0Data) do (
blckRef: BlockRef, trustedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
# Callback add to fork choice if signed block valid (and becomes trusted)
@ -456,7 +456,7 @@ proc proposeSignedBlock*(node: BeaconNode,
epochRef, blckRef, trustedBlock.message,
node.beaconClock.now().slotOrZero())
of BeaconBlockFork.Altair:
node.dag.addRawBlock(node.quarantine, newBlock.altairBlock) do (
node.dag.addRawBlock(node.quarantine, newBlock.altairData) do (
blckRef: BlockRef, trustedBlock: altair.TrustedSignedBeaconBlock,
epochRef: EpochRef):
# Callback add to fork choice if signed block valid (and becomes trusted)
@ -464,7 +464,7 @@ proc proposeSignedBlock*(node: BeaconNode,
epochRef, blckRef, trustedBlock.message,
node.beaconClock.now().slotOrZero())
of BeaconBlockFork.Merge:
node.dag.addRawBlock(node.quarantine, newBlock.mergeBlock) do (
node.dag.addRawBlock(node.quarantine, newBlock.mergeData) do (
blckRef: BlockRef, trustedBlock: merge.TrustedSignedBeaconBlock,
epochRef: EpochRef):
# Callback add to fork choice if signed block valid (and becomes trusted)
@ -524,7 +524,7 @@ proc proposeBlock(node: BeaconNode,
# general this is far too much copy/paste
let forked = case blck.kind:
of BeaconBlockFork.Phase0:
let root = hash_tree_root(blck.phase0Block)
let root = hash_tree_root(blck.phase0Data)
# TODO: recomputed in block proposal
let signing_root = compute_block_root(
@ -544,10 +544,10 @@ proc proposeBlock(node: BeaconNode,
fork, genesis_validators_root, slot, root)
ForkedSignedBeaconBlock.init(
phase0.SignedBeaconBlock(
message: blck.phase0Block, root: root, signature: signature)
message: blck.phase0Data, root: root, signature: signature)
)
of BeaconBlockFork.Altair:
let root = hash_tree_root(blck.altairBlock)
let root = hash_tree_root(blck.altairData)
# TODO: recomputed in block proposal
let signing_root = compute_block_root(
@ -568,10 +568,10 @@ proc proposeBlock(node: BeaconNode,
ForkedSignedBeaconBlock.init(
altair.SignedBeaconBlock(
message: blck.altairBlock, root: root, signature: signature)
message: blck.altairData, root: root, signature: signature)
)
of BeaconBlockFork.Merge:
let root = hash_tree_root(blck.mergeBlock)
let root = hash_tree_root(blck.mergeData)
# TODO: recomputed in block proposal
let signing_root = compute_block_root(
@ -592,7 +592,7 @@ proc proposeBlock(node: BeaconNode,
ForkedSignedBeaconBlock.init(
merge.SignedBeaconBlock(
message: blck.mergeBlock, root: root, signature: signature)
message: blck.mergeData, root: root, signature: signature)
)
return await node.proposeSignedBlock(head, validator, forked)

8
nbench/scenarios.nim
View File

@ -149,8 +149,8 @@ proc runFullTransition*(dir, preState, blocksPrefix: string, blocksQty: int, ski
echo "Running: ", prePath
let state = (ref ForkedHashedBeaconState)(
hbsPhase0: phase0.HashedBeaconState(data: parseSSZ(prePath, phase0.BeaconState)),
beaconStateFork: forkPhase0
phase0Data: phase0.HashedBeaconState(data: parseSSZ(prePath, phase0.BeaconState)),
kind: BeaconStateFork.Phase0
)
setStateRoot(state[], hash_tree_root(state[]))
@ -174,9 +174,9 @@ proc runProcessSlots*(dir, preState: string, numSlots: uint64) =
echo "Running: ", prePath
let state = (ref ForkedHashedBeaconState)(
hbsPhase0: phase0.HashedBeaconState(
phase0Data: phase0.HashedBeaconState(
data: parseSSZ(prePath, phase0.BeaconState)),
beaconStateFork: forkPhase0)
kind: BeaconStateFork.Phase0)
setStateRoot(state[], hash_tree_root(state[]))
# Shouldn't necessarily assert, because nbench can run test suite

16
ncli/ncli.nim
View File

@ -74,17 +74,17 @@ type
desc: "Filename of state resulting from applying blck to preState"}: string
template saveSSZFile(filename: string, value: ForkedHashedBeaconState) =
case value.beaconStateFork:
of forkPhase0: SSZ.saveFile(filename, value.hbsPhase0.data)
of forkAltair: SSZ.saveFile(filename, value.hbsAltair.data)
of forkMerge: SSZ.saveFile(filename, value.hbsMerge.data)
case value.kind:
of BeaconStateFork.Phase0: SSZ.saveFile(filename, value.phase0Data.data)
of BeaconStateFork.Altair: SSZ.saveFile(filename, value.altairData.data)
of BeaconStateFork.Merge: SSZ.saveFile(filename, value.mergeData.data)
proc doTransition(conf: NcliConf) =
let
stateY = (ref ForkedHashedBeaconState)(
hbsPhase0: phase0.HashedBeaconState(
phase0Data: phase0.HashedBeaconState(
data: SSZ.loadFile(conf.preState, phase0.BeaconState)),
beaconStateFork: forkPhase0
kind: BeaconStateFork.Phase0
)
blckX = SSZ.loadFile(conf.blck, phase0.SignedBeaconBlock)
flags = if not conf.verifyStateRoot: {skipStateRootValidation} else: {}
@ -112,9 +112,9 @@ proc doSlots(conf: NcliConf) =
var timers: array[Timers, RunningStat]
let
stateY = withTimerRet(timers[tLoadState]): (ref ForkedHashedBeaconState)(
hbsPhase0: phase0.HashedBeaconState(
phase0Data: phase0.HashedBeaconState(
data: SSZ.loadFile(conf.preState2, phase0.BeaconState)),
beaconStateFork: forkPhase0
kind: BeaconStateFork.Phase0
)
setStateRoot(stateY[], hash_tree_root(stateY[]))

8
ncli/ncli_db.nim
View File

@ -370,7 +370,7 @@ proc cmdRewindState(conf: DbConf, cfg: RuntimeConfig) =
let tmpState = assignClone(dag.headState)
dag.withState(tmpState[], blckRef.atSlot(Slot(conf.slot))):
echo "Writing state..."
dump("./", stateData.data.hbsPhase0, blck)
dump("./", stateData.data.phase0Data, blck)
func atCanonicalSlot(blck: BlockRef, slot: Slot): BlockSlot =
if slot == 0:
@ -408,7 +408,7 @@ proc cmdExportEra(conf: DbConf, cfg: RuntimeConfig) =
defer: e2s.close()
dag.withState(tmpState[], canonical):
e2s.appendRecord(stateData.data.hbsPhase0.data).get()
e2s.appendRecord(stateData.data.phase0Data.data).get()
var
ancestors: seq[BlockRef]
@ -492,7 +492,7 @@ proc cmdValidatorPerf(conf: DbConf, cfg: RuntimeConfig) =
indices
case info.kind
of EpochInfoFork.Phase0:
template info: untyped = info.phase0Info
template info: untyped = info.phase0Data
for i, s in info.statuses.pairs():
let perf = addr perfs[i]
if RewardFlags.isActiveInPreviousEpoch in s.flags:
@ -719,7 +719,7 @@ proc cmdValidatorDb(conf: DbConf, cfg: RuntimeConfig) =
inTxn = true
case info.kind
of EpochInfoFork.Phase0:
template info: untyped = info.phase0Info
template info: untyped = info.phase0Data
insertEpochInfo.exec(
(getStateField(state[].data, slot).epoch.int64,
info.total_balances.current_epoch_raw.int64,

6
nfuzz/libnfuzz.nim
View File

@ -114,15 +114,15 @@ proc nfuzz_block(input: openArray[byte], xoutput: ptr byte,
rollback: RollbackForkedHashedProc): auto =
var
fhState = (ref ForkedHashedBeaconState)(
hbsPhase0: phase0.HashedBeaconState(
phase0Data: phase0.HashedBeaconState(
data: data.state, root: hash_tree_root(data.state)),
beaconStateFork: forkPhase0)
kind: BeaconStateFork.Phase0)
cache = StateCache()
info = ForkedEpochInfo()
result =
state_transition(
cfg, fhState[], blck, cache, info, flags, rollback)
data.state = fhState.hbsPhase0.data
data.state = fhState.phase0Data.data
decodeAndProcess(BlockInput):
state_transition(defaultRuntimeConfig, data, data.beaconBlock, flags, noRollback)

16
research/block_sim.nim
View File

@ -244,11 +244,11 @@ cli do(slots = SLOTS_PER_EPOCH * 6,
static: doAssert false
hashedState =
when T is phase0.SignedBeaconBlock:
addr stateData.data.hbsPhase0
addr stateData.data.phase0Data
elif T is altair.SignedBeaconBlock:
addr stateData.data.hbsAltair
addr stateData.data.altairData
elif T is merge.SignedBeaconBlock:
addr stateData.data.hbsMerge
addr stateData.data.mergeData
else:
static: doAssert false
message = makeBeaconBlock(
@ -264,9 +264,7 @@ cli do(slots = SLOTS_PER_EPOCH * 6,
default(GraffitiBytes),
attPool.getAttestationsForBlock(stateData.data, cache),
eth1ProposalData.deposits,
@[],
@[],
@[],
BeaconBlockExits(),
sync_aggregate,
default(ExecutionPayload),
noRollback,
@ -392,9 +390,9 @@ cli do(slots = SLOTS_PER_EPOCH * 6,
if blockRatio > 0.0:
withTimer(timers[t]):
case dag.cfg.stateForkAtEpoch(slot.epoch)
of forkMerge: proposeMergeBlock(slot)
of forkAltair: proposeAltairBlock(slot)
of forkPhase0: proposePhase0Block(slot)
of BeaconStateFork.Merge: proposeMergeBlock(slot)
of BeaconStateFork.Altair: proposeAltairBlock(slot)
of BeaconStateFork.Phase0: proposePhase0Block(slot)
if attesterRatio > 0.0:
withTimer(timers[tAttest]):
handleAttestations(slot)

12
research/state_sim.nim
View File

@ -44,7 +44,7 @@ cli do(slots = SLOTS_PER_EPOCH * 5,
(hashedState, _) = loadGenesis(validators, validate)
genesisBlock = get_initial_beacon_block(hashedState.data)
state = (ref ForkedHashedBeaconState)(
hbsPhase0: hashedState[], beaconStateFork: forkPhase0)
phase0Data: hashedState[], kind: BeaconStateFork.Phase0)
echo "Starting simulation..."
@ -65,10 +65,10 @@ cli do(slots = SLOTS_PER_EPOCH * 5,
write(stdout, ".")
if last:
writeJson("state.json", state[].hbsPhase0)
writeJson("state.json", state[].phase0Data)
else:
if getStateField(state[], slot) mod json_interval.uint64 == 0:
writeJson(jsonName(prefix, getStateField(state[], slot)), state[].hbsPhase0.data)
writeJson(jsonName(prefix, getStateField(state[], slot)), state[].phase0Data.data)
write(stdout, ":")
else:
write(stdout, ".")
@ -79,7 +79,7 @@ cli do(slots = SLOTS_PER_EPOCH * 5,
for i in 0..<slots:
maybeWrite(false)
verifyConsensus(state[].hbsPhase0.data, attesterRatio)
verifyConsensus(state[].phase0Data.data, attesterRatio)
let
attestations_idx = getStateField(state[], slot)
@ -97,7 +97,7 @@ cli do(slots = SLOTS_PER_EPOCH * 5,
withTimer(timers[t]):
signedBlock = addTestBlock(
state[], latest_block_root, cache, attestations = blockAttestations,
flags = flags).phase0Block
flags = flags).phase0Data
latest_block_root = withTimerRet(timers[tHashBlock]):
hash_tree_root(signedBlock.message)
signedBlock.root = latest_block_root
@ -168,4 +168,4 @@ cli do(slots = SLOTS_PER_EPOCH * 5,
echo "Done!"
printTimers(state[].hbsPhase0.data, attesters, validate, timers)
printTimers(state[].phase0Data.data, attesters, validate, timers)

6
tests/consensus_spec/altair/test_fixture_sanity_blocks.nim
View File

@ -33,8 +33,8 @@ proc runTest(testName, testDir, unitTestName: string) =
test prefix & testName & " - " & unitTestName & preset():
var
preState = newClone(parseTest(testPath/"pre.ssz_snappy", SSZ, altair.BeaconState))
fhPreState = (ref ForkedHashedBeaconState)(hbsAltair: altair.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), beaconStateFork: forkAltair)
fhPreState = (ref ForkedHashedBeaconState)(altairData: altair.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), kind: BeaconStateFork.Altair)
cache = StateCache()
info = ForkedEpochInfo()
@ -59,7 +59,7 @@ proc runTest(testName, testDir, unitTestName: string) =
if hasPostState:
let postState = newClone(parseTest(testPath/"post.ssz_snappy", SSZ, altair.BeaconState))
when false:
reportDiff(fhPreState.hbsAltair.data, postState)
reportDiff(fhPreState.altairData.data, postState)
doAssert getStateRoot(fhPreState[]) == postState[].hash_tree_root()
`testImpl _ blck _ testName`()

6
tests/consensus_spec/altair/test_fixture_sanity_slots.nim
View File

@ -31,9 +31,9 @@ proc runTest(identifier: string) =
var
preState = newClone(parseTest(testDir/"pre.ssz_snappy", SSZ, altair.BeaconState))
fhPreState = (ref ForkedHashedBeaconState)(
hbsAltair: altair.HashedBeaconState(
altairData: altair.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])),
beaconStateFork: forkAltair)
kind: BeaconStateFork.Altair)
cache = StateCache()
info: ForkedEpochInfo
let postState = newClone(parseTest(testDir/"post.ssz_snappy", SSZ, altair.BeaconState))
@ -44,7 +44,7 @@ proc runTest(identifier: string) =
getStateField(fhPreState[], slot) + num_slots, cache, info, {})
getStateRoot(fhPreState[]) == postState[].hash_tree_root()
let newPreState = newClone(fhPreState.hbsAltair.data)
let newPreState = newClone(fhPreState.altairData.data)
reportDiff(newPreState, postState)
`testImpl _ slots _ identifier`()

20
tests/consensus_spec/altair/test_fixture_sync_protocol.nim
View File

@ -25,7 +25,7 @@ proc compute_aggregate_sync_committee_signature(
forked: ForkedHashedBeaconState,
participants: openArray[ValidatorIndex],
block_root = ZERO_HASH): ValidatorSig =
template state: untyped {.inject.} = forked.hbsAltair.data
template state: untyped {.inject.} = forked.altairData.data
if len(participants) == 0:
return ValidatorSig.infinity
@ -33,7 +33,7 @@ proc compute_aggregate_sync_committee_signature(
let
root =
if block_root != ZERO_HASH: block_root
else: mockBlockForNextSlot(forked).altairBlock.message.parent_root
else: mockBlockForNextSlot(forked).altairData.message.parent_root
signing_root = sync_committee_msg_signing_root(
state.fork, state.slot.epoch, state.genesis_validators_root, root)
@ -56,7 +56,7 @@ proc block_for_next_slot(
forked: var ForkedHashedBeaconState,
cache: var StateCache,
withAttestations = false): ForkedSignedBeaconBlock =
template state: untyped {.inject.} = forked.hbsAltair.data
template state: untyped {.inject.} = forked.altairData.data
let parent_root = block:
var previous_block_header = state.latest_block_header
@ -89,7 +89,7 @@ suite "Ethereum Foundation - Altair - Unittests - Sync protocol" & preset():
# https://github.com/ethereum/consensus-specs/blob/v1.1.0/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py#L25-L81
test "process_light_client_update_not_updated":
var forked = assignClone(genesisState[])
template state: untyped {.inject.} = forked[].hbsAltair.data
template state: untyped {.inject.} = forked[].altairData.data
let pre_snapshot = LightClientSnapshot(
current_sync_committee: state.current_sync_committee,
@ -100,7 +100,7 @@ suite "Ethereum Foundation - Altair - Unittests - Sync protocol" & preset():
# so it won't update snapshot
var cache = StateCache()
let
signed_block = block_for_next_slot(cfg, forked[], cache).altairBlock
signed_block = block_for_next_slot(cfg, forked[], cache).altairData
block_header = BeaconBlockHeader(
slot: signed_block.message.slot,
proposer_index: signed_block.message.proposer_index,
@ -144,7 +144,7 @@ suite "Ethereum Foundation - Altair - Unittests - Sync protocol" & preset():
# https://github.com/ethereum/consensus-specs/blob/v1.1.0/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py#L84-L147
test "process_light_client_update_timeout":
var forked = assignClone(genesisState[])
template state: untyped {.inject.} = forked[].hbsAltair.data
template state: untyped {.inject.} = forked[].altairData.data
let pre_snapshot = LightClientSnapshot(
current_sync_committee: state.current_sync_committee,
@ -165,7 +165,7 @@ suite "Ethereum Foundation - Altair - Unittests - Sync protocol" & preset():
check: snapshot_period + 1 == update_period
let
signed_block = block_for_next_slot(cfg, forked[], cache).altairBlock
signed_block = block_for_next_slot(cfg, forked[], cache).altairData
block_header = BeaconBlockHeader(
slot: signed_block.message.slot,
proposer_index: signed_block.message.proposer_index,
@ -210,7 +210,7 @@ suite "Ethereum Foundation - Altair - Unittests - Sync protocol" & preset():
# https://github.com/ethereum/consensus-specs/blob/v1.1.0/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py#L150-L221
test "process_light_client_update_finality_updated":
var forked = assignClone(genesisState[])
template state: untyped {.inject.} = forked[].hbsAltair.data
template state: untyped {.inject.} = forked[].altairData.data
let pre_snapshot = LightClientSnapshot(
current_sync_committee: state.current_sync_committee,
@ -241,7 +241,7 @@ suite "Ethereum Foundation - Altair - Unittests - Sync protocol" & preset():
var next_sync_committee_branch:
array[log2trunc(NEXT_SYNC_COMMITTEE_INDEX), Eth2Digest]
let
finalized_block = blocks[SLOTS_PER_EPOCH - 1].altairBlock
finalized_block = blocks[SLOTS_PER_EPOCH - 1].altairData
finalized_block_header = BeaconBlockHeader(
slot: finalized_block.message.slot,
proposer_index: finalized_block.message.proposer_index,
@ -259,7 +259,7 @@ suite "Ethereum Foundation - Altair - Unittests - Sync protocol" & preset():
# Build block header
let
blck = mockBlock(forked[], state.slot, cfg = cfg).altairBlock.message
blck = mockBlock(forked[], state.slot, cfg = cfg).altairData.message
block_header = BeaconBlockHeader(
slot: blck.slot,
proposer_index: blck.proposer_index,

4
tests/consensus_spec/altair/test_fixture_transition.nim
View File

@ -44,8 +44,8 @@ proc runTest(testName, testDir, unitTestName: string) =
test testName & " - " & unitTestName & preset():
var
preState = newClone(parseTest(testPath/"pre.ssz_snappy", SSZ, phase0.BeaconState))
fhPreState = (ref ForkedHashedBeaconState)(hbsPhase0: phase0.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), beaconStateFork: forkPhase0)
fhPreState = (ref ForkedHashedBeaconState)(phase0Data: phase0.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), kind: BeaconStateFork.Phase0)
cache = StateCache()
info = ForkedEpochInfo()
cfg = defaultRuntimeConfig

6
tests/consensus_spec/merge/test_fixture_sanity_blocks.nim
View File

@ -33,8 +33,8 @@ proc runTest(testName, testDir, unitTestName: string) =
test prefix & testName & " - " & unitTestName & preset():
var
preState = newClone(parseTest(testPath/"pre.ssz_snappy", SSZ, merge.BeaconState))
fhPreState = (ref ForkedHashedBeaconState)(hbsMerge: merge.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), beaconStateFork: forkMerge)
fhPreState = (ref ForkedHashedBeaconState)(mergeData: merge.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), kind: BeaconStateFork.Merge)
cache = StateCache()
info = ForkedEpochInfo()
@ -61,7 +61,7 @@ proc runTest(testName, testDir, unitTestName: string) =
if hasPostState:
let postState = newClone(parseTest(testPath/"post.ssz_snappy", SSZ, merge.BeaconState))
when false:
reportDiff(fhPreState.hbsMerge.data, postState)
reportDiff(fhPreState.mergeData.data, postState)
doAssert getStateRoot(fhPreState[]) == postState[].hash_tree_root()
`testImpl _ blck _ testName`()

6
tests/consensus_spec/merge/test_fixture_sanity_slots.nim
View File

@ -31,9 +31,9 @@ proc runTest(identifier: string) =
var
preState = newClone(parseTest(testDir/"pre.ssz_snappy", SSZ, merge.BeaconState))
fhPreState = (ref ForkedHashedBeaconState)(
hbsMerge: merge.HashedBeaconState(
mergeData: merge.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])),
beaconStateFork: forkMerge)
kind: BeaconStateFork.Merge)
cache = StateCache()
info = ForkedEpochInfo()
let postState = newClone(parseTest(testDir/"post.ssz_snappy", SSZ, merge.BeaconState))
@ -44,7 +44,7 @@ proc runTest(identifier: string) =
getStateField(fhPreState[], slot) + num_slots, cache, info, {})
getStateRoot(fhPreState[]) == postState[].hash_tree_root()
let newPreState = newClone(fhPreState.hbsMerge.data)
let newPreState = newClone(fhPreState.mergeData.data)
reportDiff(newPreState, postState)
`testImpl _ slots _ identifier`()

6
tests/consensus_spec/phase0/test_fixture_sanity_blocks.nim
View File

@ -33,8 +33,8 @@ proc runTest(testName, testDir, unitTestName: string) =
test prefix & testName & " - " & unitTestName & preset():
var
preState = newClone(parseTest(testPath/"pre.ssz_snappy", SSZ, phase0.BeaconState))
fhPreState = (ref ForkedHashedBeaconState)(hbsPhase0: phase0.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), beaconStateFork: forkPhase0)
fhPreState = (ref ForkedHashedBeaconState)(phase0Data: phase0.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), kind: BeaconStateFork.Phase0)
cache = StateCache()
info = ForkedEpochInfo()
@ -59,7 +59,7 @@ proc runTest(testName, testDir, unitTestName: string) =
if hasPostState:
let postState = newClone(parseTest(testPath/"post.ssz_snappy", SSZ, phase0.BeaconState))
when false:
reportDiff(hashedPreState.hbsPhase0.data, postState)
reportDiff(hashedPreState.phase0Data.data, postState)
doAssert getStateRoot(fhPreState[]) == postState[].hash_tree_root()
`testImpl _ blck _ testName`()

6
tests/consensus_spec/phase0/test_fixture_sanity_slots.nim
View File

@ -29,8 +29,8 @@ proc runTest(identifier: string) =
test "Slots - " & identifier:
var
preState = newClone(parseTest(testDir/"pre.ssz_snappy", SSZ, phase0.BeaconState))
fhPreState = (ref ForkedHashedBeaconState)(hbsPhase0: phase0.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), beaconStateFork: forkPhase0)
fhPreState = (ref ForkedHashedBeaconState)(phase0Data: phase0.HashedBeaconState(
data: preState[], root: hash_tree_root(preState[])), kind: BeaconStateFork.Phase0)
cache = StateCache()
info: ForkedEpochInfo
let postState = newClone(parseTest(testDir/"post.ssz_snappy", SSZ, phase0.BeaconState))
@ -42,7 +42,7 @@ proc runTest(identifier: string) =
info, {})
getStateRoot(fhPreState[]) == postState[].hash_tree_root()
let newPreState = newClone(fhPreState.hbsPhase0.data)
let newPreState = newClone(fhPreState.phase0Data.data)
reportDiff(newPreState, postState)
`testImpl _ slots _ identifier`()

6
tests/mocking/mock_attestations.nim
View File

@ -27,9 +27,9 @@ proc mockAttestationData(
doAssert state.slot >= slot
if slot == state.slot:
let forkedState = (ref ForkedHashedBeaconState)(beaconStateFork: forkPhase0,
hbsPhase0: phase0.HashedBeaconState(root: hash_tree_root(state), data: state))[]
result.beacon_block_root = mockBlockForNextSlot(forkedState).phase0Block.message.parent_root
let forkedState = (ref ForkedHashedBeaconState)(kind: BeaconStateFork.Phase0,
phase0Data: phase0.HashedBeaconState(root: hash_tree_root(state), data: state))[]
result.beacon_block_root = mockBlockForNextSlot(forkedState).phase0Data.message.parent_root
else:
result.beacon_block_root = get_block_root_at_slot(state, slot)

12
tests/mocking/mock_blocks.nim
View File

@ -91,10 +91,10 @@ proc mockBlock*(
var info = ForkedEpochInfo()
doAssert process_slots(cfg, tmpState[], slot, cache, info, flags = {})
result.kind = case tmpState[].beaconStateFork
of forkPhase0: BeaconBlockFork.Phase0
of forkAltair: BeaconBlockFork.Altair
of forkMerge: BeaconBlockFork.Merge
result.kind = case tmpState[].kind
of BeaconStateFork.Phase0: BeaconBlockFork.Phase0
of BeaconStateFork.Altair: BeaconBlockFork.Altair
of BeaconStateFork.Merge: BeaconBlockFork.Merge
withStateAndBlck(tmpState[], result):
blck.message.slot = slot
blck.message.proposer_index =
@ -108,10 +108,10 @@ proc mockBlock*(
apply_randao_reveal(state.data, blck)
when stateFork >= forkAltair:
when stateFork >= BeaconStateFork.Altair:
blck.message.body.sync_aggregate = SyncAggregate.init()
when stateFork >= forkMerge:
when stateFork >= BeaconStateFork.Merge:
blck.message.body.execution_payload =
build_empty_execution_payload(state.data)

4
tests/mocking/mock_genesis.nim
View File

@ -26,8 +26,8 @@ proc initGenesisState*(
)
result = (ref ForkedHashedBeaconState)(
beaconStateFork: forkPhase0,
hbsPhase0: initialize_hashed_beacon_state_from_eth1(
kind: BeaconStateFork.Phase0,
phase0Data: initialize_hashed_beacon_state_from_eth1(
cfg, eth1BlockHash, 0, deposits, {}))
maybeUpgradeState(cfg, result[])

14
tests/spec_block_processing/test_process_attestation.nim
View File

@ -44,32 +44,32 @@ suite "[Unit - Spec - Block processing] Attestations " & preset():
# ----------------------------------------
let
current_epoch_count =
state.hbsPhase0.data.current_epoch_attestations.len
state.phase0Data.data.current_epoch_attestations.len
previous_epoch_count =
state.hbsPhase0.data.previous_epoch_attestations.len
state.phase0Data.data.previous_epoch_attestations.len
# State transition
# ----------------------------------------
var cache = StateCache()
check process_attestation(
state.hbsPhase0.data, attestation, flags = {}, 0.Gwei, cache
state.phase0Data.data, attestation, flags = {}, 0.Gwei, cache
).isOk
# Check that the attestation was processed
if attestation.data.target.epoch == get_current_epoch(state[]):
check(state.hbsPhase0.data.current_epoch_attestations.len ==
check(state.phase0Data.data.current_epoch_attestations.len ==
current_epoch_count + 1)
else:
check(state.hbsPhase0.data.previous_epoch_attestations.len ==
check(state.phase0Data.data.previous_epoch_attestations.len ==
previous_epoch_count + 1)
valid_attestation("Valid attestation"):
let attestation = mockAttestation(state.hbsPhase0.data)
let attestation = mockAttestation(state.phase0Data.data)
getStateField(state[], slot) += MIN_ATTESTATION_INCLUSION_DELAY
valid_attestation("Valid attestation from previous epoch"):
nextSlot(state[])
let attestation = mockAttestation(state.hbsPhase0.data)
let attestation = mockAttestation(state.phase0Data.data)
getStateField(state[], slot) = Slot(SLOTS_PER_EPOCH - 1)
nextEpoch(state[])

2
tests/spec_block_processing/test_process_deposits.nim
View File

@ -26,7 +26,7 @@ import
suite "[Unit - Spec - Block processing] Deposits " & preset():
const NumValidators = uint64 5 * SLOTS_PER_EPOCH
let genesisState = newClone(initGenesisState(NumValidators).hbsPhase0)
let genesisState = newClone(initGenesisState(NumValidators).phase0Data)
doAssert genesisState.data.validators.lenu64 == NumValidators
template valid_deposit(deposit_amount: uint64, name: string): untyped =

8
tests/spec_epoch_processing/epoch_utils.nim
View File

@ -26,7 +26,7 @@ proc processSlotsUntilEndCurrentEpoch(state: var ForkedHashedBeaconState) =
# For the last slot of the epoch,
# only process_slot without process_epoch
# (see process_slots()) - state.root is invalid after here!
process_slot(state.hbsPhase0.data, getStateRoot(state))
process_slot(state.phase0Data.data, getStateRoot(state))
proc transitionEpochUntilJustificationFinalization*(state: var ForkedHashedBeaconState) =
# Process slots and do the epoch transition until crosslinks
@ -36,7 +36,7 @@ proc transitionEpochUntilJustificationFinalization*(state: var ForkedHashedBeaco
cache = StateCache()
info: phase0.EpochInfo
info.init(state.hbsPhase0.data)
info.process_attestations(state.hbsPhase0.data, cache)
info.init(state.phase0Data.data)
info.process_attestations(state.phase0Data.data, cache)
process_justification_and_finalization(
state.hbsPhase0.data, info.total_balances)
state.phase0Data.data, info.total_balances)

18
tests/spec_epoch_processing/test_process_justification_and_finalization.nim
View File

@ -36,7 +36,7 @@ proc finalizeOn234(
# checkpoints for epochs ago
let (c1, c2, c3, c4, _) = getCheckpoints(epoch)
putCheckpointsInBlockRoots(state.hbsPhase0.data, [c1, c2, c3, c4])
putCheckpointsInBlockRoots(state.phase0Data.data, [c1, c2, c3, c4])
# Save for final checks
let old_finalized = getStateField(state, finalized_checkpoint)
@ -51,7 +51,7 @@ proc finalizeOn234(
getStateField(state, justification_bits).setBit 2
# mock the 2nd latest epoch as justifiable, with 4th as the source
addMockAttestations(
state.hbsPhase0.data,
state.phase0Data.data,
epoch = epoch - 2,
source = c4,
target = c2,
@ -82,7 +82,7 @@ proc finalizeOn23(state: var ForkedHashedBeaconState, epoch: Epoch, sufficient_s
# checkpoints for epochs ago
let (c1, c2, c3, _, _) = getCheckpoints(epoch)
putCheckpointsInBlockRoots(state.hbsPhase0.data, [c1, c2, c3])
putCheckpointsInBlockRoots(state.phase0Data.data, [c1, c2, c3])
# Save for final checks
let old_finalized = getStateField(state, finalized_checkpoint)
@ -96,7 +96,7 @@ proc finalizeOn23(state: var ForkedHashedBeaconState, epoch: Epoch, sufficient_s
getStateField(state, justification_bits).setBit 1
# mock the 2nd latest epoch as justifiable, with 3rd as the source
addMockAttestations(
state.hbsPhase0.data,
state.phase0Data.data,
epoch = epoch - 2,
source = c3,
target = c2,
@ -127,7 +127,7 @@ proc finalizeOn123(state: var ForkedHashedBeaconState, epoch: Epoch, sufficient_
# checkpoints for epochs ago
let (c1, c2, c3, c4, c5) = getCheckpoints(epoch)
putCheckpointsInBlockRoots(state.hbsPhase0.data, [c1, c2, c3, c4, c5])
putCheckpointsInBlockRoots(state.phase0Data.data, [c1, c2, c3, c4, c5])
# Save for final checks
let old_finalized = getStateField(state, finalized_checkpoint)
@ -141,7 +141,7 @@ proc finalizeOn123(state: var ForkedHashedBeaconState, epoch: Epoch, sufficient_
getStateField(state, justification_bits).setBit 1
# mock the 2nd latest epoch as justifiable, with 5th as the source
addMockAttestations(
state.hbsPhase0.data,
state.phase0Data.data,
epoch = epoch - 2,
source = c5,
target = c2,
@ -149,7 +149,7 @@ proc finalizeOn123(state: var ForkedHashedBeaconState, epoch: Epoch, sufficient_
)
# mock the 1st latest epoch as justifiable with 3rd as source
addMockAttestations(
state.hbsPhase0.data,
state.phase0Data.data,
epoch = epoch - 1,
source = c3,
target = c1,
@ -180,7 +180,7 @@ proc finalizeOn12(state: var ForkedHashedBeaconState, epoch: Epoch, sufficient_s
# checkpoints for epochs ago
let (c1, c2, _, _, _) = getCheckpoints(epoch)
putCheckpointsInBlockRoots(state.hbsPhase0.data, [c1, c2])
putCheckpointsInBlockRoots(state.phase0Data.data, [c1, c2])
# Save for final checks
let old_finalized = getStateField(state, finalized_checkpoint)
@ -194,7 +194,7 @@ proc finalizeOn12(state: var ForkedHashedBeaconState, epoch: Epoch, sufficient_s
getStateField(state, justification_bits).setBit 0
# mock the 2nd latest epoch as justifiable, with 3rd as the source
addMockAttestations(
state.hbsPhase0.data,
state.phase0Data.data,
epoch = epoch - 1,
source = c2,
target = c1,

16
tests/test_attestation_pool.nim
View File

@ -113,7 +113,7 @@ suite "Attestation pool processing" & preset():
let
root1 = addTestBlock(
state.data, state.blck.root,
cache, attestations = attestations, nextSlot = false).phase0Block.root
cache, attestations = attestations, nextSlot = false).phase0Data.root
bc1 = get_beacon_committee(
state[].data, getStateField(state.data, slot), 0.CommitteeIndex, cache)
att1 = makeAttestation(state[].data, root1, bc1[0], cache)
@ -377,7 +377,7 @@ suite "Attestation pool processing" & preset():
test "Fork choice returns latest block with no attestations":
var cache = StateCache()
let
b1 = addTestBlock(state.data, dag.tail.root, cache).phase0Block
b1 = addTestBlock(state.data, dag.tail.root, cache).phase0Data
b1Add = dag.addRawBlock(quarantine, b1) do (
blckRef: BlockRef, signedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
@ -390,7 +390,7 @@ suite "Attestation pool processing" & preset():
head == b1Add[]
let
b2 = addTestBlock(state.data, b1.root, cache).phase0Block
b2 = addTestBlock(state.data, b1.root, cache).phase0Data
b2Add = dag.addRawBlock(quarantine, b2) do (
blckRef: BlockRef, signedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
@ -405,7 +405,7 @@ suite "Attestation pool processing" & preset():
test "Fork choice returns block with attestation":
var cache = StateCache()
let
b10 = makeTestBlock(state.data, dag.tail.root, cache).phase0Block
b10 = makeTestBlock(state.data, dag.tail.root, cache).phase0Data
b10Add = dag.addRawBlock(quarantine, b10) do (
blckRef: BlockRef, signedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
@ -420,7 +420,7 @@ suite "Attestation pool processing" & preset():
let
b11 = makeTestBlock(state.data, dag.tail.root, cache,
graffiti = GraffitiBytes [1'u8, 0, 0, 0 ,0 ,0 ,0 ,0 ,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
).phase0Block
).phase0Data
b11Add = dag.addRawBlock(quarantine, b11) do (
blckRef: BlockRef, signedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
@ -466,7 +466,7 @@ suite "Attestation pool processing" & preset():
test "Trying to add a block twice tags the second as an error":
var cache = StateCache()
let
b10 = makeTestBlock(state.data, dag.tail.root, cache).phase0Block
b10 = makeTestBlock(state.data, dag.tail.root, cache).phase0Data
b10Add = dag.addRawBlock(quarantine, b10) do (
blckRef: BlockRef, signedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
@ -495,7 +495,7 @@ suite "Attestation pool processing" & preset():
dag.updateFlags.incl {skipBLSValidation}
var cache = StateCache()
let
b10 = addTestBlock(state.data, dag.tail.root, cache).phase0Block
b10 = addTestBlock(state.data, dag.tail.root, cache).phase0Data
b10Add = dag.addRawBlock(quarantine, b10) do (
blckRef: BlockRef, signedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
@ -521,7 +521,7 @@ suite "Attestation pool processing" & preset():
get_committee_count_per_slot(state[].data, Epoch epoch, cache)
for slot in start_slot ..< start_slot + SLOTS_PER_EPOCH:
let new_block = addTestBlock(
state.data, block_root, cache, attestations = attestations).phase0Block
state.data, block_root, cache, attestations = attestations).phase0Data
block_root = new_block.root
let blockRef = dag.addRawBlock(quarantine, new_block) do (

52
tests/test_beacon_chain_db.nim
View File

@ -78,9 +78,9 @@ proc getTestStates(stateFork: BeaconStateFork): auto =
# Each of phase 0/altair/merge states gets used twice, so make them global to
# module
let
testStatesPhase0 = getTestStates(forkPhase0)
testStatesAltair = getTestStates(forkAltair)
testStatesMerge = getTestStates(forkMerge)
testStatesPhase0 = getTestStates(BeaconStateFork.Phase0)
testStatesAltair = getTestStates(BeaconStateFork.Altair)
testStatesMerge = getTestStates(BeaconStateFork.Merge)
suite "Beacon chain DB" & preset():
test "empty database" & preset():
@ -199,7 +199,7 @@ suite "Beacon chain DB" & preset():
var db = makeTestDB(SLOTS_PER_EPOCH)
for state in testStatesPhase0:
db.putState(state[].hbsPhase0.data)
db.putState(state[].phase0Data.data)
let root = hash_tree_root(state[])
check:
@ -217,7 +217,7 @@ suite "Beacon chain DB" & preset():
var db = makeTestDB(SLOTS_PER_EPOCH)
for state in testStatesAltair:
db.putState(state[].hbsAltair.data)
db.putState(state[].altairData.data)
let root = hash_tree_root(state[])
check:
@ -235,7 +235,7 @@ suite "Beacon chain DB" & preset():
var db = makeTestDB(SLOTS_PER_EPOCH)
for state in testStatesMerge:
db.putState(state[].hbsMerge.data)
db.putState(state[].mergeData.data)
let root = hash_tree_root(state[])
check:
@ -254,7 +254,7 @@ suite "Beacon chain DB" & preset():
let stateBuffer = (phase0.BeaconStateRef)()
for state in testStatesPhase0:
db.putState(state[].hbsPhase0.data)
db.putState(state[].phase0Data.data)
let root = hash_tree_root(state[])
check:
@ -274,7 +274,7 @@ suite "Beacon chain DB" & preset():
let stateBuffer = (altair.BeaconStateRef)()
for state in testStatesAltair:
db.putState(state[].hbsAltair.data)
db.putState(state[].altairData.data)
let root = hash_tree_root(state[])
check:
@ -294,7 +294,7 @@ suite "Beacon chain DB" & preset():
let stateBuffer = (merge.BeaconStateRef)()
for state in testStatesMerge:
db.putState(state[].hbsMerge.data)
db.putState(state[].mergeData.data)
let root = hash_tree_root(state[])
check:
@ -314,8 +314,8 @@ suite "Beacon chain DB" & preset():
db = makeTestDB(SLOTS_PER_EPOCH)
dag = init(ChainDAGRef, defaultRuntimeConfig, db, {})
state = (ref ForkedHashedBeaconState)(
beaconStateFork: forkPhase0,
hbsPhase0: phase0.HashedBeaconState(data: phase0.BeaconState(
kind: BeaconStateFork.Phase0,
phase0Data: phase0.HashedBeaconState(data: phase0.BeaconState(
slot: 10.Slot)))
root = Eth2Digest()
@ -327,17 +327,17 @@ suite "Beacon chain DB" & preset():
assign(state[], restoreAddr[].data)
check:
state[].hbsPhase0.data.slot == 10.Slot
not db.getState(root, state[].hbsPhase0.data, restore)
state[].hbsPhase0.data.slot != 10.Slot
state[].phase0Data.data.slot == 10.Slot
not db.getState(root, state[].phase0Data.data, restore)
state[].phase0Data.data.slot != 10.Slot
test "sanity check Altair and cross-fork getState rollback" & preset():
var
db = makeTestDB(SLOTS_PER_EPOCH)
dag = init(ChainDAGRef, defaultRuntimeConfig, db, {})
state = (ref ForkedHashedBeaconState)(
beaconStateFork: forkAltair,
hbsAltair: altair.HashedBeaconState(data: altair.BeaconState(
kind: BeaconStateFork.Altair,
altairData: altair.HashedBeaconState(data: altair.BeaconState(
slot: 10.Slot)))
root = Eth2Digest()
@ -349,20 +349,20 @@ suite "Beacon chain DB" & preset():
assign(state[], restoreAddr[].data)
check:
state[].hbsAltair.data.slot == 10.Slot
not db.getAltairState(root, state[].hbsAltair.data, restore)
state[].altairData.data.slot == 10.Slot
not db.getAltairState(root, state[].altairData.data, restore)
# assign() has switched the case object fork
state[].beaconStateFork == forkPhase0
state[].hbsPhase0.data.slot != 10.Slot
state[].kind == BeaconStateFork.Phase0
state[].phase0Data.data.slot != 10.Slot
test "sanity check Merge and cross-fork getState rollback" & preset():
var
db = makeTestDB(SLOTS_PER_EPOCH)
dag = init(ChainDAGRef, defaultRuntimeConfig, db, {})
state = (ref ForkedHashedBeaconState)(
beaconStateFork: forkMerge,
hbsMerge: merge.HashedBeaconState(data: merge.BeaconState(
kind: BeaconStateFork.Merge,
mergeData: merge.HashedBeaconState(data: merge.BeaconState(
slot: 10.Slot)))
root = Eth2Digest()
@ -374,12 +374,12 @@ suite "Beacon chain DB" & preset():
assign(state[], restoreAddr[].data)
check:
state[].hbsMerge.data.slot == 10.Slot
not db.getMergeState(root, state[].hbsMerge.data, restore)
state[].mergeData.data.slot == 10.Slot
not db.getMergeState(root, state[].mergeData.data, restore)
# assign() has switched the case object fork
state[].beaconStateFork == forkPhase0
state[].hbsPhase0.data.slot != 10.Slot
state[].kind == BeaconStateFork.Phase0
state[].phase0Data.data.slot != 10.Slot
test "find ancestors" & preset():
var

32
tests/test_block_pool.nim
View File

@ -127,8 +127,8 @@ suite "Block pool processing" & preset():
cache = StateCache()
info = ForkedEpochInfo()
att0 = makeFullAttestations(state[], dag.tail.root, 0.Slot, cache)
b1 = addTestBlock(state[], dag.tail.root, cache, attestations = att0).phase0Block
b2 = addTestBlock(state[], b1.root, cache).phase0Block
b1 = addTestBlock(state[], dag.tail.root, cache, attestations = att0).phase0Data
b2 = addTestBlock(state[], b1.root, cache).phase0Data
test "getRef returns nil for missing blocks":
check:
dag.getRef(default Eth2Digest) == nil
@ -181,7 +181,7 @@ suite "Block pool processing" & preset():
info, {})
let
b4 = addTestBlock(state[], b2.root, cache).phase0Block
b4 = addTestBlock(state[], b2.root, cache).phase0Data
b4Add = dag.addRawBlock(quarantine, b4, nilPhase0Callback)
check:
@ -357,7 +357,7 @@ suite "chain DAG finalization tests" & preset():
test "prune heads on finalization" & preset():
# Create a fork that will not be taken
var
blck = makeTestBlock(dag.headState.data, dag.head.root, cache).phase0Block
blck = makeTestBlock(dag.headState.data, dag.head.root, cache).phase0Data
tmpState = assignClone(dag.headState.data)
check:
process_slots(
@ -365,7 +365,7 @@ suite "chain DAG finalization tests" & preset():
getStateField(tmpState[], slot) + (5 * SLOTS_PER_EPOCH).uint64,
cache, info, {})
let lateBlock = addTestBlock(tmpState[], dag.head.root, cache).phase0Block
let lateBlock = addTestBlock(tmpState[], dag.head.root, cache).phase0Data
block:
let status = dag.addRawBlock(quarantine, blck, nilPhase0Callback)
check: status.isOk()
@ -381,7 +381,7 @@ suite "chain DAG finalization tests" & preset():
blck = addTestBlock(
tmpState[], dag.head.root, cache,
attestations = makeFullAttestations(
tmpState[], dag.head.root, getStateField(tmpState[], slot), cache, {})).phase0Block
tmpState[], dag.head.root, getStateField(tmpState[], slot), cache, {})).phase0Data
let added = dag.addRawBlock(quarantine, blck, nilPhase0Callback)
check: added.isOk()
dag.updateHead(added[], quarantine)
@ -447,12 +447,12 @@ suite "chain DAG finalization tests" & preset():
hash_tree_root(dag2.headState.data) == hash_tree_root(dag.headState.data)
test "orphaned epoch block" & preset():
var prestate = (ref ForkedHashedBeaconState)(beaconStateFork: forkPhase0)
var prestate = (ref ForkedHashedBeaconState)(kind: BeaconStateFork.Phase0)
for i in 0 ..< SLOTS_PER_EPOCH:
if i == SLOTS_PER_EPOCH - 1:
assign(prestate[], dag.headState.data)
let blck = makeTestBlock(dag.headState.data, dag.head.root, cache).phase0Block
let blck = makeTestBlock(dag.headState.data, dag.head.root, cache).phase0Data
let added = dag.addRawBlock(quarantine, blck, nilPhase0Callback)
check: added.isOk()
dag.updateHead(added[], quarantine)
@ -469,7 +469,7 @@ suite "chain DAG finalization tests" & preset():
cache, info, {})
# create another block, orphaning the head
let blck = makeTestBlock(prestate[], dag.head.parent.root, cache).phase0Block
let blck = makeTestBlock(prestate[], dag.head.parent.root, cache).phase0Data
# Add block, but don't update head
let added = dag.addRawBlock(quarantine, blck, nilPhase0Callback)
@ -486,7 +486,7 @@ suite "chain DAG finalization tests" & preset():
for blck in makeTestBlocks(
dag.headState.data, dag.head.root, cache, int(SLOTS_PER_EPOCH * 6 - 2),
true):
let added = dag.addRawBlock(quarantine, blck.phase0Block, nilPhase0Callback)
let added = dag.addRawBlock(quarantine, blck.phase0Data, nilPhase0Callback)
check: added.isOk()
dag.updateHead(added[], quarantine)
dag.pruneAtFinalization()
@ -501,7 +501,7 @@ suite "chain DAG finalization tests" & preset():
dag.headState.data, dag.head.root, cache,
attestations = makeFullAttestations(
dag.headState.data, dag.head.root, getStateField(dag.headState.data, slot),
cache, {})).phase0Block
cache, {})).phase0Data
let added = dag.addRawBlock(quarantine, blck, nilPhase0Callback)
check: added.isOk()
@ -517,7 +517,7 @@ suite "chain DAG finalization tests" & preset():
assign(tmpStateData[], dag.headState)
dag.updateStateData(tmpStateData[], cur.atSlot(cur.slot), false, cache)
check:
dag.get(cur).data.phase0Block.message.state_root == getStateRoot(tmpStateData[].data)
dag.get(cur).data.phase0Data.message.state_root == getStateRoot(tmpStateData[].data)
getStateRoot(tmpStateData[].data) == hash_tree_root(tmpStateData[].data)
cur = cur.parent
@ -563,7 +563,7 @@ suite "Old database versions" & preset():
state = newClone(dag.headState.data)
cache = StateCache()
att0 = makeFullAttestations(state[], dag.tail.root, 0.Slot, cache)
b1 = addTestBlock(state[], dag.tail.root, cache, attestations = att0).phase0Block
b1 = addTestBlock(state[], dag.tail.root, cache, attestations = att0).phase0Data
b1Add = dag.addRawBlock(quarantine, b1, nilPhase0Callback)
check:
@ -600,7 +600,7 @@ suite "Diverging hardforks":
# Because the first block is after the Altair transition, the only block in
# common is the tail block
var
b1 = addTestBlock(tmpState[], dag.tail.root, cache).phase0Block
b1 = addTestBlock(tmpState[], dag.tail.root, cache).phase0Data
b1Add = dag.addRawBlock(quarantine, b1, nilPhase0Callback)
check b1Add.isOk()
@ -618,7 +618,7 @@ suite "Diverging hardforks":
# There's a block in the shared-correct phase0 hardfork, before epoch 2
var
b1 = addTestBlock(tmpState[], dag.tail.root, cache).phase0Block
b1 = addTestBlock(tmpState[], dag.tail.root, cache).phase0Data
b1Add = dag.addRawBlock(quarantine, b1, nilPhase0Callback)
check:
@ -629,7 +629,7 @@ suite "Diverging hardforks":
cache, info, {})
var
b2 = addTestBlock(tmpState[], b1.root, cache).phase0Block
b2 = addTestBlock(tmpState[], b1.root, cache).phase0Data
b2Add = dag.addRawBlock(quarantine, b2, nilPhase0Callback)
check b2Add.isOk()

37
tests/test_exit_pool.nim
View File

@ -9,27 +9,28 @@
import chronicles, chronos
import eth/keys
import ../beacon_chain/spec/[datatypes/base, presets]
import ../beacon_chain/spec/[datatypes/base, forks, presets]
import ../beacon_chain/consensus_object_pools/[block_quarantine, blockchain_dag, exit_pool]
import "."/[testutil, testdbutil]
proc getExitPool(): auto =
let dag =
init(ChainDAGRef, defaultRuntimeConfig, makeTestDB(SLOTS_PER_EPOCH * 3), {})
newClone(ExitPool.init(dag))
suite "Exit pool testing suite":
setup:
let pool = getExitPool()
let
dag = init(
ChainDAGRef, defaultRuntimeConfig, makeTestDB(SLOTS_PER_EPOCH * 3), {})
pool = newClone(ExitPool.init(dag))
test "addExitMessage/getProposerSlashingMessage":
for i in 0'u64 .. MAX_PROPOSER_SLASHINGS + 5:
for j in 0'u64 .. i:
pool.proposer_slashings.addExitMessage(
ProposerSlashing(), MAX_PROPOSER_SLASHINGS)
ProposerSlashing(signed_header_1: SignedBeaconBlockHeader(
message: BeaconBlockHeader(proposer_index: j))), MAX_PROPOSER_SLASHINGS)
withState(dag.headState.data):
check:
pool[].getProposerSlashingsForBlock().lenu64 ==
pool[].getBeaconBlockExits(state.data).proposer_slashings.lenu64 ==
min(i + 1, MAX_PROPOSER_SLASHINGS)
pool[].getProposerSlashingsForBlock().len == 0
pool[].getBeaconBlockExits(state.data).proposer_slashings.len == 0
test "addExitMessage/getAttesterSlashingMessage":
for i in 0'u64 .. MAX_ATTESTER_SLASHINGS + 5:
@ -37,21 +38,23 @@ suite "Exit pool testing suite":
pool.attester_slashings.addExitMessage(
AttesterSlashing(
attestation_1: IndexedAttestation(attesting_indices:
List[uint64, Limit MAX_VALIDATORS_PER_COMMITTEE](@[0'u64])),
List[uint64, Limit MAX_VALIDATORS_PER_COMMITTEE](@[j])),
attestation_2: IndexedAttestation(attesting_indices:
List[uint64, Limit MAX_VALIDATORS_PER_COMMITTEE](@[0'u64]))),
List[uint64, Limit MAX_VALIDATORS_PER_COMMITTEE](@[j]))),
MAX_ATTESTER_SLASHINGS)
withState(dag.headState.data):
check:
pool[].getAttesterSlashingsForBlock().lenu64 ==
pool[].getBeaconBlockExits(state.data).attester_slashings.lenu64 ==
min(i + 1, MAX_ATTESTER_SLASHINGS)
pool[].getAttesterSlashingsForBlock().len == 0
pool[].getBeaconBlockExits(state.data).attester_slashings.len == 0
test "addExitMessage/getVoluntaryExitMessage":
for i in 0'u64 .. MAX_VOLUNTARY_EXITS + 5:
for j in 0'u64 .. i:
pool.voluntary_exits.addExitMessage(
SignedVoluntaryExit(), MAX_VOLUNTARY_EXITS)
SignedVoluntaryExit(message: VoluntaryExit(validator_index: j)), MAX_VOLUNTARY_EXITS)
withState(dag.headState.data):
check:
pool[].getVoluntaryExitsForBlock().lenu64 ==
pool[].getBeaconBlockExits(state.data).voluntary_exits.lenu64 ==
min(i + 1, MAX_VOLUNTARY_EXITS)
pool[].getProposerSlashingsForBlock().len == 0
pool[].getBeaconBlockExits(state.data).voluntary_exits.len == 0

10
tests/test_gossip_validation.nim
View File

@ -78,7 +78,7 @@ suite "Gossip validation " & preset():
for blck in makeTestBlocks(
dag.headState.data, dag.head.root, cache,
int(SLOTS_PER_EPOCH * 5), false):
let added = dag.addRawBlock(quarantine, blck.phase0Block) do (
let added = dag.addRawBlock(quarantine, blck.phase0Data) do (
blckRef: BlockRef, signedBlock: phase0.TrustedSignedBeaconBlock,
epochRef: EpochRef):
# Callback add to fork choice if valid
@ -196,17 +196,17 @@ suite "Gossip validation - Extra": # Not based on preset config
case blck.kind
of BeaconBlockFork.Phase0:
const nilCallback = OnPhase0BlockAdded(nil)
dag.addRawBlock(quarantine, blck.phase0Block, nilCallback)
dag.addRawBlock(quarantine, blck.phase0Data, nilCallback)
of BeaconBlockFork.Altair:
const nilCallback = OnAltairBlockAdded(nil)
dag.addRawBlock(quarantine, blck.altairBlock, nilCallback)
dag.addRawBlock(quarantine, blck.altairData, nilCallback)
of BeaconBlockFork.Merge:
const nilCallback = OnMergeBlockAdded(nil)
dag.addRawBlock(quarantine, blck.mergeBlock, nilCallback)
dag.addRawBlock(quarantine, blck.mergeData, nilCallback)
check: added.isOk()
dag.updateHead(added[], quarantine)
dag
state = newClone(dag.headState.data.hbsAltair)
state = newClone(dag.headState.data.altairData)
syncCommitteeIdx = 0.SyncCommitteeIndex
syncCommittee = @(dag.syncCommitteeParticipants(state[].data.slot))

2
tests/test_helpers.nim
View File

@ -36,7 +36,7 @@ suite "Spec helpers":
Slot(100), cache, info, flags = {})
let
state = forked[].hbsPhase0.data
state = forked[].phase0Data.data
root = state.hash_tree_root()
func numLeaves(obj: object): GeneralizedIndex =

6
tests/test_statediff.nim
View File

@ -26,7 +26,7 @@ suite "state diff tests" & preset():
dag = init(ChainDAGRef, defaultRuntimeConfig, db, {})
test "random slot differences" & preset():
let testStates = getTestStates(dag.headState.data, forkPhase0)
let testStates = getTestStates(dag.headState.data, BeaconStateFork.Phase0)
for i in 0 ..< testStates.len:
for j in (i+1) ..< testStates.len:
@ -34,9 +34,9 @@ suite "state diff tests" & preset():
getStateField(testStates[j][], slot)
if getStateField(testStates[i][], slot) + SLOTS_PER_EPOCH != getStateField(testStates[j][], slot):
continue
var tmpStateApplyBase = assignClone(testStates[i].hbsPhase0.data)
var tmpStateApplyBase = assignClone(testStates[i].phase0Data.data)
let diff = diffStates(
testStates[i].hbsPhase0.data, testStates[j].hbsPhase0.data)
testStates[i].phase0Data.data, testStates[j].phase0Data.data)
# Immutable parts of validators stored separately, so aren't part of
# the state diff. Synthesize required portion here for testing.
applyDiff(

2
tests/test_sync_manager.nim
View File

@ -34,7 +34,7 @@ suite "SyncManager test suite":
result = newSeq[ForkedSignedBeaconBlock](count)
var curslot = start
for item in result.mitems():
item.phase0Block.message.slot = curslot
item.phase0Data.message.slot = curslot
curslot = curslot + 1'u64
test "[SyncQueue] Start and finish slots equal":

4
tests/testblockutil.nim
View File

@ -116,9 +116,7 @@ proc addTestBlock*(
graffiti,
attestations,
deposits,
@[],
@[],
@[],
BeaconBlockExits(),
SyncAggregate.init(),
default(ExecutionPayload),
noRollback,

6
tests/teststateutil.nim
View File

@ -63,10 +63,10 @@ proc getTestStates*(
info = ForkedEpochInfo()
cfg = defaultRuntimeConfig
if stateFork in [forkAltair, forkMerge]:
if stateFork in [BeaconStateFork.Altair, BeaconStateFork.Merge]:
cfg.ALTAIR_FORK_EPOCH = 1.Epoch
if stateFork == forkMerge:
if stateFork == BeaconStateFork.Merge:
cfg.MERGE_FORK_EPOCH = 1.Epoch
for i, epoch in stateEpochs:
@ -80,5 +80,5 @@ proc getTestStates*(
valid_deposit(state.data)
doAssert getStateField(tmpState[], slot) == slot
if tmpState[].beaconStateFork == stateFork:
if tmpState[].kind == stateFork:
result.add assignClone(tmpState[])