Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
79 commits
Select commit Hold shift + click to select a range
54be2b2
perf(crypto): sum validated public keys through blst's batched affine…
MegaRedHand Oct 29, 2026
5c787c6
perf(beacon): committee key sums, warmed off the import path
MegaRedHand Oct 30, 2026
bece6dd
perf(beacon): verify a block's signatures in one random-weight batch
MegaRedHand Oct 30, 2026
7736808
Merge part a into part b
MegaRedHand Oct 30, 2026
dda8568
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Oct 30, 2026
dd3c975
perf(beacon): verify attestations against committee key sums
MegaRedHand Oct 30, 2026
508c43e
feat(benchmark): add --warm-committee-sums to the import replay
MegaRedHand Oct 30, 2026
bac0aa3
test(crypto): cover keys that cancel in the batched sum
MegaRedHand Oct 30, 2026
8110d6b
Merge branch 'perf/bls-batched-key-sums' into perf/block-signature-batch
MegaRedHand Oct 30, 2026
e6eeb5b
fix(beacon): check the proposer's signature first and never drop a ba…
MegaRedHand Oct 30, 2026
3ea5790
Merge branch 'perf/block-signature-batch' into perf/committee-key-sums
MegaRedHand Oct 30, 2026
562b369
perf(beacon): keep cold committee sums at the plain path's cost and w…
MegaRedHand Oct 30, 2026
b650c74
Merge main into perf/bls-batched-key-sums
MegaRedHand Nov 4, 2026
4b648c7
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 4, 2026
4be6e9c
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 4, 2026
9984540
Merge main into perf/bls-batched-key-sums
MegaRedHand Nov 11, 2026
ee9aa61
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 11, 2026
9493f48
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 11, 2026
944e151
test(beacon): make the committee key-sum tests preset-agnostic
MegaRedHand Nov 11, 2026
f46b185
docs(crypto): say where fast_aggregate_verify's non-empty key list co…
MegaRedHand Nov 17, 2026
f42da82
test(crypto): fast_aggregate_verify rejects an empty key list
MegaRedHand Nov 17, 2026
d5eadc3
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 17, 2026
d9f9381
docs(crypto): spell out the compressed-point flag bits behind INFINIT…
MegaRedHand Nov 17, 2026
5c2d988
docs(beacon): say what a failing signature batch costs and why it sta…
MegaRedHand Nov 17, 2026
1bd8f80
docs(beacon): point process_block_with_signatures at the partial-stat…
MegaRedHand Nov 17, 2026
9344f78
test(beacon): explain how the operations wrapper keeps an unhandled c…
MegaRedHand Nov 17, 2026
93e146d
Merge main into perf/bls-batched-key-sums
MegaRedHand Nov 17, 2026
8a0a730
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 17, 2026
1a56d45
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 17, 2026
8637e3a
Merge main into perf/bls-batched-key-sums
MegaRedHand Nov 18, 2026
b7a8edb
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 18, 2026
3a95f1d
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 18, 2026
461cdde
Merge main into perf/bls-batched-key-sums
MegaRedHand Nov 18, 2026
0bd7072
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 18, 2026
f5e39ad
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 18, 2026
79a4c89
perf(crypto): take a single validated key as its own sum
MegaRedHand Nov 18, 2026
aa65405
fix(beacon): give SignatureBatch no public Default
MegaRedHand Nov 18, 2026
62c4cbc
docs(beacon): say at the check why payload attestation indices may re…
MegaRedHand Nov 18, 2026
b41192b
test(crypto): an invalid aggregate inside a batch fails it
MegaRedHand Nov 18, 2026
1057e4c
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 18, 2026
f8b9cd3
perf(crypto): sum validated public keys through blst's batched affine…
MegaRedHand Oct 29, 2026
b19da8f
test(crypto): cover keys that cancel in the batched sum
MegaRedHand Oct 30, 2026
5bb3dda
docs(crypto): say where fast_aggregate_verify's non-empty key list co…
MegaRedHand Nov 17, 2026
be26d6b
test(crypto): fast_aggregate_verify rejects an empty key list
MegaRedHand Nov 17, 2026
8bf0171
perf(crypto): take a single validated key as its own sum
MegaRedHand Nov 18, 2026
170aee8
fix(beacon): keep the unverified signature batch test-only and make a…
MegaRedHand Nov 18, 2026
f7805d2
perf(crypto): tell an identity key from its affine point, and stop co…
MegaRedHand Nov 18, 2026
bb658bc
docs(beacon): cite the spec's sorted-only check for payload attestati…
MegaRedHand Nov 18, 2026
1f55542
test(beacon): import checked everywhere, and drop the operations harn…
MegaRedHand Nov 18, 2026
45da672
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 18, 2026
f04660e
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 18, 2026
407074c
perf(blockchain): run one warm-only key-sum task at a time, and name …
MegaRedHand Nov 18, 2026
5af189d
fix(benchmark): warm the previous epoch's key sums after a gap in the…
MegaRedHand Nov 18, 2026
678cf9c
docs(beacon): spell out the key-sum majority rule and what a warm-up …
MegaRedHand Nov 18, 2026
efa4669
chore(metrics): give the key-sum warm histogram a 16 s bucket
MegaRedHand Nov 18, 2026
4426ef0
Merge main into perf/bls-batched-key-sums
MegaRedHand Nov 19, 2026
093bf34
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 19, 2026
391e317
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 19, 2026
7ecb365
perf(crypto): sum validated public keys through blst's batched affine…
MegaRedHand Oct 29, 2026
ed8f09c
test(crypto): cover keys that cancel in the batched sum
MegaRedHand Oct 30, 2026
1eaf194
docs(crypto): say where fast_aggregate_verify's non-empty key list co…
MegaRedHand Nov 17, 2026
4e4fe13
test(crypto): fast_aggregate_verify rejects an empty key list
MegaRedHand Nov 17, 2026
be952d1
perf(crypto): take a single validated key as its own sum
MegaRedHand Nov 18, 2026
73953da
Merge perf/bls-batched-key-sums into perf/block-signature-batch
MegaRedHand Nov 19, 2026
63ba4aa
Merge main into perf/block-signature-batch
MegaRedHand Nov 19, 2026
78de264
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 19, 2026
477ca69
fix(beacon): check pending signatures before a validator record or th…
MegaRedHand Nov 19, 2026
93b4566
refactor(beacon): return no state from a failed transition_block
MegaRedHand Nov 19, 2026
fa8c70f
refactor(beacon): drop block_signature_set
MegaRedHand Nov 19, 2026
b22918d
refactor(beacon): one definition of is_valid_indexed_attestation's ch…
MegaRedHand Nov 19, 2026
619e202
refactor(crypto): drop the batch's redundant identity-key check
MegaRedHand Nov 19, 2026
01e0024
refactor(crypto): build the bls predicates on SignatureSet
MegaRedHand Nov 19, 2026
0521d9d
refactor(state-transition): register the batch disagreement counter a…
MegaRedHand Nov 19, 2026
147d418
test(beacon): a credential change checks pending signatures before it…
MegaRedHand Nov 19, 2026
02dd69f
docs(beacon): say in apply_block which body signatures are checked be…
MegaRedHand Nov 19, 2026
af1671d
docs(beacon): name the gloas bid among the writes before a signature …
MegaRedHand Nov 19, 2026
f854757
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 19, 2026
c5e2784
Merge main into perf/block-signature-batch
MegaRedHand Nov 20, 2026
186250d
Merge perf/block-signature-batch into perf/committee-key-sums
MegaRedHand Nov 20, 2026
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions Cargo.lock

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

