Problem

When handleReorg falls back to reset() — either because the reorg is too large, contains an invalid block, or subtreeProcessor.Reorg() returns an error — two distinct bugs cause the block assembly to end up in an incorrect state after the reset completes.

Bug 1: Assembly transactions silently lost after reset

SubtreeProcessor.reset() clears the in-memory assembly (chainedSubtrees, currentSubtree, currentTxMap) without first marking those transactions as NOT on longest chain in the UTXO store.

The unmined iterator used by loadUnminedTransactions() filters by WHERE unmined_since IS NOT NULL. Any assembly transaction whose unmined_since is NULL in the UTXO store — which happens when a competing fork's BlockValidation processed it, inserting it with UnminedSince=0 — is invisible to this scan. The transaction is silently dropped from the rebuilt assembly and never mined.

The reorgBlocks() path already handles this correctly: before finalising the reorg it calls markNotOnLongestChain() for all current assembly transactions (lines 2665–2710). The reset path was missing the equivalent step.

Bug 2: Conflicts not detected after reset

BlockAssembler.reset() called loadUnminedTransactions with validateInputs=false. The getConflictingNodes() step that precedes it reads only pre-stored conflicting markers from block subtree files. If a moveForward block was validated before the conflicting assembly tx existed (so no marker was written into the subtree file), the conflict goes undetected.

validateUnminedTxInputs() independently verifies each unmined tx's inputs against the UTXO store's SpendingData. If SpendingData.TxID points to a different tx the input is already spent elsewhere and the tx is marked conflicting and excluded. This check has no dependency on subtree file markers, so it catches exactly the gaps left by getConflictingNodes().

Fix

SubtreeProcessor.reset() (services/blockassembly/subtreeprocessor/SubtreeProcessor.go):

Before clearing the assembly state, collect all transaction hashes from chainedSubtrees and currentSubtree and call markNotOnLongestChain(). This is idempotent — transactions that already have unmined_since set are unchanged — and directly mirrors what reorgBlocks() does.

BlockAssembler.handleReorg() (services/blockassembly/BlockAssembler.go):

Both reset() call sites in handleReorg now pass validateInputs=true. This enables validateUnminedTxInputs() inside loadUnminedTransactions, which catches any spending conflicts that getConflictingNodes() missed due to absent subtree markers. The existing gRPC-triggered reset path (resetReq.ValidateInputs) is unchanged.

Tests

Three new tests added using TDD — each written as failing (RED) first, then the fix applied to make it pass (GREEN):

Unit: TestResetMarksAssemblyTxsAsNotOnLongestChainBeforeClearing

(services/blockassembly/subtreeprocessor/reset_reorg_test.go)

Adds a tx to the assembly, manually sets its unmined_since to NULL in the UTXO store (simulating a competing fork), calls Reset(), and asserts the tx now has unmined_since set. Without the fix, the tx remains NULL and is lost from the rebuilt assembly.

Unit: TestReset_ConflictDetectionViaValidateInputs

(services/blockassembly/BlockAssembler_test.go)

Creates a tx in the unmined pool whose parent output's SpendingData points to a different (winning) tx, then calls reset(ctx, false, true). Asserts the conflicting tx is not loaded into block assembly. Without the fix (validateInputs=false), the conflict is missed and the tx incorrectly re-enters assembly.

E2E: TestReorgResetRecoversAssemblyTxPostgres/Aerospike

(test/sequentialtest/double_spend/11_reorg_reset_recovers_assembly_tx_test.go)

End-to-end sequential test that sets unmined_since=NULL on an assembly tx (simulating it being marked mined by a competing fork), forces a block assembly reset, and verifies the tx is recovered back into assembly. Follows the same style as the other numbered tests in test/sequentialtest/double_spend/.

Test plan

• go test -race -tags testtxmetacache -run TestResetMarksAssemblyTxsAsNotOnLongestChainBeforeClearing ./services/blockassembly/subtreeprocessor/ — PASS
• go test -race -tags testtxmetacache -run TestReset_ConflictDetectionViaValidateInputs ./services/blockassembly/ — PASS
• make sequentialtest TEST=TestReorgResetRecoversAssemblyTxPostgres — PASS
• go test -race -tags testtxmetacache ./services/blockassembly/... — all existing tests PASS