Repository navigation
feat: emit, pin, seed and verify the v4 evo snapshot section - #7601
PastaPastaPasta wants to merge 33 commits into
Conversation
83e5239 to
3c826e3
Compare
3c826e3 to
b88ddc3
Compare
b88ddc3 to
bb40231
Compare
|
This pull request has conflicts, please rebase. |
|
🕓 Review not started yet because this PR is a draft.
Commit 88ef72a. Normal review starts when eligible; priority review starts as soon as a slot is available. |
bb40231 to
6399275
Compare
|
Rebased onto the rebased #7593 (
Verified locally on 🤖 Posted autonomously by Claude on behalf of pasta. |
|
You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard. |
WalkthroughThe PR adds chain-aware Evo snapshot construction, validation, serialization, and state seeding. AssumeUTXO loading validates Evo data, records required historical MN-list work, handles state mismatches, and protects snapshot blocks from pruning. Estimated code review effort: 5 (Critical) | ~90 minutes Sequence Diagram(s)sequenceDiagram
participant dumptxoutset
participant CreateUTXOSnapshot
participant BuildEvoSnapshot
participant EvoDB
dumptxoutset->>CreateUTXOSnapshot: create UTXO snapshot
CreateUTXOSnapshot->>BuildEvoSnapshot: build Evo state at snapshot height
BuildEvoSnapshot->>EvoDB: read Evo chain state
CreateUTXOSnapshot-->>dumptxoutset: return Evo hash and masternode count
Merge Risk:
|
6399275 to
23d04e1
Compare
|
Pushed While restacking the follow-up loadtxoutset work on this head, its Verified on 🤖 Posted autonomously by Claude on behalf of pasta. |
thepastaclaw
left a comment
There was a problem hiding this comment.
Final validation — Phase 2 only (queue backlog)
The snapshot lifecycle has five confirmed blocking defects affecting cold-start continuation, quorum reconstruction, exception routing, and recovery from rejected snapshots. The commit also overstates the functional test's coverage. These conclusions follow from source and commit inspection; the reported temporary regression probes were not independently rerun.
🔴 5 blocking | 🟡 1 suggestion(s)
1 finding(s) not shown inline (the lines are not part of this PR's diff)
🟡 Suggestion: Reword the commit body's end-to-end test claim
<commit:23d04e1ef3d>:1
The commit body states that feature_assumeutxo_dash.py exercises the dump/load/complete cycle end to end, but the script only calls dumptxoutset and checks returned metadata and the emitted marker. Its docstring explicitly says loading is added in M5. Reword the commit body to describe the emission checks actually present; the PR description repeats the same inaccurate coverage claim and should be corrected as well. This is a reporting correction, not a request to expand the test's scope.
source: gpt-6-astra (phase2-reviewer: general, dash-core-commit-history)
Review provenance
Source: reviewer 1: gpt-6-astra (agent: phase2-reviewer, role: general); reviewer 2: gpt-6-astra (agent: phase2-reviewer, role: dash-core-commit-history); final verifier: gpt-6-astra (agent: astra-verifier, role: final-verifier)
- Triage:
criticalbygpt-6-astra(effort low) — The intricate snapshot lifecycle changes in src/validation.cpp and src/evo/snapshot_chain.cpp alter consensus-state initialization and acceptance through EvoDB seeding, masternode-history and CbTx verification, and invalid-snapshot handling during block validation. - Phase 1 reviewers: not run (skipped for throughput: 22 PRs queued, above the 10 limit)
- Fresh verifier:
gpt-6-astra— final-verifier; agentastra-verifier - Phase 2 reviewers:
gpt-6-astra— general (completed, effort xhigh); agentphase2-reviewer,gpt-6-astra— dash-core-commit-history (completed, effort xhigh); agentphase2-reviewer
🤖 Prompt for all review comments with AI agents
These findings are from an automated code review. Verify each finding against the current code and only fix it if needed.
In `src/evo/snapshot_chain.cpp`:
- [BLOCKING] src/evo/snapshot_chain.cpp:469-470: Seed the credit-pool expiry history needed after the base
Seeding only the base CCreditPool does not support cold snapshot continuation. On a mature v20-active chain, connecting base+2 calls GetCreditPool(base+1), whose ConstructCreditPool() reads the block at base+1-CreditPoolPeriodBlocks() to determine the amount leaving the withdrawal window. If background validation has not supplied that pre-base block, GetCreditDataFromBlock() throws `failed-getcbforblock-read`, and special-transaction processing converts the failure into a consensus rejection of the valid post-base block. The historical read occurs even when there were no withdrawals. Carry and seed the per-height expiry data, or obtain the required historical blocks before allowing continuation; the aggregate latelyUnlocked value cannot determine future expirations.
- [BLOCKING] src/evo/snapshot_chain.cpp:137-145: Include work-block state for quorums not yet mined at the base
The builder registers work blocks only for mined commitments and carried historical rotation snapshots. For a v20-active base at H+5, where H is a DKG cycle boundary and the current mining window has not started, no commitment registers H-WORK_DIFF_DEPTH. The rotation horizons start at H-C, so they do not supply this work block either. A cold consumer validating the first post-base commitment for H requests that pre-base MN list through GetAllQuorumMembers(), but neither a seeded list nor its ordinary diff chain exists; GetListForBlockInternal() throws instead of allowing the valid chain to advance. Include the pre-base work lists and modifiers required by upcoming quorum processing, even before commitments are mined, and update ValidateEvoSnapshotAgainstChain() so its required-work set accepts and requires that state.
In `src/validation.cpp`:
- [BLOCKING] src/validation.cpp:3207-3211: Allow snapshot mismatches to reach the chainstate exception boundary
This catch cannot handle mismatches raised through special-transaction processing because intervening handlers consume them. GetAllQuorumMembers() rethrows SnapshotStateMismatchError while the EvoDB transaction is active, but CheckSpecialTxInner() and ProcessSpecialTxsInBlock() both catch std::exception and translate it into consensus-invalid state (`failed-check-special-tx` or `failed-procspectxsinblock`). ConnectTip() then calls InvalidBlockFound() rather than rejecting the snapshot through HandleSnapshotStateMismatch(). Add explicit passthrough handling for SnapshotStateMismatchError in the intervening catch layers so the transaction unwinds before this boundary handles the local-state failure.
In `src/llmq/utils.cpp`:
- [BLOCKING] src/llmq/utils.cpp:340-341: Use the seeded modifier when constructing rotation snapshots
Passing nullptr bypasses the seeded modifier when writing a reconstructed rotation snapshot. BuildNewQuorumQuarterMembers() receives the snapshot-aware modifier, but BuildQuorumSnapshot() recalculates its ordering here without the snapshot manager. When the historical work block is unavailable and its coinbase contained a non-null ChainLock, GetNonNullCoinbaseChainlock() returns no value, so this calculation uses the block-hash fallback instead of the seeded ChainLock-derived modifier. The activeQuorumMembers bitmap is consequently indexed in a different order from the order used by GetQuorumQuarterMembersBySnapshot(). This can conflict with an existing seeded snapshot or persist incorrect membership state. Pass the already-resolved modifier into BuildQuorumSnapshot() rather than recalculating it.
In `src/evo/evodb.cpp`:
- [BLOCKING] src/evo/evodb.cpp:275-277: Remove rejected snapshot-derived state as well as lifecycle markers
Snapshot activation commits seeded records into the shared EvoDB keyspace, but DiscardSnapshotMarkers() removes only lifecycle bookkeeping and the retained section. A rejected `llmq_M3` modifier remains readable through GetSeededQuorumModifier() after the default identity returns to NORMAL. Once ordinary validation encounters that work block, it can raise the same mismatch again, now without an active snapshot for HandleSnapshotStateMismatch() to invalidate. Seeded MN-list, rotation, and credit-pool records likewise remain available to normal readers, contradicting the recovery path's promise to restart without snapshot data. Track or isolate snapshot-owned records and remove their unvalidated state during rejection while preserving independently validated records; do not erase the retained section before performing the cleanup that needs it.
In `<commit:23d04e1ef3d>`:
- [SUGGESTION] <commit:23d04e1ef3d>:1: Reword the commit body's end-to-end test claim
The commit body states that `feature_assumeutxo_dash.py exercises the dump/load/complete cycle end to end`, but the script only calls dumptxoutset and checks returned metadata and the emitted marker. Its docstring explicitly says loading is added in M5. Reword the commit body to describe the emission checks actually present; the PR description repeats the same inaccurate coverage claim and should be corrected as well. This is a reporting correction, not a request to expand the test's scope.
| if (!cpoolman.SeedSnapshot(snapshot_start_block, snapshot.credit_pool) || | ||
| !mnhfman.SeedSignals(snapshot_start_block, snapshot.mnhf_signals)) { |
There was a problem hiding this comment.
🔴 Blocking: Seed the credit-pool expiry history needed after the base
Seeding only the base CCreditPool does not support cold snapshot continuation. On a mature v20-active chain, connecting base+2 calls GetCreditPool(base+1), whose ConstructCreditPool() reads the block at base+1-CreditPoolPeriodBlocks() to determine the amount leaving the withdrawal window. If background validation has not supplied that pre-base block, GetCreditDataFromBlock() throws failed-getcbforblock-read, and special-transaction processing converts the failure into a consensus rejection of the valid post-base block. The historical read occurs even when there were no withdrawals. Carry and seed the per-height expiry data, or obtain the required historical blocks before allowing continuation; the aggregate latelyUnlocked value cannot determine future expirations.
source: gpt-6-astra (phase2-reviewer: general)
There was a problem hiding this comment.
Confirmed, and I am leaving this open for a decision from pasta rather than fixing it here. ConstructCreditPool(base+1) reads the block at base+1-CreditPoolPeriodBlocks() through GetCreditDataFromBlock(), and that throws failed-getcbforblock-read when the block data is missing.
develop has made this worse since the review. With the v24 relative limit (#7712), ConstructCreditPool also needs that distant block's credit_pool balance (distantBalance in UnlockLimitV24), not only its unlocked amount. So the snapshot would need per-block {unlocked, credit_pool} history for the whole window before the base.
There are two possible fixes, and both are design changes:
- carry that window in the evo section, which is a v3 format change to code merged in feat: evo snapshot v3 — canonical bounded codec and context-free validation #7592, plus seeding and validation work;
- fetch and connect the pre-base window blocks before the snapshot chainstate is allowed to advance.
I don't want to guess which one is wanted.
🤖 Posted autonomously by Codex on behalf of pasta.
There was a problem hiding this comment.
Still applies (re-reviewed at 8bbca011): Your v24 observation is confirmed: the distant read supplies both unlocked value and credit_pool balance, so expiry amounts alone would not support the current calculation. Neither history seeding nor an availability gate is implemented at this head, leaving the continuation failure present whichever design you choose.
| EraseHistoricalMNListMarkers(*db, batch); | ||
| batch.Erase(EVODB_SNAPSHOT_EVO_SECTION); | ||
| batch.Erase(EVODB_DUAL_CHAINSTATE); |
There was a problem hiding this comment.
🔴 Blocking: Remove rejected snapshot-derived state as well as lifecycle markers
Snapshot activation commits seeded records into the shared EvoDB keyspace, but DiscardSnapshotMarkers() removes only lifecycle bookkeeping and the retained section. A rejected llmq_M3 modifier remains readable through GetSeededQuorumModifier() after the default identity returns to NORMAL. Once ordinary validation encounters that work block, it can raise the same mismatch again, now without an active snapshot for HandleSnapshotStateMismatch() to invalidate. Seeded MN-list, rotation, and credit-pool records likewise remain available to normal readers, contradicting the recovery path's promise to restart without snapshot data. Track or isolate snapshot-owned records and remove their unvalidated state during rejection while preserving independently validated records; do not erase the retained section before performing the cleanup that needs it.
source: gpt-6-astra (phase2-reviewer: general)
There was a problem hiding this comment.
Agreed that this is a real gap, but I have not changed it in this push. It needs a design decision from pasta. Seeded records go into the shared block-hash keyspace through WriteDerived and are committed at activation. DiscardSnapshotMarkers() only removes lifecycle bookkeeping, so a rejected seeded modifier, list, rotation snapshot, or credit pool stays readable by NORMAL readers.
A correct fix needs one of two things:
- track the snapshot-owned keys and remove only those not independently confirmed by background validation, and do that before the retained section is erased;
- isolate seeded state under its own key prefix or identity until promotion.
Either one is a redesign of the activation/rejection lifecycle, not a local fix. Leaving this open.
🤖 Posted autonomously by Codex on behalf of pasta.
There was a problem hiding this comment.
Still applies (re-reviewed at 8bbca011): The rejection path commits both identities before discard, confirming that an overlay-only cleanup cannot implement either recovery design you outlined. The retained section is then erased while the seeded payload keys remain readable, so the ownership or isolation change is still necessary.
| const size_t emit_active{std::min(indexes.size(), active_count)}; | ||
| for (size_t i{0}; i < emit_active; ++i) { | ||
| const CBlockIndex* work_index{register_work_block(params, data.rotation_enabled, indexes[i])}; | ||
| if (work_index == nullptr) { | ||
| error = "missing active quorum work block"; | ||
| return false; | ||
| } | ||
| auto entry{ReadCommitment(qblockman, params.type, indexes[i], work_index, error)}; | ||
| if (!error.empty()) return false; |
There was a problem hiding this comment.
🔴 Blocking: Include work-block state for quorums not yet mined at the base
The builder registers work blocks only for mined commitments and carried historical rotation snapshots. For a v20-active base at H+5, where H is a DKG cycle boundary and the current mining window has not started, no commitment registers H-WORK_DIFF_DEPTH. The rotation horizons start at H-C, so they do not supply this work block either. A cold consumer validating the first post-base commitment for H requests that pre-base MN list through GetAllQuorumMembers(), but neither a seeded list nor its ordinary diff chain exists; GetListForBlockInternal() throws instead of allowing the valid chain to advance. Include the pre-base work lists and modifiers required by upcoming quorum processing, even before commitments are mined, and update ValidateEvoSnapshotAgainstChain() so its required-work set accepts and requires that state.
source: gpt-6-astra (phase2-reviewer: general)
There was a problem hiding this comment.
Confirmed. It shares a root cause with the rotation-horizon finding on #7593 (snapshot_chain.cpp:168 there), so I am leaving it open for a decision from pasta.
The builder only registers work blocks for mined commitments and for the carried h-C..h-4C rotation horizon. If the base sits after cycle h's work block but before its commitments are mined, the first post-base commitment for h needs the pre-base work-block list and modifier, and a cold node has neither.
Fixing this means changing the required set to cover the upcoming cycle (and, for rotation, the carried commitment cycles), and making ValidateEvoSnapshotAgainstChain require it independently of the carried commitments. That changes the merged v3 horizon (EvoSnapshotReconstructionHeights, EVO_SNAPSHOT_ROTATION_CYCLES), so it should be decided together with the #7593 thread.
🤖 Posted autonomously by Codex on behalf of pasta.
There was a problem hiding this comment.
Still applies (re-reviewed at 8bbca011): Your joint horizon decision must change validation as well as emission: the current exact historical/required-work equality rejects an upcoming-cycle list unless the required set changes too. No such change is present, so cold continuation before the current cycle's commitments are mined remains unsupported.
23d04e1 to
f728741
Compare
|
Rebased onto #7593's amended head 🤖 Posted autonomously by Claude on behalf of pasta. |
A quorum whose base block predates v19 needs a legacy-version commitment signed under the legacy BLS scheme. Every live network is far past v19, so the only chains that still reach this are regtest and devnet chains started with a late v19 height. Skip the DKG there instead of carrying a legacy signing path for it; blocks get null commitments until v19 activates. feature_protx_version.py keeps its pre-v19 phase and legacy masternode registrations, and checks that no DKG session starts before v19. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Production code can no longer produce a legacy signature or a legacy secure aggregate. Sign(), AggregateSecure() and VerifyInsecureAggregated() are basic, and verification defaults to basic unless a scheme is named, which only the block-derived consensus checks do. Every live path stops consulting the process-wide flag: DKG messages and sessions, sig shares, recovered signatures, the coinbase ChainLock decoder, the miner, the P2P commitment check and the quorum RPCs. The per-contribution vvec scheme bookkeeping in the DKG goes with it, since a vvec is always decoded with the subgroup check now. A provider transaction that needs an operator signature is refused before v19, where consensus would verify it under the legacy scheme. After v19 the signature is basic whatever the payload version, which is what consensus has verified since v19. Tests that exercise historical validation get legacy signatures from SignBLS()/AggregateSecureBLS() in test/util. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
A lazily decoded BLS object carried a legacy/basic tag next to its
bytes. For an operator key that tag was a second copy of what the
owning payload's or masternode state's nVersion already says, and the
two had to be kept in step by hand: SetStateVersion() re-encoded the
key, validation rejected payloads whose tag disagreed with their
version, and a stale tag changed the unique-property slot and the bytes
written to disk.
Remove the tag from the wrapper's interface. It still keeps the bytes
it was read from and the scheme they were read under, so decoding stays
deferred and writing back under the same scheme needs no decoding, but
nothing can observe or change that scheme, and writing under the other
scheme re-encodes the decoded point instead of emitting zeros for an
object that was never decoded.
CBLSLazySignature is basic only. CBLSLazyPublicKey has no scheme-less
Serialize, GetHash or ToString, so every encoding of an operator key
names the scheme, which each owner exposes as OperatorKeyScheme().
The unique-property map takes an OperatorKeySlot{key, scheme} and can
no longer be instantiated with a bare key; its hashes are unchanged, so
operator-key uniqueness stays per encoding. The mempool's operator-key
maps, the state diff rule and the MNAUTH key hash use the same explicit
scheme.
The old-format state diff now holds the operator key as raw bytes and
builds the key once the version is known, before the diff is applied,
instead of reading it as legacy and flipping the tag afterwards.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
bls::bls_legacy_scheme was a mutable global that every un-annotated BLS encode, decode and verify read. Validation had to flip it at the v19 boundary on connect and undo, restore it when a block failed, keep a background chainstate from disturbing the active one, and force it at startup, and any new BLS call site silently depended on all of that being right. Nothing reads it any more, so delete it together with ScopedBLSLegacyScheme and its five uses in validation, the v19 flips in special transaction processing, the notify_bls_state plumbing in chainstate loading, the override in ForceSignalDBUpdate and the temporary equivalence checks. A BLS call that names no scheme is now basic. Legacy appears only as an explicit BLSScheme::Legacy, derived from a payload or commitment version or from the block being validated. Secret keys and ids cannot be given a scheme: passing one does not compile, and a secret key is always read with the range check the basic scheme selected. Tests name the scheme they exercise instead of storing the flag. The tests of the flag machinery itself are gone. The per-block scheme of operator signatures is covered by proupserv_signature_scheme_follows_block_height, which now also walks the tip back across v19, and a new test runs commitment verification, direct and queued, under each scheme. bls_check_runs_under_the_scheme_it_was_given runs queued checks on CCheckQueue worker threads: a check verifies under the scheme it carries, whichever thread runs it. verify_db_across_v19 runs the level 4 database check from a tip past v19 over blocks mined before it. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
…rified The scheme of the block after a given one was spelled out as a v19 ternary in four places. BLSSchemeAfter() is now the one expression, used for the provider transaction rules, for commitments in a block and by the quorum RPCs that pick a scheme from a block. CFinalCommitment::Verify() took a flag for whether to check signatures and a scheme that defaulted to basic, so a new caller on a consensus path would have verified under basic without saying so. It now takes an optional scheme: none skips the signatures, a value verifies under it. BuildCommitmentHash() no longer defaults its scheme either. Nothing mined a legacy commitment into a block any more, so the choice made in CQuorumBlockProcessor::ProcessBlock() was not pinned by a test. mined_commitment_scheme_follows_the_block connects and rejects blocks on both sides of v19, including a legacy-version commitment mined after it, which must verify under basic. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
… rule The legacy scheme is only needed for data a version or a block marks as legacy. lint-bls-scheme.py lists the production files that name BLSScheme::Legacy, each with its reason, and fails when another file starts to or a listed one stops, so a new legacy use is a deliberate, reviewed addition. The developer notes gain a short section on how a scheme is chosen. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
…ncomplete While the snapshot chainstate is active and unvalidated, every DKG phase handler thread spun with no delay: WaitForNextPhase(nullopt, Initialized), the first call of each round, threw AbortPhaseException on its first check, and PhaseHandlerThread caught it and restarted the round at once. Each iteration took cs_main, threw and caught an exception, called MarkAborted and, under -debug=llmq-dkg, logged four lines. No round can start in that state (InitNewQuorum refuses it), so the round-start wait now sleeps and re-checks instead of aborting. A round in progress is still abandoned, and a stop request, now checked first, still ends the wait. Nodes not running on an unvalidated snapshot behave as before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
During dual-chainstate operation a snapshot chainstate block whose Evo state depends on data this node does not have yet (a pre-base MN-list diff on a cold EvoDB) raised BlockDataUnavailableError. The generic std::exception catch in ProcessSpecialTxsInBlock turned it into failed-procspectxsinblock, so the block was marked BLOCK_FAILED_VALID and its relayer could be punished, although nothing is wrong with it. Add evo/snapshot_types.h with a LocalStateError base for errors about this node's own Evo state: BlockDataUnavailableError (moved here), SnapshotStateMismatchError and EvoViewBindingError. Rebuilding the credit pool or the EHF signals from a block body this node does not have (pruned, or below a snapshot base) raises BlockDataUnavailableError; a body the node has (BLOCK_HAVE_DATA) but cannot read raises BlockDataReadError. The readers take the data flag and the block position under one cs_main lock. For a pruned node this changes NORMAL too: such a block now stalls the chainstate instead of being marked invalid. Every generic catch on the block-connection path (CheckSpecialTxInner, ProcessSpecialTxsInBlock, CheckCreditPoolDiffForBlock, UndoSpecialTxsInBlock, GetCreditPoolDiffForBlock, CMNHFManager::ProcessBlock, CDeterministicMNManager::ProcessBlock) rethrows them. ConnectTip, DisconnectTip and TestBlockValidity classify them: a mismatch rejects the snapshot through the new ChainstateManager::HandleSnapshotStateMismatch, a read error stops the node like a block ConnectTip cannot read (AbortNode), and anything else is state.Error, so the chainstate stalls instead of invalidating the block. ConnectTip announces that error through BlockChecked like any other connection result, so submitblock reports it and the relaying peer is neither punished nor credited. Mempool and mining callers of CheckSpecialTx fail locally, the asset-unlock credit-pool precheck passes the error on, and mempool acceptance (single, package and test-accept) turns any local Evo error into an error result, dropping the coins it loaded like any failure. A package is refused with the mempool error evo-local-unavailable, which testmempoolaccept reports as its package error and submitpackage as its failure. HandleSnapshotStateMismatch is extracted from the MaybeCompleteSnapshotValidation rejection lambda, and flushes both chainstates first so it can also run mid-connection. A stall is typed: BlockValidationState carries a LocalEvoStateResult (unavailable data, a binding fault, or a mismatch that could not reject the snapshot), queried with IsLocalEvoStateError(). It is an error, never invalidity, and is distinct from storage errors and from a rejected snapshot. The chainstate remembers the blocks it stalled on (every one: they are all in the block index) and refuses them at once on later attempts instead of revalidating them, until the node restarts; the first stall logs an error and sets the misc warning. Without a snapshot, Evo state is missing only because the block data it is derived from was pruned, and the warning says so and suggests -reindex. Completing snapshot validation does not make the background chainstate's state readable to the snapshot chainstate before the next startup promotes it, so a chainstate still stalled then is told to restart. Candidate selection passes over the branches that need the stalled block connected (or disconnected), so a usable branch with less work still advances the chain; ActivateBestChain reports the stall when only it keeps a chain with more work out of reach. A stalled block found invalid or conflicting with a ChainLock since obstructs nothing: it is forgotten, and a branch through it is removed like any unusable one. Callers that treated any failure as fatal no longer abort on a stall: ActivateBestChain announces the blocks it connected before stopping, ActivateBestChainStep returns the disconnected transactions to the mempool without AbortNode, block import continues with the other chainstates and the rest of startup, LoadExternalBlockFile keeps importing for the other chainstates, ChainLock enforcement retries on its next run, and InstantSend keeps the conflicting blocks a lock could not invalidate and retries them after the next tip or ChainLock change instead of asserting; an invalidation that is only temporary, for a lock without its transaction, clears the failure flags it set however it ends. A stall partway through a rewind keeps the blocks already disconnected and announces the tip reached: InvalidateBlock and ChainLock conflict marking finish and announce what they disconnected, and ActivateBestChain never releases cs_main with the chain rewound below the candidates it passed: it lists them again, as InvalidateBlock does, and selects again with the stall remembered, so it normally reconnects the chain it started from before it reports the stall. A block whose disconnect stalls stays in the chain, so the best header (and best invalid block) adjusted for it are restored. The warning helper only sets the warning. Validation raises the GUI alert through the new kernel::Notifications::evoStateWarningChanged(), which node::KernelNotifications forwards to uiInterface.NotifyAlertChanged() without -alertnotify, so validation does not depend on the node's UI interface. The alert count in chainstatemanager_activate_snapshot pins that the alert still fires once per warning: it is a parity check, not a test that fails without a fix. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
An EvoViewToken names the Evo state one operation works on: an EvoDB, an identity, a generation and the snapshot base. EvoViewScope binds the calling thread's accesses on that EvoDB to a token until it goes out of scope; scopes nest and restore the enclosing binding on exit. A transaction the same thread holds open on the EvoDB also binds it, and a scope and a transaction must agree: a conflict in either order raises EvoViewBindingError. CEvoDB::CurrentView() resolves the open transaction, then the innermost scope, then the default identity. Nothing binds scopes yet, so behavior is unchanged: unbound access still resolves to the default identity. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
LevelDB skips a table block that fails its checksum and its iterator stays valid at the next one, reporting the failure only through its status. A walk that stops on !Valid() therefore cannot tell the end of the data from entries it never saw. CDBIterator::HasError() exposes that status, so a walk that must not finish over missing records can check it before each key and at the end. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…th journaled promotion
The snapshot chainstate shared the NORMAL keyspace. Its records above the
snapshot base (MN lists, mined commitments, credit pools) stayed readable
by NORMAL after the snapshot was rejected, so the background chainstate
could consume them instead of deriving its own state, or abort on a
WriteDerived mismatch.
Every key the SNAPSHOT identity writes is now stored as ("S",
generation, key), and its reads and iterators see only that namespace:
there is no NORMAL fallback, and NORMAL iterators step over all
generations. Like the database iterator it wraps, a namespace iterator
reports read errors (HasError). WriteDerived therefore compares only
within its own view. CEvoDB gains WriteImmediate for view-aware writes
outside a transaction, unsynced like the raw write it replaces;
StoreSnapshotForBlock uses it, and under the snapshot view at or below
the base it only compares a carried quarter and neither persists nor
caches an uncarried one. The remaining raw-DB users (DMN migration and
repair, quorum cleanup) are marked NORMAL-only lifecycle operations.
Generations carry an unprefixed lifecycle record (unpublished,
published, rejected, promoting; base; tip; local schema version) and
the EvoSnapshotConsensusConfig fingerprint of the consensus and
deployment configuration they were published under. Startup collects
unpublished and rejected generations, refuses a published one whose
fingerprint no longer matches, and refuses dual-chainstate markers that
predate isolation.
Rejection marks the generation rejected in the same synced batch that
discards the markers. The rejected record stays until the snapshot's coins
directory has been invalidated, and only then is the generation collected,
so a crash in between still finishes the invalidation at startup. Promotion writes a journal
before the first coins-directory rename, merges the generation into
NORMAL keys with a resumable cursor, collects it, and publishes the final markers
atomically with removing the journal. Startup finishes a journaled
promotion; without a journal, a completed coins swap can only be an
interrupted invalid-snapshot cleanup and is discarded.
LevelDB skips a table block that fails its checksum and its iterator
stays valid at the next one, reporting the error only through its
status. Promotion, collection and generation loading check it before
each key and at the end, and stop with their journal and records in
place: otherwise a promotion could publish its tip without the records
it never copied, and a collection erase the record of a generation it
did not finish.
Every key a generation is seeded with is recorded in its seed manifest
with its family's merge policy (CEvoDB::WriteSeed). Promotion never
copies a seeded key into NORMAL, which derives that state itself. Where
NORMAL holds the same key, a masternode list must be canonically equal
(the same masternodes, internal ids and registration counter, however
the maps are laid out) and a byte-deterministic record byte-equal;
snapshot-only scaffolding is never compared, and a policy this version
does not know fails the promotion. An unseeded key comes from a block
above the base, which NORMAL never connects while the generation is
live, so one NORMAL also holds fails the promotion as well; only the
LLMQ best-block singleton is superseded.
A refusal for a changed consensus configuration names the generation,
its base block and height, its phase, that the changed component is
unknown because only the aggregate fingerprint is recorded, and how to
recover. It is made before startup changes anything on disk.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Isolating the snapshot generation's records is not enough while the managers keep one cache for both chainstates: a list, quorum member set, mined-commitment location or deployment state derived under the snapshot view at a block the background chainstate also reaches was served to NORMAL lookups, which then never derived their own. EvoViewCache keeps one partition per Evo view (EvoDB, identity, generation). Every cache keyed by a block or quorum hash now resolves the calling operation's view and uses only that partition: the MN-list lists, diffs, tip and initial-snapshot anchor; quorum snapshots; credit pools; MNHF signals; mined-commitment locations and the qc-hash caches; the quorum member caches; the quorum manager's quorum, scan and commitment-scan caches; the versionbits and warning caches; and the previous-coinbase ChainLock statics. The versionbits partition and the EHF signals SignalHeight reads both come from the calling thread's view. Caches of data parsed from block bytes and the vvec/skshare stores stay shared. Retiring a generation drops its partitions at the next lookup and leaves NORMAL's, so a failed snapshot load no longer empties the active masternode list until the next block. Promoting a generation, like opening a CEvoDB, bumps an epoch that drops every partition. DeploymentActiveAfter/At through a ChainstateManager decide a buried deployment by height alone, without resolving a view. The MN-list cache of a view is pruned against the higher of its tip and the highest block it processed: a view stops receiving tip notifications once its chainstate is no longer the active one, so a stale tip would keep its cache from ever being pruned. A snapshot view has no quorum history at or below its base once DIP3 is active there (a base at or above the DIP3 height), so lookups that would need it raise BlockDataUnavailableError instead of answering from partial data: a mined-commitment scan that comes up short (GetMinedCommitmentsUntilBlock, and the rotating per-index scan on a miss), a HasMinedCommitment miss for a quorum at or below the base, and the coinbase ChainLock read of a block at or below the base whose body is not stored. EHF signals derived from block bodies are written only inside a block-scoped Evo transaction, on a cache hit too, so lookups from mempool acceptance, mining or RPC leave the view clean. Adds CDeterministicMNManager::SetListSnapshotMissHookForTesting, which reports lookups that miss both the cache and the stored lists, and CachedListHeightsForTesting, for the partition and pruning tests and the stall tests that need one lookup to fail. With the hook, a test also rejects a snapshot in the middle of a block connection and checks that the background chainstate becomes the active one. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Evo accesses resolved their view from an open transaction or, failing that, the active chainstate. Work for the background chainstate outside a transaction, and work handed to another thread, silently used the active (snapshot) view instead. ForceSignalDBUpdate, for one, opened a NORMAL transaction at the active snapshot tip and flushed the NORMAL root. Every Chainstate method that reads Evo state (ActivateBestChain, ConnectTip, DisconnectTip, ReplayBlocks, LoadChainTip, RollforwardBlock, FlushStateToDisk, InvalidateBlock, EnforceBlock), TestBlockValidity, VerifyDB and the per-chainstate startup loops now bind that chainstate's view. ForceSignalDBUpdate takes the intended chainstate's view and uses its identity for the transaction and the root commit. Signals that view cannot rebuild are left to be rebuilt on demand when it is a snapshot view, so startup can still reach the promotion of a validated snapshot; NORMAL, which lacks history only when it was pruned, still fails startup, as does a body that cannot be read. DMN repair binds NORMAL. Active-chain dispatchers bind the active chainstate's view per operation unless the thread is already bound, with a single view too, so a turn that a snapshot publication overtakes finishes in the view it started in. While a snapshot generation is live, the view is read under cs_main, together with the active tip where the turn needs one (ActiveEvoViewScope::Tip()), so a turn never pairs one chainstate's view with another's tip. With a single view there is nothing to pair, and a turn that needs no tip binds without waiting for cs_main. The dispatchers are: RPC execution, each peer's message-handler turn (its queued GETDATA requests, its next message and its sends), the miner, mempool admission, Evo-reading interfaces calls, each node-scheduler task and each ChainLock, DKG and InstantSend work round. A failing work round, the LLMQ signing loops' and each DKG phase handler's included, is logged once per operation, view generation and reason, and its recovery once the operation has gone a minute without failing. A local Evo state error in a message handler drops that message, like any exception there, without punishing the peer; one from the peer's queued GETDATA requests ends receiving for that turn. Neither ends the message-handler thread, and the peer's sends (including its discouragement and ping timeout) still run. GETDATA requests leave the queue before they are served, so a failed lookup neither serves earlier requests again nor keeps the peer's later messages waiting; it is answered with NOTFOUND together with the requests found missing before it, and the requests after it are served on the next turn. The node scheduler and REST start before the block databases load, and a load retry replaces the Evo database, so they bind only to the one startup publishes once loading is final (and withdraws before destroying it, after they have stopped); until then their work runs unbound. RPC is held off by its warm-up until then. A chainstate load retry first lets the validation events the failed attempt queued run, since they are bound to the databases it then releases. Queued validation events and LLMQ worker-pool tasks capture the enqueuing thread's binding and reinstall it when they run; a task bound to a retired generation, or whose binding cannot be installed, is dropped, and what its enqueuer claimed for it is released. A local Evo state error in one subscriber to a queued event stays with that subscriber, and the others still receive the event; synchronous signals still pass it on to their caller. Either way the subscriber's registration count stays right, so it can still be unregistered. Every GUI- and wallet-facing interface operation that reads Evo state (the EVO provider operations, Evo, governance and LLMQ reads, isV24Active and listMNCollaterials) binds the active view and contains evo::LocalStateError at the interface boundary: it logs once per operation and generation, sets the misc warning, and reports failure through the operation's own channel. Operations without one now return std::optional (or, for GovernanceInfo, an optional fundingthreshold), and their Qt and wallet consumers keep their current data, show that the masternode state is unavailable, or refuse the action, instead of treating it as data. getPlatformQuorum runs Q's lookup in the bound view as well, and answers UNAVAILABLE when it cannot, or when a snapshot was published after it bound its view. While the masternode list is unavailable, the wallet keeps outputs it cannot classify out of automatic coin selection, CoinJoin's included, and classifies them again on the next block. A block builds its wallet batch only for that work or for a block it scans. A chainstate's remembered Evo stall lapses once its view changes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With two chainstates, an Evo access that no transaction or scope binds says nothing about which chainstate it serves. Resolving it to the default identity silently computed one chainstate's state from the other's data. While a snapshot generation is live, an unbound read, write, iterator or cache lookup, and one bound to a retired generation, now raises EvoViewBindingError before touching any state. The check is a plain throw, so it holds in release builds. Manager entry points that take an explicit chainstate (ProcessSpecialTxsInBlock, UndoSpecialTxsInBlock and the quorum block processor's ProcessBlock and UndoBlock) refuse to run unless the calling thread is bound to that chainstate's view, raising EvoViewBindingError on connect and undo alike, so the chainstate boundaries classify it as a local stall. With a single chainstate the NORMAL default is unchanged unless -checkevobinding is set. A binding fault is a local error everywhere: state.Error during validation, RPC_INTERNAL_ERROR over RPC, an aborted operation for P2P and the miner, a logged and ended task for queued and scheduled work, and an initialization failure at startup. It never becomes an empty success, consensus invalidity, a peer penalty or a process abort. A new test extends the snapshot chain past DIP3 and V20 activation and the first disk-snapshot period with a registered masternode, and checks that the real MN-list, credit-pool and EHF state it writes stays in its generation and its cache partitions, and that NORMAL rebuilds all of it after the snapshot is rejected and the node restarts. -checkevobinding (default: on for regtest, and forced on in the unit test fixtures) applies the same rule with a single chainstate: an unbound access raises EvoViewBindingError before any snapshot exists, so tests and regtest exercise the bindings everywhere. Test code that drives the node the way a dispatcher does binds like one: NotifyMNListTip delivers a tip notification in the active view, tests and fuzz targets that drive a peer through the test connman bind its turn as ServicePeer does, and test bodies that call into the node directly open an active-chain turn. The interfaces sweep covers getPlatformQuorum. The release note records the externally visible changes: RPC_INTERNAL_ERROR for local Evo errors, the package error, the read-error shutdown, the pruned-data wording, the stall that replaces invalidity on a pruned node, and strict binding on regtest. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…pshot base During dual operation a quorum based at or below the snapshot base is in history the snapshot view does not have, and selecting it throws a local Evo state error. That error escaped BuildVerificationBatch, ended the work round, and dropped every lock FetchPendingLocks had already taken off the queue, so one such lock cost up to 31 others. Catch it per lock instead. The lock is left out of the batch and of the results: it cannot be verified in this run, and its peer is not to blame. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…base as complete RequireSatisfiedScan treated any short height-index scan under a snapshot view based at or above DIP3 as needing the missing history. A type that was not enabled up to the base has no commitments there, so its scan is complete, but it still threw: a CbTx quorum-root check over such a type stalled the snapshot chainstate until promotion. Require the type to be enabled at the end of the missing range or at DIP3 activation. Deployment-gated types stay enabled once enabled, and the types DIP0024 retires are enabled from DIP3 on. The check runs before the EvoDB lock is taken, because deployment state can read EvoDB. getPlatformQuorum reads its window with these walkers. Under such a view, a window that reaches history the view lacks makes the walker throw, so the lookup is UNAVAILABLE rather than INVALID, even for a quorum in the part of the window above the base. A quorum mined below the base is a block of the active chain below any later height, so it stays UNAVAILABLE once a window above the base has left it behind, too. The base is checked first, and the DIP3 ancestor is only looked up when that check fails: a chain that does not reach genesis, such as the testnet-height chain quorum_proofs_tests builds, has no such ancestor. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… and view GUI models poll the wrapped operations, and every failed poll set the misc warning again and notified the GUI. Raise it together with the log line, once per operation and active Evo view. On a node without a snapshot it says that block data was pruned and suggests -reindex. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ction Startup recovery of a persisted snapshot rejection renamed chainstate_snapshot to chainstate_snapshot_INVALID. When an earlier rejection had left that directory behind, the rename failed and startup aborted until the user removed one by hand. Keep the earlier directory, which may be the one the user was asked to report, and durably delete the interrupted one instead. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…is not saved When HandleSnapshotStateMismatch could not sync EvoDB or persist the rejection, the snapshot generation stayed bound and the default Evo identity stayed SNAPSHOT, although the IBD chainstate was active again. For the rest of the run, dispatches bound to the active view read the rejected generation, and so did every operation that had bound it before the rejection: a DKG round waiting at its start for background validation, a message-handler turn waiting for cs_main, a queued event or task. In that case, revoke the generation for the rest of the run (CEvoDB::RevokeSnapshotGeneration). In memory it is retired as a saved rejection retires it: views bound to it no longer resolve, the default identity is NORMAL, the node no longer counts as running two chainstates, and what the generation has not written is dropped. Its records stay on disk, so startup recovery still rejects it, and until then no new generation can be created. A test makes the rejection fail to persist through a new CEvoDB test failpoint while a DKG-style round bound to the snapshot view waits at its start. The round resumes and fails instead of reading the rejected generation, active-view reads see NORMAL, and after a restart startup recovery rejects the generation. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ap work The v3 Evo section carried a fixed rotation horizon (h-C..h-4C) and treated parameter-derived counts as maxima. A carried safety quorum from h-2C reads quarters down to h-5C, the next cycle reads the quarter of h itself, and a quorum index whose DKG keeps failing has carried commitments many cycles back, so the snapshot chainstate either computed different members from too few quarters or refused a base the exporter accepted. Bump EVO_SNAPSHOT_VERSION to 4 and reject v3. PlanEvoSnapshotDependencies() derives, for one type at base B from the carried commitments, the exact set of rotation quarters (S_T), work blocks (W_T) and bootstrap entries: the work blocks of h and N that nothing carried references. The builder, the chain validator and later the completion rebuild all use it. The builder fails when an applicable quarter is missing (the no-store paths of the ordinary computation), and the validator requires exact set equality instead of the old tolerance, plus a quarter only where the ordinary computation stores one. Both refuse a base whose next cycle N reads work data at or below B while some activation input (a buried deployment, the DIP0024 quorum height, or a versionbits period boundary) can still change before N: a type enabled, or switching rotation, only after B would need inputs nothing carries. QuorumSnapshotData gains bootstrap_work (at most two entries, ascending by cycle height); rotation quarters are bounded by 3K+4, historical lists by the per-type 4K+6 / K+2 work-block bounds, and modifiers by their sum. Seeding APIs take the target view token and write inside its open transaction through CEvoDB::WriteSeed, which records each key in the generation's seed manifest: masternode lists as MN_LIST; mined commitments, their height index, rotation quarters, the credit pool and the MNHF signals at the base as BYTE_DETERMINISTIC; score modifiers as SCAFFOLDING. SeedEvoSnapshotState() seeds a decoded section. Under the snapshot view a list lookup at or below the base that misses the carried full lists raises BlockDataUnavailableError instead of walking absent diffs or guessing an empty list. Score modifiers prefer a seeded exact value when the work block's data is unavailable and check it against the block otherwise. Also carried over from the earlier dashpay#7593 head: GetDeterministicMNListHash() and the background base-list marker use the canonical codec hash. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The pool after block X reads the {credit_pool, unlocked} pair of block X - P
(CreditPoolPeriodBlocks()) from that block's body. A snapshot chainstate has no
bodies at or below its base, so constructing the pool of B + 2 already failed
with failed-getcbforblock-read.
v4 gains credit_history: the window entries of [max(0, B - P + 1), B], oldest
first, built from the block bodies. A pre-DIP3 block contributes {0, 0}; an
unreadable or malformed DIP3-active block is an export error. Context-free
validation requires money-range amounts, a checked sum equal to the pool's
latelyUnlocked, and a last entry equal to the pool's balance. The chain
validator requires exactly min(P, B + 1) entries whenever DIP3 is active at B,
zero entries before v20, and an empty base pool while v20 is inactive.
CCreditPoolManager::SeedHistory() stores the entries in the snapshot view, as
snapshot-only scaffolding that promotion never copies into NORMAL.
ConstructCreditPool() resolves the distant block through a view-bound reader:
at or below the base in the snapshot view it uses the carried entry (missing:
unavailable; compared against the body when that is readable: mismatch), never
inserting it into the cache of entries parsed from bodies. Above the base and
in NORMAL it reads the body as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…hainLock checks CheckCbTxBestChainlock() compares a block's coinbase ChainLock with the one its parent's coinbase carries. For the first block above a snapshot base the parent is the base itself, whose body the snapshot chainstate does not have: the ordinary reader then answers "no ChainLock" and B+1 may drop or regress the certified height. The section also had no anchor to the base header of its own. v4 gains the base coinbase (length-delimited, at most 1,000,000 bytes checked before allocating, exactly one canonical transaction and nothing after it) and its index-0 merkle branch (at most 32 nodes). Context-free validation requires a coinbase special transaction larger than 64 bytes whose CbTx height is the list's, and no MN or quorum state without one. The chain validator requires the coinbase exactly when DIP3 is active at the base and proves it through the branch against the base header. VerifyEvoSnapshotBaseBlock() is the load helper: the same proof, then the CbTx checks over a strictly decoded payload (DecodeCbTxPayload()). CSpecialTxProcessor::GetCoinbaseChainlock() returns certified, none or unavailable. In the snapshot view it serves the base from the seeded coinbase and answers unavailable for a v20 block without data; NORMAL keeps the legacy "none". CheckCbTxBestChainlock() uses it in place of the GetNonNullCoinbaseChainlock() fallback and raises BlockDataUnavailableError on unavailable. The miner's CbTx ChainLock choice uses the same reader, so a template built on the base carries the base's ChainLock forward instead of a null one that validation would reject. The asset-unlock status RPC uses it too. The mnlistdiff/QRINFO quorum ChainLock info, which cannot reach the processor without an include cycle, reports a work block without a body in the snapshot view as unavailable (no peer penalty) instead of serving a null signature. GetNonNullCoinbaseChainlock() decodes the same strict way, and Validate() applies the decoder's coinbase size cap. SeedEvoSnapshotState() now takes the special-tx processor, which owns every manager it seeds. Both coinbase readers take a block's status and position in one cs_main scope, and a block this node has but cannot read raises BlockDataReadError instead of reading as "no ChainLock". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…e stage below it The builder exported GetSignalsStage(B), the record already filtered for the block after B. Seeding it as DB_SIGNALS_v2(B) made the snapshot chainstate filter it a second time, and a signal that the deployment table filters at B + 1 (a bit reused by a deployment whose window has not started) vanished from the carried record while NORMAL keeps it, so completion could never agree. Export GetForBlock(B), the raw record, which SeedSignals() writes as DB_SIGNALS_v2(B); GetSignalsStage(B) then filters it for B + 1 exactly as NORMAL does. GetForBlock() becomes public for the builder. Below the base the snapshot view holds no record, and a node that loaded the snapshot without the bodies could not rebuild one, so a versionbits query of an EHF deployment there (the next cycle's context check at the base, StateSinceHeight, getdeploymentinfo) failed. A record is the parent's stage plus the block's new signals, and the stage drops a signal only when a deployment on its bit starts after the signal's block: a rule on the signal alone. So for a block X on the base's chain, the base record's signals mined at or below X, filtered, are X's own stage. The snapshot view answers GetSignalsStage(X) that way, never caching or writing the derived record, and never returns it from GetForBlock(), whose raw record still needs X's body. A block off the base's chain (a side branch forking below the base) does not inherit the base's signals: it is rebuilt from its own branch on top of the derived record of its fork point, or is unavailable. A view that carries no base record (a snapshot without an evo section) rebuilds from the blocks as before. The snapshot view also never writes any signal record at or below its base other than the seeded one, which promotion would find overlapping NORMAL's, and SeedSignals() refuses a signal mined above the base. Versionbits evaluates the signal height after the always- and never-active returns, so a deployment that cannot change state never reads it. The exporter runs outside any block transaction, where a rebuilt record is held only in the cache; it exports that record all the same. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…napshot view A v20 score modifier commits to the work block's coinbase ChainLock. When the block cannot be read, the ordinary calculation silently uses the block-hash modifier instead, and so did the prediction path (ComputeQuorumMembersFromWorkBlock), even where the snapshot carries the exact value. In the snapshot view that computes different members than the network without any error. One resolver, keyed by (type, work block), now serves GetHashModifier(), quarter decoding and the prediction path: it returns the seeded value or the block's own, checks them against each other when both exist (SnapshotStateMismatchError), and raises BlockDataUnavailableError when it has neither, in every view: NORMAL no longer guesses the block-hash modifier for a work block it pruned. A work block the node has but cannot read raises BlockDataReadError in either view; the resolver and the exporter's ExactWorkModifier() read its status and position in one cs_main scope. llmq::utils::GetQuorumModifierForWorkBlock() exposes the resolver. A quorum object computed its members eagerly, so without that fallback a pruned node could no longer build one for an old quorum, and would stall on an MNHF signal it signed: LLMQ_400_85's active quorums reach further back than a pruned node keeps. Where NORMAL cannot resolve the work block's modifier (WorkBlockModifierUnavailableError), a quorum is now built from its mined commitment alone. It verifies signatures with the commitment's key, and CQuorum::Members(), which replaces the public member vector, raises BlockDataUnavailableError for it, as do IsMember(), IsValidMember() and GetMemberIndex(), so nothing reads a guessed or empty list. Such a quorum takes no verification vector or contributions from QDATA, is not queued for key-share warming, and has no contributions for the old-data cleanup to keep. Commitment verification and quorum rotation still need the members and stay unavailable without them. The quorum health figures of the GUI and quorum listextended count such a quorum's commitment member slots. A release note describes the change for pruned nodes. The snapshot view raised unavailable for any quarter missing at or below the base. Only an applicable one (rotation and the type enabled at that cycle) is an input the ordinary computation stored; a missing inapplicable quarter keeps the legacy break there, as NORMAL does, so a cycle near rotation's start still reconstructs. Both the resolver and the exporter compute a v20 work block's modifier from its data through llmq::utils::GetWorkBlockModifier(). The member-computation fixtures live in evo_snapshot_tests.cpp, so the tests do too. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ScanQuorums() and ScanCommitments() read the mined-commitment index. In the snapshot view that index holds only the carried commitments at or below the base, so a scan reaching past them returned a short or (with rotation) a different vector, and quorum selection for a ChainLock or an asset unlock silently disagreed with the network. A carried scan sequence (the type's history without rotation, one quorum index with it) ends either in END, when the canonical selection carries fewer records than it takes (K, or two per index), or in UNKNOWN. A missing index is END; a rotating type without rotation at the base has an empty indexed family. TraverseScanSequences() replays the ordinary selection over such sequences (newest first, or rank by rank in ascending index order) and proves the identical vector, including a legitimately short history, or reports that an UNKNOWN end was reached first. Export and load apply one gate: every ChainLock verification scan for the heights B + 1 may certify (from the base's certified height, or from genesis when it certifies none; none at all without v20 at B + 1) with n = a and SIGN_HEIGHT_OFFSET, and the Platform asset-unlock scan at B with n = a + 1, must be proven from the section; the exporter also compares the proven vectors with its full index. Coverage only grows with the cutoff for a fixed type and count, so only the first start of each enablement context is proven. Bases that fail are refused. At runtime, the snapshot view's scans call CQuorumManager::ProveScan() over the view's commitment index, whose ends are recorded locally at seeding (ScanCoverageRecord, never on the wire). Every request proves its own prefix: cached prefixes are proven ones, a shorter cache entry is re-proven from the original cutoff instead of continued, there is no keepOldConnections warm-up to fail a covered smaller request, and an uncovered prefix raises BlockDataUnavailableError, as does a proven quorum this node fails to build. Records above the base extend the sequences. CQuorumBlockProcessor::SequenceEnd() is the one answer to how a view's history of a scan sequence ends, and both ProveScan() and the height-index primitives' short-scan gate (RequireSatisfiedScan) read it. It is END: - in NORMAL, and in a snapshot view whose base precedes DIP3, which hold every commitment mined on their chain; - for a family the type never writes. A type is indexed exactly when it rotates, and a rotating type is enabled exactly when rotation is at its cycle base, so a rotating type read non-indexed before DIP0024 (a base before activation) is empty; - where the seeded coverage says so: a type the payload omits (disabled at B with no history, e.g. one enabled only later), an under-filled type, or a quorum index that never formed one. A short scan ending there is an answer, so B + 1 reads what NORMAL reads. Anywhere else it stalls, as a need deeper than the payload carries does. END rests on the carried counts, which only the mandatory evo-hash pin binds. RequireSatisfiedScan keeps the header check that a type enabled at neither end of the missing range has nothing in it; both checks now run with the EvoDB lock released. The shared quorum and commitment scan (ScanMined) and ProveScan() normalize the start with one NormalizeScanStart(), and in the snapshot view the shared scan takes the proven path for both result types. Lookups by quorum hash follow the same rule. An MNHF signal may be signed by any historical quorum of its type. In the snapshot view HasMinedCommitment raises BlockDataUnavailableError (the chainstate stalls) for a quorum at or below the base without a commitment, unless headers and the carried sequences prove it was never mined: not on the base's chain, not a quorum height of an enabled type, or no older than the oldest carried record of an ending or newest-first sequence. Such a miss stays a plain miss, so a block relying on that quorum is still invalid. RequireSatisfiedScan's rule is ShortScanIsComplete(). getPlatformQuorum reads its window with these height-index walkers, so a sequence whose recorded coverage ends lets a hash that is no block of the active chain below the height be INVALID, and one whose end is unknown makes the lookup UNAVAILABLE. getPlatformQuorum over a seeded generation: carried commitments are found at the base; a window reaching past the oldest carried one stays unavailable for carried quorums in it, quorums NORMAL would find there and unmined ones alike; a window full again from commitments above the base, or a history whose seeded coverage ends, makes an unmined hash invalid once a ChainLock anchors it, while a carried quorum that has left the window stays unavailable; after promotion NORMAL decides. Promotion, also interrupted and resumed, copies no seed-only record (modifiers, credit window, base coinbase, scan coverage) into NORMAL. With the quorum keys, the key-only quorum test also checks that a pruned node accepts an MNHF signal its quorum signed. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
dumptxoutset builds the evo section from the dumped chainstate's own view at the same cs_main-pinned point as the coins cursor, appends it after the last coin as [marker][EvoSnapshot], and reports a summary of it. A base the section cannot represent (for example a needed rotation quarter is missing, or the ChainLock scans cannot be proven), or a section failing the chain checks a loading node applies, is an RPC error. PreflightEvoSnapshot() is the one chain check export and load share: ValidateEvoSnapshotAgainstChain() and, once DIP3 is active at the base, VerifyEvoSnapshotBaseBlock(). It reads the calling thread's Evo view, so the exporter runs it on NORMAL and the loader in the generation it seeds. Snapshot load decodes a trailing section and requires it to end the file; a UTXO-only file still loads. The section is not used yet. Until a later commit compares the whole section at completion, a DIP3-active snapshot is never validated or promoted: completion returns the new EVO_DATA_UNAVAILABLE, which startup treats like a skip. feature_assumeutxo_dash.py dumps a rotating-quorum chain at a base before its own cycle's mining window and at the block before the next cycle, and checks the carried rotation cycles and bootstrap entries against the dependency rule, the credit-pool window length, the base coinbase, and that the reported hash is the SHA256 of the section bytes in the file. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…data A DIP3-active snapshot base now requires the evo section and a non-null pinned evo hash that the decoded section matches, and a non-null pin requires a section. The pin comes only from chainparams or, on regtest, from the new -assumeutxodata=<height>:<hash_serialized>:<evo_hash>:<nchaintx>:<blockhash> option, never from the file. Each such entry is bound to its base block, and the option authorizes nothing on other networks. A pre-DIP3 UTXO-only snapshot loads as before. EvoSnapshotTestSetup is a deterministic DIP3/v20 chain with four fixed-key masternodes whose base at 219 is pinned through -assumeutxodata. The pin is the SHA256 of the section as a test-side assembler writes the format table field by field, and the section holds what the fixture implies (its masternodes, quarters and credit window). A null pin, a UTXO-only file, and a section with a substituted field that every later check accepts are each refused before any generation is created. The honest snapshot activates, and with background validation already at its base it is still not validated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> # Conflicts: # src/test/evo_snapshot_tests.cpp # src/test/util/masternode.cpp
…publish After the pin check, snapshot load seeds the section into the new unpublished generation and, in that generation's view, runs the chain checks export runs (PreflightEvoSnapshot(): exact equality with the planned dependency sets, provable ChainLock and asset-unlock scans, the credit-pool window, and the anchor to the base header through the coinbase merkle proof and CbTx). Deployment state at or below the base then comes from the carried signal record, never from history a node with only the headers lacks: such a node could not load a base whose next cycle reads work data at or below it. Load then dry-runs the quorum member computations the snapshot chainstate may need at or right after the base from the seeded state alone: every carried quorum, the base's cycle, and the next cycle when its work block is at or below the base (refused if a v20 work block's members cannot be computed). Once DIP3 is active the snapshot-side base MN-list marker is the carried list's. The active chainstate keeps running whenever activation releases cs_main. Preparation therefore first flushes it, coins before Evo state, so the NORMAL records it then commits never reach disk ahead of the coins, and registers the base before releasing cs_main: until the switch the active chainstate records the base's MN list as the background chainstate would. Activation then waits, at most a few seconds, for the dispatch turns of other threads to end (so its caller must not hold cs_main), and switches in one cs_main hold: the mempool must still be empty, the active tip must be the base or have less work than it (an equal-work sibling at the base height would be loaded as the background tip at the next startup, whose completion would then reject the snapshot), and no block of the base's chain may be invalid or conflict with a ChainLock; only then are the generation published (with the markers, the configuration fingerprint and the encoded section, retained in the lifecycle metadata), the base recorded in the snapshot directory and the block index faked, and the snapshot view told its tip before it becomes the default. A turn still running in NORMAL finishes there. A turn counts itself without a lock; one that ends takes the waiter's mutex and notifies only while activation waits. Every failure before the switch, from opening the snapshot's coins database on, undoes the generation, the caches and the directory; none leaves faked block-index state behind. Rejection, completion and cleanup flush each chainstate's coins, checked, before syncing its Evo state. A local Evo state error while populating (state this node cannot derive or read) refuses the snapshot as bad input does, instead of escaping activation. On restart, an unpublished generation is collected as before; a published one is used only while its retained section still decodes and matches the pin of its base. evo/snapshot_chain.cpp joins the kernel sources, since validation now calls it. A DIP3-active snapshot is still never validated or promoted. The unknown-version warning check, where it needs Evo state the chainstate lacks, is skipped instead of escaping block connection. The "snapshot state unavailable" warning no longer takes the single misc warning slot. Each stalled chainstate and each failing interfaces:: operation has its own; a stall's stays with its chainstate (at completion it says to restart), an operation's goes on its next success. Setting or clearing one notifies the GUI only when the warnings change, so an operation the GUI keeps polling while it fails notifies once. A simulated restart in the tests drops the Evo view caches, as a real one does: their tips point into the block index it unloads. The failed-open case meets a leak in CDBWrapper's constructor: it throws before its destructor could free the LevelDB cache, filter policy and logger GetOptions allocated. LeakSanitizer ignores those allocations. Tests, on the deterministic DIP3 fixture, and on a variant whose quorums really form (commitments signed with the fixture's operator keys and a quorum key it keeps, ChainLocks and asset unlocks signed with that key); a node "with only the headers" also starts with an empty NORMAL EvoDB: - a node with only the headers loads the snapshot and connects, across a restart, the blocks a synced node mined up to B+P+2, through the next cycle; members of the base and next cycle match the synced node's; - such a node loads the section a synced node dumps at every base of a 24-block cycle, including those inside the next cycle's work window; - a work-block body the node has but cannot read refuses the load cleanly; - at the block before the next cycle, the bootstrapped next cycle's members are predicted from the seeded state and match the synced node's; - a crash after seeding, before or after publication, leaves no live generation after restart, and NORMAL carries on; - right after activation the snapshot view serves the base's MN list as its tip list; - the switch is refused when the active chainstate meanwhile took a mempool transaction, the base's chain became invalid, the chainstate moved to a sibling of the base with the same work, or it went past the base, and a snapshot coins database that fails to open fails the load; each time the node is left as before, and the load then succeeds at the base; - the switch waits for a dispatch turn that ends within the bound; one that outlives it carries on in NORMAL without failing or stopping the node; - a load refused by its dry run on a node with only the headers marks no block assumed-valid and fakes no transaction count; - a crash right after preparing restarts without an Evo/coins mismatch, although the chainstate had connected blocks since its last flush; - a carried credit-window record that has gone missing stalls the chainstate with a local error, without marking the block invalid, and raises a warning that leaves others in place; - a retained section that no longer matches the pin is refused at startup; - with real quorums, the next cycle's signed commitments, verified against members from the carried quarters (including the base cycle's), and the ChainLocks in every coinbase are accepted, and stay in the snapshot view, for a base right before the next cycle and for one five blocks after its own cycle, before the next cycle's work block; - each quorum cache the snapshot chainstate warms at or below the base (quarters, members, quorums, quorum and commitment scans, mined-commitment blocks, commitment indexes, CbTx commitment hashes, the remembered coinbase ChainLock) stays in its view: NORMAL finds nothing there or cannot tell until it has connected those blocks, then answers as the synced node did, also when the snapshot view holds a different commitment; - with a rotating index whose DKG fails for ten cycles, the members of its ten- and eleven-cycle-old quorums are computed at activation, with cold caches, as the synced node's; the ten-cycle-old quarter, only an output, is not kept, and without a quarter they need the members are unavailable; - on a node without the base body, the block after the base, building on the real ChainLock the carried base coinbase holds, connects; - withdrawals at exactly the limit, before the base and across a restart and the window edge after it, are accepted; on both sides of that edge anything above the synced node's limit, and a carried index, are rejected; - a rejected snapshot's commitments are rebuilt by NORMAL from the blocks; - NORMAL's MN-list cache stays bounded during a long background sync; - a carried record missing for a reorg or ChainLock enforcement stalls both (a local Evo state error, with the warning) without marking anything invalid, until a restart; - background validation reaching the base validates nothing yet; - an unknown bit active, and warned about, on the synced node: once that node, still holding NORMAL's warning-cache states, loads a snapshot without the bodies below its base, the snapshot chainstate computes the states itself from the headers and the carried signal record, and warns too. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Completion now rebuilds the entire evo section from the state background validation derived and requires its hash to equal the retained section's, which must still equal the pin. This replaces the interim refusal to validate a DIP3-active snapshot. The rebuild and the shared preflight report why they failed: missing input, local corruption, an internal error, or a disagreement (at export, where nothing is compared, a base the section cannot be built for). Only a disagreement rejects the snapshot (EVO_STATE_MISMATCH). Missing input (EVO_DATA_UNAVAILABLE) leaves it neither validated nor rejected, with a warning that says the next restart retries. Data this node has but cannot read or finds inconsistent (a retained section that is gone, does not decode or no longer matches its pin, which startup checked; an unreadable body; EvoDB best blocks that differ from their coins tips) stops the node with EVO_LOCAL_FAILURE, and an internal error (including a missing record of the background chainstate's list at the base) with EVO_INTERNAL_ERROR; neither rejects the snapshot, and startup then fails with the same advice instead of retrying at every restart. The advice says that -reindex-chainstate discards the snapshot. A coin of the background chainstate that cannot be read, so that its UTXO set hash cannot be computed, is local corruption too. Upstream rejects the snapshot there, which would leave the node on the coins it cannot read and tell the user the snapshot was invalid; this is a deliberate divergence. A snapshot still in use that cannot be rejected stops the node rather than being kept. The inputs only block bodies provide (the v20 work-block modifiers, the credit-pool window, the base coinbase and its branch, and the base's credit pool, which folds in blocks back to the last pool on disk) are captured as the background chainstate connects those blocks, in its block transaction, or at activation for blocks it has already connected; activation refuses a base whose such body is gone. The capture plan refuses a credit window reaching below genesis, since the chain checks run only after it. The rebuild prefers the captures over the bodies. A local Evo error while capturing the base pool stalls the background chainstate as other local Evo errors do. Capturing follows the registered plan, so a block the still-active chainstate connects between preparation and the switch is captured too. Since promotion repeats completion at the next startup, the captures stay until promotion; they are also dropped on rejection, when activation fails (after flushing that chainstate's coins), and at startup when no generation is live or the one left never activated (after a crash before or after publication). No prune lock is kept for them: it would not cover what either chainstate reads, and pruning is to be refused while a snapshot is in use. The MN-list work captures and the old comparison block that the design removes do not exist on this base; the existing base MN-list marker comparison is kept. Tests, on the deterministic DIP3 fixture, with sections pinned as they are: - a mutated currentLimit, credit-pool index range, signal height, rotation quarter bit or credit-window entry passes every load gate and the snapshot chainstate's own blocks, and is rejected only at completion, with no block marked invalid; a wrong modifier is, on a node without the work-block bodies at load; - a corrupted capture is a mismatch; a missing one whose block is gone is missing input with a warning naming the retry, after which completion succeeds once the body is back; activation refuses a base whose connected input body is gone; with real quorums, completion succeeds from the captures alone once every body at or below the base is gone and the caches are cold, both for those activation wrote on a synced node (a withdrawal in the window) and for those the background chainstate of a node with only the headers wrote as it connected the blocks, across a restart; - the honest run on a node with only the headers completes across a restart and dropped caches; the background chainstate announces none of the MN-list changes it connects and its ForceSignalDBUpdate writes only its own view; the captures last until promotion; NORMAL consumers read the promoted MN list and credit pool; - a published generation is refused after a V24 min_activation_height change, naming the generation, base, phase and recovery and saying the changed part is unknown, with nothing changed on disk; so is a promotion interrupted mid-merge, whose failing recovery names the way out; both resume under the original configuration; - blocks the still-active chainstate connects between preparation and the switch, through the base, are captured and its base list recorded, so completion succeeds; - a crash right after a refused switch restarts without an Evo/coins mismatch, although the chainstate connected blocks meanwhile; - an unreadable body, a changed retained section and mismatched best blocks stop the node as local corruption, an internal error and a missing base list record as internal errors, none rejecting the snapshot; startup then fails the same way, fails as local corruption on an unreadable background coin, and promotes once the data is whole again; - with real quorums: a carried safety commitment with another public key, signature or mined block in the same window is rejected only at completion; the honest section completes, the next cycle's mined commitment is NORMAL's after promotion, and a quorum-signed signal for an unused bit mined at the base is carried raw and kept by promotion; - a crash before or after publication leaves no captures after restart; - a chainstate stalled on a missing carried record keeps its warning past completion, and after the restart that promotes the snapshot the warning is gone and the stalled block connects. The completion warning and its clear raise the GUI alert through kernel::Notifications::evoStateWarningChanged(), only when the warning changes. The alert counts in chainstatemanager_evo_snapshot_completion_uses_the_captures pin one alert for the warning and one for its clear: they are parity checks, not tests that fail without a fix. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
This pull request has conflicts, please rebase. |
Issue being fixed or feature implemented
This is the third Evo-state PR of the reworked AssumeUTXO series. It is stacked on #7593 and #7887, which are stacked on two open PRs: #8145 and #8049 (#8067 and #8069 have merged). The stack is those two, #7887, #7593, this PR, then two more drafts. Against
developthis PR shows 33 commits (11 from the two PRs, 12 from #7887, 6 from #7593); only the top 4 belong to this PR. It stays a draft until the PRs below it merge.Update (2026-11-09). Rebased onto develop
6271b740e99d, after #8071, #8073 and #8067 merged. #8067's two commits dropped out of the stack as already upstream (same patch-ids). bitcoin#28218 (in #8071) movesIsInitialBlockDownloadto theChainstateManager; the stack now callsm_chainman.IsInitialBlockDownload(), as upstream's AssumeUTXO code does, and every changed caller previously asked the active chainstate, so behaviour is unchanged. At the new heads, every commit builds (gcc-11--enable-werror), the targeted unit suites pass at each layer tip, and fork CI passed on this head (run 42681480205).Update (2026-11-10, rebase). Rebased onto develop
041e450769b, after #8070, #8081 and #8083 merged, with #8069's rebased commits underneath. #8070 made four changes the stack had to follow:llmq/options.hintollmq/utils.handllmq/options_args.h. The stack's includes switch to match.Params()tom_chainman.GetParams()inllmq/quorumsman.cpp. The stack keeps the chainman lookup on the lines it moves.CGovernanceManagerconstructor a data-directory argument. Two new test constructions pass it.node/interface_ui.hfromvalidation.cpp(kernel: Remove util/system from kernel library, interface_ui from validation. bitcoin/bitcoin#27636). Because of this, the Evo-state warning now reaches the GUI through a newkernel::Notifications::evoStateWarningChanged()hook. Its node override callsuiInterface.NotifyAlertChanged(), as the direct call did before;-alertnotifyis still not run for this warning. From feat: emit, pin, seed and verify the v4 evo snapshot section #7601 on, validation raises it only when the warning text changes. Two existing test scenarios now count these alerts.The commit count is unchanged. Every changed commit builds, the targeted unit suites pass at the #7887, #7601 and #8079 tips, and the kernel library still links on its own. All PR checks passed on the pushed head
75e85c275bf0, and fork CI passed on it too (run 42865397181), including the ASan, TSan and multiprocess jobs.Update (2026-11-10, second rebase). Rebased onto develop
9c981d925b4, after #7939, #7815, #7678, #8085, #8088 and #8092 merged, with #8069's rebased commits underneath. Every commit replays without a conflict. One test needed a change: #8085 adds a unit test that sendsQFCOMMITMENTmessages from the test body, so the commit that turns-checkevobindingon in the unit-test fixtures now opens an active-chain view for it, as it already did for that file's other tests. At the #8079 tip the build and every unit suite pass. So do the AssumeUTXO functional tests,feature_loadblockandfeature_remove_pruned_files_on_startup, both with default settings and with-blockcompression=3(#7939 leaves compression off by default), andfeature_pruningandrpc_rawtransaction. All PR checks passed on the pushed head96525ccb91a9, including the ASan, TSan and multiprocess jobs.Update (2026-11-11, third rebase). Rebased onto develop
b4b4d852e34, after #8082 and #8084 merged. The only conflict was insrc/init.cpp: develop's bitcoin#26296 backport drops the/* Continued */log markers, including one in the startup repair block that #7887 moves intoFinishImportedStartup(). The block stays moved and loses the marker. The one marker the stack added itself, on the refusal to activate a snapshot while an earlier rejected one is still on disk (#8078), is gone too, and every log call the stack adds ends its format with a newline, as the new clang-tidy check requires. #7887's GETDATA changes merge onto bitcoin#27675's rewrite of that path unchanged. The commit count is unchanged. At the #8079 tip the build and every unit suite pass, and so do the AssumeUTXO functional tests,feature_loadblock,feature_remove_pruned_files_on_startup,feature_pruning,rpc_rawtransaction,mempool_reorg,mempool_limit, and the P2P tests on the paths bitcoin#27675 changed (p2p_getdata,p2p_tx_download,p2p_invalid_txandp2p_filter).Update (2026-11-11, fourth rebase). Rebased onto develop
b2172a9cf8a, after #7623, #8076, #7975, #7835 and #8052 merged. It also takes #8049's new revision (e392e45): a DKG phase thread now checks for a stop request first, and while background validation is incomplete it waits only at round start. The commit count is unchanged. #8052 applied without conflicts; two develop changes needed adapting:chainman.m_options.datadir; here that change lands in theRestartChainstateManager()helper this stack factors out (feat: emit, pin, seed and verify the v4 evo snapshot section #7601). refactor: Add [[nodiscard]] where ignoring a Result return type is an error bitcoin/bitcoin#27774's[[nodiscard]]onApplyArgsManOptions()sits next to the newLegacyIndexesEnabled()declaration (feat: load AssumeUTXO snapshots with loadtxoutset and validate them in the background (regtest only) #8078).ProcessBlock()and intoConnectTip(), after the tip update and for the active chainstate only. When a connect fails,ConnectTip()now rolls back the Evo transaction and drops the failed block's cached masternode list.-checkevobinding.Update (2026-11-11, fifth rebase). Takes #8049's newer revision (
5aa5ad6), which changes only its unit test: instead of a 200 ms timeout, the test now waits for the DKG handler's "waiting for snapshot background validation" log line. Apart from context lines next to that test, the stack's own commits are unchanged.All PR checks passed on the pushed head
e05943fe1193, including the ASan, TSan and multiprocess jobs.At the #8079 tip the build, every unit suite and
test_dash-qtpass, and so do the AssumeUTXO functional tests andp2p_platform_ban. One develop merge earlier, on the same patches,feature_llmq_rotationandfeature_llmq_signing(with and without--spork21) passed. Before #8049's new revision was taken, the functional tests listed for the third rebase passed too, along withwallet_assumeutxo,wallet_backup,wallet_basicandwallet_importdescriptors.Update (2026-11-11, sixth rebase). Rebased onto develop
7d85e330840, after #8095, #8105, #8080, #8097 and #8094 merged. It also takes #8049's newer revision (ec71e73), which again changes only its unit test and a header comment: the in-round check now runs the wait on another thread from Idle, so only the snapshot check can end it. Every commit replays without a conflict. #8095 changes how the miner picks its best ChainLock, in the same function where this stack reads the previous block's coinbase ChainLock (#7593). The two changes are independent, and the stack's commit applies unchanged. At the #8079 tip the build and five runs ofvalidation_chainstatemanager_testspass. So do the AssumeUTXO functional tests,wallet_assumeutxo,feature_llmq_chainlocksandfeature_governance.Update (2026-11-11, seventh rebase). Rebased onto develop
ce9ef663c9e, after #8104 merged. #8104 takes a block's final commitments out of the mineable pool only once the block has been accepted, instead of inProcessCommitment(). Three commits needed adapting. InProcessCommitment()this stack keeps its per-view mined-commitment cache and drops the pool removal, as #8104 does (#7887). InRollforwardBlock()the removal runs after this stack's snapshot-input capture, which can still fail, so a block that fails there keeps its commitments in the pool (#7601). The third change is a reflowed declaration. As before #8104, the removal runs for blocks that either chainstate connects, and it reads no Evo state. A block that stalls on missing snapshot data now also keeps its commitments in the pool. Each adapted commit compiles on its own. At the #8079 tip the build passes, and so dollmq_blockprocessor_tests,validation_chainstatemanager_tests,validation_chainstate_tests,feature_llmq_dkgerrors,feature_llmq_rotation, the AssumeUTXO functional tests andwallet_assumeutxo.Update (2026-11-11, eighth rebase). Rebased onto develop
95cfb5b8f2a, after #8110 merged. #8110 replaces functional casts in Dash code withstatic_cast. One commit needed adapting: the commit that makes work modifiers exact (#7593) deletes the block-basedGetNonNullCoinbaseChainlock()overload, in which #8110 had changed a cast, so the deletion stands. Every other commit applies unchanged, and a source check found no new C-style or functional casts in the stack's Dash files. At the #8079 tip the build passes, includingdash-qt, and so doquorum_proofs_tests,llmq_commitment_tests,evo_cbtx_tests,coinjoin_tests,evo_snapshot_tests,test_dash-qt,feature_llmq_chainlocks,feature_llmq_rotation, the AssumeUTXO functional tests andwallet_assumeutxo.All PR checks passed on the pushed head
572ec037526f, including the ASan, TSan and multiprocess jobs.Update (2026-11-12, ninth rebase). Rebased onto develop
c68d3cd81fc, after #8116, #8100, #8112, #8119, #8114, #8120, #8121 and #8127 merged. One commit needed adapting: #8100 adds a governance reorg unit test, and this stack's commit that rejects unbound Evo reads (#7887) now opens an active-chain turn at the start of that test, as it does for the file's other tests that call into the node. Without it the test fails withEvoViewBindingErrorunder-checkevobinding. Every other commit applies unchanged. #8121's ChainLock check inCreateNewBlock()andgetblocktemplateruns before any Evo read, and #8119'sPeriodicStats()runs inside the stack's scheduler binding. At the #8079 tip the build passes, includingdash-qt, and so dogovernance_vote_processing_tests,llmq_chainlock_tests,spork_tests,coinjoin_inouts_tests,validation_chainstatemanager_tests,test_dash-qt,feature_governance,feature_llmq_chainlocks,feature_stats,interface_bitcoin_cli,mining_basic, the AssumeUTXO functional tests andwallet_assumeutxo. #8099, which merged after this rebase, touches no file in this stack, and a trial merge passesinterface_restandrpc_deprecated.All PR checks passed on the pushed head
aa71eb53bfd3, including the ASan, TSan and multiprocess jobs.Update (2026-11-13, tenth rebase). Rebased onto develop
5c34dcfbf79, after #8099, #8135, #8130 and #8131 merged, and onto the reworked #8066 (db5aac0) and #8069 (b8e3318); #8049 is unchanged.ScanMinedCommitments*scans,CDBIterator::HasErroror the table-corruption test helper.CDBIterator::HasErrorin a new commit (feat(dbwrapper): report LevelDB iterator read errors), because its generation walkers need it. The corruption helper moved intoevo_db_tests.cpp, its only user.scan_mined_commitments_reports_missing_history). The scan-coverage proofs (TraverseScanSequencesand its tests) are unchanged.getPlatformQuorumnow returns UNAVAILABLE instead of FOUND for a quorum in the readable part of a window that reaches history the view lacks.interfaces_testsrows changed to match.CBLSBatchVerifierorCBLSWorker. No stack path runs either inside a scheme override or for the background chainstate.test_dash-qt, and the AssumeUTXO, governance, ChainLock, stats, CLI and mining functional tests.HasErrorcommit and its first caller compile at their own positions, and aHasError-always-false mutant failsevo_db_tests.All PR checks passed on the pushed head
92c43f5ad184, including the ASan, TSan and multiprocess jobs.Update (2026-11-13, eleventh rebase). Rebased onto develop
01023ded78b, after #8141, #8108, #8111, #8113, #8115, #8117, #8118, #8122 and #8069 merged. #8069 merged atb8e3318, the revision this stack already carried, so its commit leaves the bottom of the stack and nothing above it changes; #8049 and #8066 are unchanged. Every commit replays without a conflict. #8113 added a CoinJoin unit test,coinjoin_maintenance_runs_for_every_wallet, that callsDoMaintenancedirectly rather than through the scheduler, so it tripped-checkevobinding. "feat(evo): reject unbound Evo reads during dual operation" now binds the active Evo view in that test, as it already does in the other tests that drive the node the way a dispatcher does; in the node, CoinJoin maintenance already runs inside the scheduler's binding. Apart from those two test lines,git range-diffshows all 66 stack commits and the four #8049 and #8066 commits identical. At the tip the build has no warnings, every unit test suite passes, and so do the AssumeUTXO, ChainLock, CLI, mining, CoinJoin RPC, address-index,rpc_blockchainandrpc_masternodefunctional tests.All PR checks passed on the pushed head
c755259b712b, including the ASan, TSan and multiprocess jobs.Update (2026-11-14, twelfth rebase). #8145 replaces #8066. Instead of a per-thread override of the process-wide BLS scheme flag, it removes the flag and takes every scheme from the data or the block. The stack now sits on #8145 (
537d8a7, ondevelopd2fb5e7) and #8049. #8078 is the first layer that can run a snapshot chainstate next to a background one, so it needs one of the two fixes; the layers below it were written against the flag. Seventeen of the 66 stack commits changed. Four differ only in context, one of them the fuzz RPC lists in the bitcoin#27596 merge, which keeploadtxoutsetandgetchainstatesbeside develop's new entries. One keeps both sides of a regtest checkpoint conflict. The other twelve drop what existed only for the flag: the scheme guards inConnectTipandDisconnectTip, the scheme restore before anevo::LocalStateErroris rethrown, and the scheme override inForceSignalDBUpdate. They also take #8145's scheme-free signatures for CbTx decoding,GetNonNullCoinbaseChainlock,VerifyEvoSnapshotBaseBlockand the work-block modifier, whose hash now uses #8145's expression. Two tests changed: the mid-connect rejection test, still run with v19 activating above the snapshot base, now checks that the background chainstate takes over instead of checking the flag, and the work-modifier test now covers the mined signature, because a pre-v19 legacy coinbase ChainLock cannot exist (it needs v20). The commit that turns-checkevobindingon in the unit-test fixtures also binds three tests that #8145 adds and the CoinJoin queue test that develop gained in #7955, and one commit's edit to a test #8145 deletes is gone. No commit was dropped. Every layer tip builds with no warnings and passes #8145'slint-bls-scheme.py. Every unit suite passes at the #7887 and #8079 tips. At the #8079 tiptest_dash-qtpasses, and so do the AssumeUTXO, ChainLock, asset-lock, EHF, ProTx-version, quorum-RPC andrpc_dumptxoutsetfunctional tests and the functional tests develop changed since the last rebase, apart from the ZMQ test, which needs a ZMQ build.All PR checks passed on the pushed head
88ef72a0083a, including the ASan, TSan and multiprocess jobs.#7593 defines the v4 Evo section, how it is built, and how it is validated against the chain. This PR wires it into the snapshot lifecycle:
dumptxoutsetemits the section;Two independent designs (Claude Opus and GPT) were reconciled into one design, which this PR implements. One requirement drives it. Anything in the section that isn't committed by the pinned Evo hash, headers or CbTx is untrusted. A snapshot node must accept and reject exactly what a fully validated node does, and it must stop rather than guess when it can't decide. Completion then checks the whole section independently before promotion.
What was done?
feat(rpc): emit the v4 evo section in dumptxoutsetdumptxoutsetwrites the v4 Evo section after the coins.feat(validation): require a matching evo pin; add regtest -assumeutxodata-assumeutxodata=<height>:<hash_serialized>:<evo_hash>:<nchaintx>:<blockhash>option lets tests pin their own snapshots. It is rejected on other networks.feat(validation): seed into an unpublished generation, dry-run, then publishdumptxoutsetand load run one shared preflight. Load runs it after seeding, in the unpublished generation's view, andActivateSnapshotturns a local Evo error into a clean refusal. Loading is tested at every residue of a 24-block cycle.cs_mainbefore it is first released. Publication waits for in-flight turns with a bounded hand-off that holds nocs_main, and an overtaken turn finishes in its own view. At the switch the snapshot's tip is delivered to the Evo tip consumers. The switch refuses a tip that is not the base but has at least the base's work. Failed preparation restores caches, directories and plans.feat(validation): rebuild and compare the full evo section at completionSnapshot-data unavailability is never turned into block invalidity or a peer penalty.
Deferred to the next layer (
loadtxoutset)loadtxoutset.Carried suppression
test/sanitizer_suppressions/lsangainsleak:GetOptions. A throwingCDBWrapperconstructor never frees whatGetOptions()allocated; the new failed-open test is the first to drive that path under ASan. Upstream has the same pattern (bitcoin#22592 is open). A fix exists but is not filed, and removing or accepting the suppression is a condition for leaving draft.How Has This Been Tested?
Linux x86_64 containers, gcc-11.5
--enable-werror(release configuration, Qt, sqlite, no BDB). The build, unit, Qt and functional runs were made on7cba3d1c15, whose tree differs from this head (d2e3675bd6b9) only by the LSan suppression file, which no build or non-sanitizer test reads. The ASan check, lint and cppcheck were repeated on this head.test_dash-qt163 passed, 2 skipped.make checkwith CI's ASan/UBSan flags (clang-19,-Wthread-safety -Werror) reports no finding, and 154 of 154 unit-suite logs say "No errors detected". Six Evo and chainstate suites pass under TSan with 0 warnings, including the turn-registry tests.rpc_wipewallettxes.py, passes alone and in 30 of 30 sequential runs, and the stack does not touch it.feature_assumeutxo_dash.py,rpc_dumptxoutset.py,feature_utxo_set_hash.py,feature_coinstatsindex.pyandfeature_asset_locks.pypass.snapshot(h)with a real next-cycle commitment;bad-cbtx-null-clsig,bad-cbtx-older-clsig, and a valid block accepted);ForceSignalDBUpdate, and the reorg and ChainLock-enforcement stall paths;utxo_snapshotfuzz target aborts in its own initialization on develop code, so no fuzz result is claimed.Breaking Changes
Loading a post-DIP3 snapshot now requires a matching Evo pin. No network has one yet, so outside regtest with
-assumeutxodata, post-DIP3 snapshots can't be loaded.Checklist:
🤖 Generated with Claude Code