12 changes: 12 additions & 0 deletions bin/ethlambda/src/benchmark/import/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -91,6 +91,12 @@ pub(crate) struct ReplayOptions {
/// sleep is outside every measured span. 0 feeds blocks back to back.
#[arg(long, value_name = "MILLISECONDS", default_value_t = 0)]
pub block_delay: u64,
/// Warm each epoch's committee key sums before its first block is
/// imported, outside every measured span. A live node does this on a
/// worker between slots (the epoch precompute); a replay has no tick
/// loop, so without this flag part of the import never sees warm sums.
#[arg(long)]
pub warm_committee_sums: bool,
/// Report format printed to stdout. Logs go to stderr, so JSON output can
/// be piped directly (e.g. into jq).
#[arg(long, value_enum, default_value_t = OutputFormat::Human)]
Expand Down Expand Up @@ -194,6 +200,12 @@ mod tests {
.replay
}

#[test]
fn warm_committee_sums_is_off_unless_asked_for() {
assert!(!parse(&[]).warm_committee_sums);
assert!(parse(&["--warm-committee-sums"]).warm_committee_sums);
}

#[test]
fn block_delay_defaults_to_zero_and_parses_milliseconds() {
assert_eq!(parse(&[]).block_delay, 0);
Expand Down
76 changes: 74 additions & 2 deletions bin/ethlambda/src/benchmark/import/replay.rs
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,7 @@ use ethlambda_blockchain::metrics::{BLOCK_ARRIVAL_PHASES, BLOCK_IMPORT_PHASES};
use ethlambda_blockchain::{BlockChainServer, ImportOutcome};
use ethlambda_p2p::beacon::decode;
use ethlambda_state_transition::beacon::fork_choice;
use ethlambda_state_transition::beacon::helpers::accessors::CommitteeCacheExt as _;
use ethlambda_storage::Store;
use ethlambda_storage::backend::RocksDBBackend;
use ethlambda_types::ShortRoot;
Expand Down Expand Up @@ -123,10 +124,17 @@ pub(crate) async fn replay_corpus(dir: &Path, options: &ReplayOptions) -> eyre::
BlockChainServer::for_replay(store, None, options.safe_slots_to_import_optimistically);

let mut samples = Vec::with_capacity(manifest.slots.len());
// The epoch of the block imported before the one in hand, for
// `--warm-committee-sums`.
let mut previous_epoch: Option<u64> = None;

let warmup_total = manifest.warmup_slots.len();
for (position, &slot) in manifest.warmup_slots.iter().enumerate() {
let (block, block_root) = load_block(dir, &config, &mut clock, slot)?;
if options.warm_committee_sums {
warm_committee_sums(&clock, &block, previous_epoch)?;
}
previous_epoch = Some(slot / preset::SLOTS_PER_EPOCH);
let wall_seconds = import(&mut server, block, slot, block_root).await?;
eprintln!(
"warm-up {}/{warmup_total}: slot {slot} imported in {}",
Expand All @@ -139,6 +147,12 @@ pub(crate) async fn replay_corpus(dir: &Path, options: &ReplayOptions) -> eyre::
let total = manifest.slots.len();
for (iteration, &slot) in manifest.slots.iter().enumerate() {
let (block, block_root) = load_block(dir, &config, &mut clock, slot)?;
// Before the timer starts, so the warm-up is in no phase and no
// `wall_seconds`.
if options.warm_committee_sums {
warm_committee_sums(&clock, &block, previous_epoch)?;
}
previous_epoch = Some(slot / preset::SLOTS_PER_EPOCH);

let timer = PhaseTimer::start(IMPORT_PHASE_HISTOGRAM);
let wall_seconds = import(&mut server, block, slot, block_root).await?;
Expand All @@ -164,7 +178,12 @@ pub(crate) async fn replay_corpus(dir: &Path, options: &ReplayOptions) -> eyre::

Ok(Report::new(
Environment::collect(),
params_from(&manifest, dir, options.block_delay),
params_from(
&manifest,
dir,
options.block_delay,
options.warm_committee_sums,
),
samples,
))
}
Expand Down Expand Up @@ -198,6 +217,53 @@ fn load_block(
Ok((block, block_root))
}

/// Warms the committee key sums a live node's epoch precompute worker would
/// have warmed before `block` arrives: its epoch's, when that epoch is later
/// than `previous_epoch`'s, and, before the first block of the replay
/// (`previous_epoch` is `None`), the epoch before as well.
///
/// The worker advances the head's post-state to the epoch start and warms
/// from that state; this does the same from the block's parent post-state, so
/// the shuffling key it files the sums under is the one the import looks up.
/// Nothing else the worker does is reproduced: in a replay the import
/// already produces the epoch's state itself, inside the measured span.
fn warm_committee_sums(
store: &Store,
block: &SignedBeaconBlock,
previous_epoch: Option<u64>,
) -> eyre::Result<()> {
let epoch = block.slot() / preset::SLOTS_PER_EPOCH;
let epochs: Vec<u64> = match previous_epoch {
Some(previous) if epoch <= previous => return Ok(()),
// The epoch right after the last one: its predecessor was warmed when
// it began.
Some(previous) if epoch == previous + 1 => vec![epoch],
// The first block, or the first after a gap in the corpus: the
// previous epoch was never warmed here, so warm it too, as the live
// worker warms both on every boundary.
_ => epoch.checked_sub(1).into_iter().chain([epoch]).collect(),
};
let parent_root = block.parent_root();
let parent_state = store.get_state(&parent_root)?.ok_or_else(|| {
eyre::eyre!(
"no post-state for parent {} of the block at slot {}",
ShortRoot(&parent_root.0),
block.slot()
)
})?;
let config = store.config();
let committee_cache = store.committee_cache();
for epoch in epochs {
if parent_state.slot() < epoch * preset::SLOTS_PER_EPOCH {
let advanced = fork_choice::advance_to_epoch_start(&parent_state, epoch, &config)?;
committee_cache.warm_key_sums(&advanced, epoch);
} else {
committee_cache.warm_key_sums(&parent_state, epoch);
}
}
Ok(())
}

/// Import one block, returning the wall time of the `import_block` call
/// alone, and fail unless it imported.
async fn import(
Expand Down Expand Up @@ -240,7 +306,12 @@ fn read_anchor(dir: &Path, config: &Config) -> eyre::Result<(BeaconState, Signed

/// The report parameters a manifest already carries, so the loop above never
/// has to reconstruct them from samples.
fn params_from(manifest: &Manifest, dir: &Path, block_delay_ms: u64) -> Params {
fn params_from(
manifest: &Manifest,
dir: &Path,
block_delay_ms: u64,
warm_committee_sums: bool,
) -> Params {
Params {
mode: "import",
corpus: dir.display().to_string(),
Expand All @@ -252,6 +323,7 @@ fn params_from(manifest: &Manifest, dir: &Path, block_delay_ms: u64) -> Params {
range_end: manifest.range_end,
blocks: manifest.slots.len(),
block_delay_ms,
warm_committee_sums,
}
}

Expand Down
20 changes: 18 additions & 2 deletions bin/ethlambda/src/benchmark/report/import.rs
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,9 @@ pub(crate) struct Params {
/// Milliseconds slept after each block's import, outside every measured
/// span. 0 means blocks were fed back to back.
pub block_delay_ms: u64,
/// Whether each epoch's committee key sums were warmed before its first
/// block, outside every measured span (`--warm-committee-sums`).
pub warm_committee_sums: bool,
}

#[derive(Debug, Serialize)]
Expand Down Expand Up @@ -107,15 +110,16 @@ impl Report {
let _ = writeln!(out, "Block-import benchmark — {} workload", params.mode);
let _ = writeln!(
out,
" corpus={} network={} anchor_slot={} warmup_blocks={} range=[{}, {}] blocks={} block_delay_ms={}",
" corpus={} network={} anchor_slot={} warmup_blocks={} range=[{}, {}] blocks={} block_delay_ms={} warm_committee_sums={}",
params.corpus,
params.network,
params.anchor_slot,
params.warmup_blocks,
params.range_start,
params.range_end,
params.blocks,
params.block_delay_ms
params.block_delay_ms,
params.warm_committee_sums
);
let _ = writeln!(
out,
Expand Down Expand Up @@ -217,6 +221,7 @@ mod tests {
range_end: 3,
blocks: 2,
block_delay_ms: 0,
warm_committee_sums: false,
}
}

Expand All @@ -231,6 +236,17 @@ mod tests {
assert!(report.human_table().contains("block_delay_ms=750"));
}

#[test]
fn warm_committee_sums_is_recorded_in_the_json_and_the_header() {
let mut params = params();
params.warm_committee_sums = true;
let report = Report::new(Environment::collect(), params, Vec::new());

let json: serde_json::Value = serde_json::from_str(&report.to_json().unwrap()).unwrap();
assert_eq!(json["params"]["warm_committee_sums"], true);
assert!(report.human_table().contains("warm_committee_sums=true"));
}

#[test]
fn the_range_prints_inclusive_as_fetch_takes_it() {
let report = Report::new(Environment::collect(), params(), Vec::new());
Expand Down
71 changes: 63 additions & 8 deletions crates/blockchain/src/epoch_precompute.rs
Original file line number Diff line number Diff line change
Expand Up @@ -22,9 +22,11 @@
//! inline; the late result is stored and simply goes unused by that block.

use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;

use ethlambda_state_transition::beacon::fork_choice;
use ethlambda_state_transition::beacon::helpers::accessors::CommitteeCacheExt as _;
use ethlambda_state_transition::beacon::helpers::misc::compute_start_slot_at_epoch;
use ethlambda_state_transition::metrics as stf_metrics;
use ethlambda_storage::{CacheKey, Chain};
Expand Down Expand Up @@ -182,23 +184,45 @@ impl BlockChainServer {
Trigger::Head => head_slot / preset::SLOTS_PER_EPOCH + 1,
Trigger::Timer { slot } => slot / preset::SLOTS_PER_EPOCH + 1,
};
let already_cached = self
.store
.cached_state(CacheKey::CheckpointState {
epoch: candidate_epoch,
root: head_root,
})
.is_some();
let cached = self.store.cached_state(CacheKey::CheckpointState {
epoch: candidate_epoch,
root: head_root,
});
let inputs = DecisionInputs {
trigger,
syncing: self.sync_status.is_syncing(),
head_slot,
head_root,
current_slot: self.wall_clock_slot(),
in_flight: self.epoch_precompute_in_flight,
already_cached,
already_cached: cached.is_some(),
};
let Some(key) = decide(&inputs) else {
// Another path already advanced the state to the epoch's start
// (validating a gloas bid for the epoch's first slot does), so no
// worker runs, and the worker is what warms the key sums. Asked
// again as if nothing were cached, `decide` says whether that cache
// hit is the only reason no worker runs; if so, warm the sums from
// the cached state, or the epoch would import without them.
let only_the_cache_stopped_the_worker = decide(&DecisionInputs {
already_cached: false,
..inputs
})
.is_some();
// One warm-only task at a time. A second would not build the sums
// again (they sit behind a `OnceLock`), but it would hold a
// blocking thread waiting on the first.
if let Some(state) = cached
&& only_the_cache_stopped_the_worker
&& !self.key_sums_warming.swap(true, Ordering::AcqRel)
{
let committee_cache = self.store.committee_cache();
let warming = ClearOnDrop(Arc::clone(&self.key_sums_warming));
tokio::task::spawn_blocking(move || {
let _warming = warming;
warm_epoch_key_sums(&committee_cache, &state, candidate_epoch)
});
}
return;
};
// The head's post-state is resident (it was just imported); a read that
Expand All @@ -220,17 +244,48 @@ impl BlockChainServer {

let config = self.store.config();
let actor = ctx.actor_ref();
let committee_cache = self.store.committee_cache();
tokio::task::spawn_blocking(move || {
let result = {
let _timing = stf_metrics::time_epoch_precompute();
fork_choice::advance_to_epoch_start(&head_state, key.epoch, &config)
};
let result = result.map(Arc::new).map_err(|err| err.to_string());
let advanced = result.as_ref().ok().map(Arc::clone);
// The state goes to the actor first: the epoch's first block must
// not wait for key sums, which only make its attestations cheaper.
let _ = actor.send(EpochPrecomputed { key, result });
if let Some(state) = advanced {
warm_epoch_key_sums(&committee_cache, &state, key.epoch);
}
});
}
}

/// Warms the key sums `epoch`'s blocks read: `epoch`'s own, and the previous
/// epoch's for the attestations those blocks carry from it. The previous
/// epoch's are normally warm already, from the last boundary; after a restart
/// mid-epoch, or a boundary whose worker did not run, they are not. Both calls
/// return at once when the sums are resident.
fn warm_epoch_key_sums(
committee_cache: &ethlambda_storage::CommitteeCache,
state: &BeaconState,
epoch: u64,
) {
committee_cache.warm_key_sums(state, epoch);
committee_cache.warm_key_sums(state, epoch.saturating_sub(1));
}

/// Clears the flag it holds when dropped, so a warm-only task releases
/// `key_sums_warming` however it ends, a panic included.
struct ClearOnDrop(Arc<AtomicBool>);

impl Drop for ClearOnDrop {
fn drop(&mut self) {
self.0.store(false, Ordering::Release);
}
}

impl Handler<EpochPrecomputeCheck> for BlockChainServer {
async fn handle(&mut self, msg: EpochPrecomputeCheck, ctx: &Context<Self>) {
self.maybe_start_epoch_precompute(Trigger::Timer { slot: msg.slot }, ctx);
Expand Down
8 changes: 8 additions & 0 deletions crates/blockchain/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -430,6 +430,7 @@ impl BlockChain {
safe_slots_to_import_optimistically,
last_tick_instant: None,
epoch_precompute_in_flight: None,
key_sums_warming: Default::default(),
sync_status,
sync_status_controller,
events,
Expand Down Expand Up @@ -560,6 +561,11 @@ pub struct BlockChainServer {
/// most one runs at a time; see [`epoch_precompute`].
epoch_precompute_in_flight: Option<epoch_precompute::PrecomputeKey>,

/// Whether a warm-only key-sum task is running: one started because the
/// epoch's state was already cached, so no precompute worker ran to warm
/// the sums. At most one runs at a time; see [`epoch_precompute`].
key_sums_warming: std::sync::Arc<std::sync::atomic::AtomicBool>,

/// Stateful sync heuristic used by `lean_node_sync_status`. Also gates
/// validator duties while syncing, unless that gating was disabled at
/// startup via `--disable-duty-sync-gate` (then it is metric-only). On a
Expand Down Expand Up @@ -2153,6 +2159,7 @@ impl BlockChainServer {
safe_slots_to_import_optimistically,
last_tick_instant: None,
epoch_precompute_in_flight: None,
key_sums_warming: Default::default(),
sync_status: SyncStatusTracker::new(false),
sync_status_controller: SyncStatusController::default(),
events: ChainEvents::new(EventBus::default(), &store),
Expand Down Expand Up @@ -4625,6 +4632,7 @@ mod tests {
safe_slots_to_import_optimistically: constants::SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY,
last_tick_instant: None,
epoch_precompute_in_flight: None,
key_sums_warming: Default::default(),
sync_status: SyncStatusTracker::new(false),
sync_status_controller: SyncStatusController::default(),
duties: ChainDuties::Beacon,
Expand Down
Loading
Loading