nimbus-eth2/tests/consensus_spec/test_fixture_light_client_s...

271 lines
10 KiB
Nim
Raw Normal View History

# beacon_chain
# Copyright (c) 2022-2024 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
{.push raises: [].}
{.used.}
import
# Standard library
std/[json, streams],
# Status libraries
stew/byteutils,
# Third-party
yaml, yaml/tojson,
# Beacon chain internals
../../beacon_chain/spec/[forks, light_client_sync],
# Test utilities
../testutil,
./fixtures_utils, ./os_ops
type
TestMeta = object
genesis_validators_root: Eth2Digest
trusted_block_root: Eth2Digest
fork_digests: ForkDigests
bootstrap_fork_digest: ForkDigest
store_fork_digest: ForkDigest
TestChecks = object
finalized_slot: Slot
finalized_beacon_root: Eth2Digest
finalized_execution_root: Eth2Digest
optimistic_slot: Slot
optimistic_beacon_root: Eth2Digest
optimistic_execution_root: Eth2Digest
TestStepKind {.pure.} = enum
ForceUpdate
ProcessUpdate
UpgradeStore
TestStep = object
case kind: TestStepKind
of TestStepKind.ForceUpdate:
discard
of TestStepKind.ProcessUpdate:
update: ForkedLightClientUpdate
of TestStepKind.UpgradeStore:
store_data_fork: LightClientDataFork
current_slot: Slot
checks: TestChecks
proc loadSteps(
path: string,
fork_digests: ForkDigests
): seq[TestStep] {.raises: [
KeyError, ValueError, YamlConstructionError, YamlParserError].} =
let stepsYAML = os_ops.readFile(path/"steps.yaml")
let steps = loadToJson(stepsYAML)
result = @[]
for step in steps[0]:
func getChecks(c: JsonNode): TestChecks {.raises: [KeyError].} =
TestChecks(
finalized_slot:
c["finalized_header"]["slot"].getInt().Slot,
finalized_beacon_root:
Eth2Digest.fromHex(c["finalized_header"]["beacon_root"].getStr()),
finalized_execution_root:
Eth2Digest.fromHex(c["finalized_header"]{"execution_root"}.getStr()),
optimistic_slot:
c["optimistic_header"]["slot"].getInt().Slot,
optimistic_beacon_root:
Eth2Digest.fromHex(c["optimistic_header"]["beacon_root"].getStr()),
optimistic_execution_root:
Eth2Digest.fromHex(c["optimistic_header"]{"execution_root"}.getStr()))
if step.hasKey"force_update":
let s = step["force_update"]
result.add TestStep(
kind: TestStepKind.ForceUpdate,
current_slot: s["current_slot"].getInt().Slot,
checks: s["checks"].getChecks())
elif step.hasKey"process_update":
let
s = step["process_update"]
update_fork_digest =
distinctBase(ForkDigest).fromHex(s{"update_fork_digest"}.getStr(
distinctBase(fork_digests.altair).toHex())).ForkDigest
update_consensus_fork =
fork_digests.consensusForkForDigest(update_fork_digest)
.expect("Unknown update fork " & $update_fork_digest)
update_filename = s["update"].getStr()
var update {.noinit.}: ForkedLightClientUpdate
withLcDataFork(lcDataForkAtConsensusFork(update_consensus_fork)):
when lcDataFork > LightClientDataFork.None:
update = ForkedLightClientUpdate.init(parseTest(
path/update_filename & ".ssz_snappy", SSZ,
lcDataFork.LightClientUpdate))
else: raiseAssert "Unreachable update fork " & $update_fork_digest
result.add TestStep(
kind: TestStepKind.ProcessUpdate,
update: update,
current_slot: s["current_slot"].getInt().Slot,
checks: s["checks"].getChecks())
elif step.hasKey"upgrade_store":
let
s = step["upgrade_store"]
store_fork_digest =
distinctBase(ForkDigest).fromHex(
s["store_fork_digest"].getStr()).ForkDigest
store_consensus_fork =
fork_digests.consensusForkForDigest(store_fork_digest)
.expect("Unknown store fork " & $store_fork_digest)
result.add TestStep(
kind: TestStepKind.UpgradeStore,
store_data_fork: lcDataForkAtConsensusFork(store_consensus_fork),
checks: s["checks"].getChecks())
else:
doAssert false, "Unknown test step: " & $step
proc runTest(suiteName, path: string) =
let relativePathComponent = path.relativeTestPathComponent()
test "Light client - Sync - " & relativePathComponent:
# Reduce stack size by making this a `proc`
proc loadTestMeta(): (RuntimeConfig, TestMeta) {.raises: [
Exception, IOError, PresetFileError, PresetIncompatibleError].} =
let (cfg, _) = readRuntimeConfig(path/"config.yaml")
type TestMetaYaml {.sparse.} = object
genesis_validators_root: string
trusted_block_root: string
bootstrap_fork_digest: Option[string]
store_fork_digest: Option[string]
let
meta = block:
var s = openFileStream(path/"meta.yaml")
defer: close(s)
var res: TestMetaYaml
yaml.load(s, res)
res
genesis_validators_root =
Eth2Digest.fromHex(meta.genesis_validators_root)
trusted_block_root =
Eth2Digest.fromHex(meta.trusted_block_root)
fork_digests =
ForkDigests.init(cfg, genesis_validators_root)
bootstrap_fork_digest =
distinctBase(ForkDigest).fromHex(meta.bootstrap_fork_digest.get(
distinctBase(fork_digests.altair).toHex())).ForkDigest
store_fork_digest =
distinctBase(ForkDigest).fromHex(meta.store_fork_digest.get(
distinctBase(fork_digests.altair).toHex())).ForkDigest
(cfg, TestMeta(
genesis_validators_root: genesis_validators_root,
trusted_block_root: trusted_block_root,
fork_digests: fork_digests,
bootstrap_fork_digest: bootstrap_fork_digest,
store_fork_digest: store_fork_digest))
let
(cfg, meta) = loadTestMeta()
steps = loadSteps(path, meta.fork_digests)
# Reduce stack size by making this a `proc`
proc loadBootstrap(): ForkedLightClientBootstrap =
let bootstrap_consensus_fork =
meta.fork_digests.consensusForkForDigest(meta.bootstrap_fork_digest)
.expect("Unknown bootstrap fork " & $meta.bootstrap_fork_digest)
var bootstrap {.noinit.}: ForkedLightClientBootstrap
withLcDataFork(lcDataForkAtConsensusFork(bootstrap_consensus_fork)):
when lcDataFork > LightClientDataFork.None:
bootstrap = ForkedLightClientBootstrap.init(parseTest(
path/"bootstrap.ssz_snappy", SSZ,
lcDataFork.LightClientBootstrap))
else:
raiseAssert "Unknown bootstrap fork " & $meta.bootstrap_fork_digest
bootstrap
# Reduce stack size by making this a `proc`
proc initializeStore(
bootstrap: ref ForkedLightClientBootstrap): ForkedLightClientStore =
let store_consensus_fork =
meta.fork_digests.consensusForkForDigest(meta.store_fork_digest)
.expect("Unknown store fork " & $meta.store_fork_digest)
var store {.noinit.}: ForkedLightClientStore
withLcDataFork(lcDataForkAtConsensusFork(store_consensus_fork)):
when lcDataFork > LightClientDataFork.None:
bootstrap[].migrateToDataFork(lcDataFork)
store = ForkedLightClientStore.init(initialize_light_client_store(
meta.trusted_block_root, bootstrap[].forky(lcDataFork), cfg).get)
else: raiseAssert "Unreachable store fork " & $meta.store_fork_digest
store
let bootstrap = newClone(loadBootstrap())
var store = initializeStore(bootstrap)
# Reduce stack size by making this a `proc`
proc processStep(step: TestStep) =
withForkyStore(store):
when lcDataFork > LightClientDataFork.None:
case step.kind
of TestStepKind.ForceUpdate:
process_light_client_store_force_update(
forkyStore, step.current_slot)
of TestStepKind.ProcessUpdate:
check step.update.kind <= lcDataFork
let
upgradedUpdate = step.update.migratingToDataFork(lcDataFork)
res = process_light_client_update(
forkyStore, upgradedUpdate.forky(lcDataFork), step.current_slot,
cfg, meta.genesis_validators_root)
check res.isOk
of TestStepKind.UpgradeStore:
check step.store_data_fork >= lcDataFork
withLcDataFork(step.store_data_fork):
when lcDataFork > LightClientDataFork.None:
store.migrateToDataFork(lcDataFork)
else: raiseAssert "Unreachable"
withForkyStore(store):
when lcDataFork > LightClientDataFork.None:
let
finalized_slot =
forkyStore.finalized_header.beacon.slot
finalized_beacon_root =
hash_tree_root(forkyStore.finalized_header.beacon)
finalized_execution_root =
when lcDataFork >= LightClientDataFork.Capella:
get_lc_execution_root(forkyStore.finalized_header, cfg)
else:
ZERO_HASH
optimistic_slot =
forkyStore.optimistic_header.beacon.slot
optimistic_beacon_root =
hash_tree_root(forkyStore.optimistic_header.beacon)
optimistic_execution_root =
when lcDataFork >= LightClientDataFork.Capella:
get_lc_execution_root(forkyStore.optimistic_header, cfg)
else:
ZERO_HASH
check:
finalized_slot == step.checks.finalized_slot
finalized_beacon_root == step.checks.finalized_beacon_root
finalized_execution_root == step.checks.finalized_execution_root
optimistic_slot == step.checks.optimistic_slot
optimistic_beacon_root == step.checks.optimistic_beacon_root
optimistic_execution_root == step.checks.optimistic_execution_root
else: raiseAssert "Unreachable"
for step in steps:
processStep(step)
suite "EF - Light client - Sync" & preset():
const presetPath = SszTestsDir/const_preset
for kind, path in walkDir(presetPath, relative = true, checkDir = true):
let basePath =
presetPath/path/"light_client"/"sync"/"pyspec_tests"
if kind != pcDir or not dirExists(basePath):
continue
for kind, path in walkDir(basePath, relative = true, checkDir = true):
runTest(suiteName, basePath/path)