[MegaRedHand]

Motivation

Store::config() opened a read view and deserialized Metadata["config"] on every call, then returned a Result no caller could act on. All fourteen call sites answered it the same way:

let genesis_time_ms = self.store.config().expect("config exists").genesis_time * 1000;

The config is written once in init_store and has no setter, so for a live Store the read cannot fail and the round trip buys nothing. Several of those call sites sit on the tick path (on_tick, propose_block, block import), so they pay it every slot.

Changes

• Store gains a config: ChainConfig field, populated in init_store from the anchor state and in from_db_state from the config it already parses for the genesis-time check.
• A plain copy, not an Arc: the value cannot go stale and is a single u64 today, so sharing it would only add indirection.
• config() becomes infallible and returns &ChainConfig.
• Drops the resulting .expect("config exists") from all call sites, which is why the diff reaches blockchain, rpc, and the spec-test runner rather than just storage.

KEY_CONFIG is still written and still read back by from_db_state, which refuses to resume a DB whose persisted genesis_time disagrees with the config file. Only the per-call read goes away, not the persistence.

Testing

• make fmt, make lint clean.
• cargo test --workspace --profile release-fast: 555 passed, 0 failed, 7 ignored (the usual #[ignore] crypto tests).

Note

CLAUDE.md gets a line about store.config() being an infallible field read once this and #562 have both landed. Left out here to avoid a conflict between the two branches.

[github-actions]

🤖 Kimi Code Review

This is a clean refactoring that eliminates unnecessary error handling and I/O for an immutable, bootstrap-time value.

Correctness & Safety

• The change is sound: ChainConfig is loaded once during store initialization (open/from_db_state) and cached. The validation logic ensuring the DB matches the supplied config remains intact (crates/storage/src/store.rs, lines 637-640 and 750-755).
• All call sites correctly migrate from .expect(...) to direct field access. No logic changes.

Performance

• Removes repeated backend round-trips for a static value. This is a minor but worthwhile optimization given config() is called on every tick, block proposal, and attestation aggregation.

Rust Idioms

• Returning &ChainConfig instead of Result<ChainConfig, Error> accurately models the invariant that the config is always available after initialization.
• The inline documentation explaining why an Arc is unnecessary (lines 554-560) is excellent; it clarifies that ChainConfig is cheap to clone and immutable.

Minor Note

• Ensure ChainConfig remains small (likely just primitives for genesis time/params). If it ever grows large (e.g., embedded bytecode or large preset lists), consider wrapping it in an Arc inside Store to avoid costly clones when the Store itself is cloned. Based on the "Lean" architecture, this appears unlikely.

Verdict: LGTM. No blockers.

---

Automated review by Kimi (Moonshot AI) · kimi-k2.5 · custom prompt

[github-actions]

🤖 Claude Code Review

Review: refactor(storage): cache ChainConfig in Store (PR 563)

This is a clean, well-scoped refactor. No correctness, security, or consensus-logic concerns.

What was verified:

1. Both construction paths set the new field correctly. init_store (crates/storage/src/store.rs:761) sets config: anchor_state.config, and from_db_state (crates/storage/src/store.rs:648) sets config: persisted_config. These are the only two places that build a Store from scratch, so the cached copy is always populated consistently with what's persisted under KEY_CONFIG.
2. No stale-cache risk. There's no setter for config, and every place that needs a different genesis time (e.g. the test-driver's "reset" path at crates/net/rpc/src/test_driver.rs:208) goes through from_anchor_state → init_store, which constructs a brand-new Store rather than mutating an existing one in place. So the invariant claimed in the PR description ("the config cannot go stale") holds.
3. All 14 call sites were updated consistently — verified via a repo-wide grep for .config(); none were missed, and none still hold onto the old Result/.expect(...) pattern.
4. Partial move in init_store (anchor_state.config moved into the returned Store at line 761) is safe: anchor_state.config.to_ssz() at line 700 only borrows, and anchor_state isn't referenced again after the final Self { ... } construction.
5. Test helpers (crates/storage/src/store.rs test module) were updated to populate the new field with ChainConfig { genesis_time: 0 }, keeping them in sync with the struct shape.
6. Doc comments on the field and the config() getter clearly explain why a plain ChainConfig copy (not Arc) is correct here, and why KEY_CONFIG is still persisted despite the cache — good self-documentation for future readers who might wonder why the seemingly-redundant storage round trip still exists.

No changes requested.

---

Automated review by Claude (Anthropic) · sonnet · custom prompt

[github-actions]

🤖 Codex Code Review

No correctness, security, or consensus-critical findings in this diff.

The change is narrowly scoped and looks sound: Store::config() is now an infallible read from cached state at crates/storage/src/store.rs:809, and the cache is initialized on each real construction path at crates/storage/src/store.rs:646 and crates/storage/src/store.rs:759. Since KEY_CONFIG is only written during bootstrap at crates/storage/src/store.rs:697, this does not change fork choice, attestation handling, justification/finalization, block processing, XMSS handling, or SSZ behavior; it just removes repeated backend reads on hot paths.

Minor test gap: crates/storage/src/store.rs:2965 only asserts that from_db_state() returns Some(_). I’d add an assertion that the reloaded store returns the persisted genesis_time via config() to lock in the new cache initialization behavior.

I could not run the Rust tests here: direct cargo usage is blocked by read-only home-directory writes for git dependencies (leansig), and network access is restricted.

---

Automated review by OpenAI Codex · gpt-5.4 · custom prompt

[greptile-apps]

Greptile Summary

The PR caches the immutable chain configuration directly in Store, eliminating repeated backend reads and deserialization from timing-sensitive and RPC paths.

• Initializes the cached configuration consistently during new-store bootstrap and database restoration.
• Makes Store::config() an infallible borrowed-field accessor.
• Updates blockchain, RPC, and specification-test callers to use the new accessor.

Confidence Score: 5/5

The PR appears safe to merge, with configuration caching consistent across bootstrap, database restoration, cloning, and test-driver replacement.

Every production Store constructor derives the cached value from the same configuration governing persisted state, and no live mutation path can make the cache stale.

Important Files Changed

Filename	Overview
crates/storage/src/store.rs	Adds the cached configuration field to every Store construction path while preserving persisted configuration validation during database restoration.
crates/blockchain/src/lib.rs	Updates consensus timing paths to use the infallible cached configuration without changing their calculations.
crates/blockchain/src/store.rs	Updates tick and proposal-head timing calculations for the new configuration accessor.
crates/blockchain/src/spec_test_runner.rs	Adapts fork-choice fixture timing to the infallible configuration accessor.
crates/net/rpc/src/genesis.rs	Reads the cached genesis time while preserving the existing RPC response contract.
crates/net/rpc/src/node.rs	Uses the cached genesis time for sync-distance calculation with existing overflow handling intact.
crates/net/rpc/tests/test_driver_e2e.rs	Updates test-driver coverage to assert against the new accessor.

_{Reviews (1): Last reviewed commit: "refactor(storage): cache ChainConfig in ..." | Re-trigger Greptile}