@cogcoin/client 0.5.12 → 0.5.13

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@0.5.12` is the store-backed Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
+`@cogcoin/client@0.5.13` is the store-backed Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
 
 Use Node 22 or newer.
 

package/dist/bitcoind/client/sync-engine.js

@@ -215,10 +215,15 @@ export async function syncToTip(dependencies) {
             aggregate.endingHeight = finalTip?.height ?? null;
             aggregate.bestHeight = endBestHeight;
             aggregate.bestHashHex = endInfo.bestblockhash;
-            if (dependencies.targetHeightCap !== null && dependencies.targetHeightCap !== undefined && caughtUpCogcoin) {
+            const reachedTargetHeightCap = dependencies.targetHeightCap !== null
+                && dependencies.targetHeightCap !== undefined
+                && endBestHeight >= dependencies.targetHeightCap;
+            if (reachedTargetHeightCap && caughtUpCogcoin) {
                 return aggregate;
             }
-            if (endInfo.blocks === endInfo.headers && caughtUpCogcoin) {
+            if (dependencies.targetHeightCap === null
+                && endInfo.blocks === endInfo.headers
+                && caughtUpCogcoin) {
                 if (dependencies.isFollowing()) {
                     dependencies.progress.replaceFollowBlockTimes(await runRpc(() => dependencies.loadVisibleFollowBlockTimes(finalTip)));
                 }

package/dist/wallet/archive.js

@@ -1,18 +1,20 @@
 import { readFile } from "node:fs/promises";
 import { writeJsonFileAtomic } from "./fs/atomic.js";
+import { normalizePortableWalletArchivePayload } from "./coin-control.js";
 import { decryptJsonWithPassphrase, encryptJsonWithPassphrase, } from "./state/crypto.js";
 export const PORTABLE_WALLET_ARCHIVE_FORMAT = "cogcoin-portable-wallet-archive";
 function assertPortableWalletArchivePayload(payload) {
-    if (payload.schemaVersion !== 1
-        || payload.walletRootId.trim() === ""
-        || payload.mnemonic.phrase.trim() === ""
-        || payload.expected.accountPath.trim() === ""
-        || payload.expected.publicExternalDescriptor.trim() === ""
-        || payload.expected.fundingAddress0.trim() === ""
-        || payload.expected.fundingScriptPubKeyHex0.trim() === "") {
+    const normalized = normalizePortableWalletArchivePayload(payload);
+    if (normalized.schemaVersion !== 1
+        || normalized.walletRootId.trim() === ""
+        || normalized.mnemonic.phrase.trim() === ""
+        || normalized.expected.accountPath.trim() === ""
+        || normalized.expected.publicExternalDescriptor.trim() === ""
+        || normalized.expected.fundingAddress0.trim() === ""
+        || normalized.expected.fundingScriptPubKeyHex0.trim() === "") {
         throw new Error("wallet_archive_payload_invalid");
     }
-    return payload;
+    return normalized;
 }
 export async function writePortableWalletArchive(path, payload, passphrase) {
     const envelope = await encryptJsonWithPassphrase(assertPortableWalletArchivePayload(payload), passphrase, {

package/dist/wallet/coin-control.d.ts

@@ -0,0 +1,41 @@
+import type { RpcListUnspentEntry, RpcLockedUnspent } from "../bitcoind/types.js";
+import { persistWalletStateUpdate } from "./descriptor-normalization.js";
+import type { WalletRuntimePaths } from "./runtime.js";
+import type { OutpointRecord, PortableWalletArchivePayloadV1, UnlockSessionStateV1, WalletStateV1 } from "./types.js";
+export declare const DEFAULT_PROACTIVE_RESERVE_SATS = 50000;
+export interface WalletCoinControlRpc {
+    listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
+    listLockUnspent(walletName: string): Promise<RpcLockedUnspent[]>;
+    lockUnspent(walletName: string, unlock: boolean, outputs: RpcLockedUnspent[]): Promise<boolean>;
+}
+export declare function outpointKey(outpoint: OutpointRecord): string;
+export declare function normalizeWalletStateRecord(state: WalletStateV1): WalletStateV1;
+export declare function normalizePortableWalletArchivePayload(payload: PortableWalletArchivePayloadV1): PortableWalletArchivePayloadV1;
+export declare function computeDesignatedProactiveReserveOutpoints(state: WalletStateV1, spendableUtxos: readonly RpcListUnspentEntry[]): OutpointRecord[];
+export declare function reconcilePersistentPolicyLocks(options: {
+    rpc: WalletCoinControlRpc;
+    walletName: string;
+    state: WalletStateV1;
+    fixedInputs?: readonly OutpointRecord[];
+    temporarilyUnlockedOutpoints?: readonly OutpointRecord[];
+    cleanupInactiveTemporaryBuilderLocks?: boolean;
+    spendableUtxos?: readonly RpcListUnspentEntry[];
+}): Promise<{
+    state: WalletStateV1;
+    changed: boolean;
+    spendableUtxos: readonly RpcListUnspentEntry[];
+}>;
+export declare function persistWalletCoinControlStateIfNeeded(options: {
+    state: WalletStateV1;
+    access: Parameters<typeof persistWalletStateUpdate>[0]["access"];
+    session?: UnlockSessionStateV1 | null;
+    paths: WalletRuntimePaths;
+    nowUnixMs: number;
+    replacePrimary?: boolean;
+    rpc: WalletCoinControlRpc;
+    cleanupInactiveTemporaryBuilderLocks?: boolean;
+}): Promise<{
+    changed: boolean;
+    session: UnlockSessionStateV1 | null;
+    state: WalletStateV1;
+}>;

package/dist/wallet/coin-control.js

@@ -0,0 +1,365 @@
+import { saveUnlockSession } from "./state/session.js";
+import { persistWalletStateUpdate } from "./descriptor-normalization.js";
+import { miningFamilyMayStillExist } from "./mining/state.js";
+export const DEFAULT_PROACTIVE_RESERVE_SATS = 50_000;
+function btcNumberToSats(value) {
+    return BigInt(Math.round(value * 100_000_000));
+}
+export function outpointKey(outpoint) {
+    return `${outpoint.txid}:${outpoint.vout}`;
+}
+function normalizeOutpointRecordList(outpoints) {
+    const normalized = [];
+    const seen = new Set();
+    for (const outpoint of outpoints ?? []) {
+        if (outpoint == null
+            || typeof outpoint.txid !== "string"
+            || outpoint.txid.length === 0
+            || typeof outpoint.vout !== "number"
+            || !Number.isInteger(outpoint.vout)
+            || outpoint.vout < 0) {
+            continue;
+        }
+        const key = outpointKey(outpoint);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        normalized.push({ txid: outpoint.txid, vout: outpoint.vout });
+    }
+    return normalized;
+}
+function normalizeReserveSats(raw) {
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+        return DEFAULT_PROACTIVE_RESERVE_SATS;
+    }
+    return Math.max(0, Math.trunc(raw));
+}
+function sameOutpointList(left, right) {
+    if (left.length !== (right?.length ?? 0)) {
+        return false;
+    }
+    return left.every((outpoint, index) => outpoint.txid === right?.[index]?.txid && outpoint.vout === right?.[index]?.vout);
+}
+export function normalizeWalletStateRecord(state) {
+    const proactiveReserveSats = normalizeReserveSats(state.proactiveReserveSats);
+    const proactiveReserveOutpoints = normalizeOutpointRecordList(state.proactiveReserveOutpoints);
+    const pendingMutations = state.pendingMutations ?? [];
+    if (proactiveReserveSats === state.proactiveReserveSats
+        && sameOutpointList(proactiveReserveOutpoints, state.proactiveReserveOutpoints)
+        && pendingMutations === state.pendingMutations) {
+        return state;
+    }
+    return {
+        ...state,
+        proactiveReserveSats,
+        proactiveReserveOutpoints,
+        pendingMutations,
+    };
+}
+export function normalizePortableWalletArchivePayload(payload) {
+    const proactiveReserveSats = normalizeReserveSats(payload.proactiveReserveSats);
+    const proactiveReserveOutpoints = normalizeOutpointRecordList(payload.proactiveReserveOutpoints);
+    if (proactiveReserveSats === payload.proactiveReserveSats
+        && sameOutpointList(proactiveReserveOutpoints, payload.proactiveReserveOutpoints)) {
+        return payload;
+    }
+    return {
+        ...payload,
+        proactiveReserveSats,
+        proactiveReserveOutpoints,
+    };
+}
+function isSpendableUtxo(entry) {
+    return entry.spendable !== false && entry.safe !== false;
+}
+function isConfirmedFundingUtxo(state, entry) {
+    return entry.scriptPubKey === state.funding.scriptPubKeyHex
+        && entry.confirmations >= 1
+        && isSpendableUtxo(entry);
+}
+function sortFundingEntriesForReserve(entries) {
+    return entries.slice().sort((left, right) => {
+        const amount = btcNumberToSats(right.amount) - btcNumberToSats(left.amount);
+        if (amount !== 0n) {
+            return amount > 0n ? 1 : -1;
+        }
+        const txid = left.txid.localeCompare(right.txid);
+        if (txid !== 0) {
+            return txid;
+        }
+        return left.vout - right.vout;
+    });
+}
+function isActiveTrackedTransaction(record) {
+    if (record == null) {
+        return false;
+    }
+    return record.status === "broadcasting"
+        || record.status === "broadcast-unknown"
+        || record.status === "live";
+}
+function isActiveTrackedStatus(status) {
+    return status === "broadcasting"
+        || status === "broadcast-unknown"
+        || status === "live";
+}
+function deriveLiveProvisionalOutpointKeys(state) {
+    const keys = new Set();
+    for (const family of state.proactiveFamilies) {
+        if ((family.type !== "anchor" && family.type !== "field") || family.tx1?.attemptedTxid == null) {
+            continue;
+        }
+        if (isActiveTrackedStatus(family.status)) {
+            keys.add(outpointKey({ txid: family.tx1.attemptedTxid, vout: 1 }));
+        }
+    }
+    return keys;
+}
+function deriveAuxiliaryDedicatedOutpoints(state, spendableUtxos) {
+    const canonicalAnchorKeys = new Set(state.domains
+        .map((domain) => domain.currentCanonicalAnchorOutpoint)
+        .filter((outpoint) => outpoint !== null)
+        .map((outpoint) => outpointKey(outpoint)));
+    const dedicatedScriptSet = new Set(state.identities
+        .filter((identity) => identity.status === "dedicated")
+        .map((identity) => identity.scriptPubKeyHex));
+    const liveProvisionalKeys = deriveLiveProvisionalOutpointKeys(state);
+    const auxiliary = [];
+    const seen = new Set();
+    for (const entry of spendableUtxos) {
+        if (!isSpendableUtxo(entry) || !dedicatedScriptSet.has(entry.scriptPubKey)) {
+            continue;
+        }
+        const outpoint = { txid: entry.txid, vout: entry.vout };
+        const key = outpointKey(outpoint);
+        if (canonicalAnchorKeys.has(key) || liveProvisionalKeys.has(key) || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        auxiliary.push(outpoint);
+    }
+    return auxiliary;
+}
+export function computeDesignatedProactiveReserveOutpoints(state, spendableUtxos) {
+    const normalizedState = normalizeWalletStateRecord(state);
+    if (normalizedState.proactiveReserveSats <= 0) {
+        return [];
+    }
+    const conflictKey = normalizedState.miningState.sharedMiningConflictOutpoint === null
+        ? null
+        : outpointKey(normalizedState.miningState.sharedMiningConflictOutpoint);
+    const eligible = sortFundingEntriesForReserve(spendableUtxos.filter((entry) => isConfirmedFundingUtxo(normalizedState, entry)
+        && outpointKey({ txid: entry.txid, vout: entry.vout }) !== conflictKey));
+    const selected = [];
+    let total = 0n;
+    const target = BigInt(normalizedState.proactiveReserveSats);
+    for (const entry of eligible) {
+        selected.push({ txid: entry.txid, vout: entry.vout });
+        total += btcNumberToSats(entry.amount);
+        if (total >= target) {
+            break;
+        }
+    }
+    return selected;
+}
+function syncStateWithComputedReserve(state, spendableUtxos) {
+    const normalizedState = normalizeWalletStateRecord(state);
+    const proactiveReserveOutpoints = computeDesignatedProactiveReserveOutpoints(normalizedState, spendableUtxos);
+    const sameLength = proactiveReserveOutpoints.length === normalizedState.proactiveReserveOutpoints.length;
+    const sameKeys = sameLength && proactiveReserveOutpoints.every((outpoint, index) => outpointKey(outpoint) === outpointKey(normalizedState.proactiveReserveOutpoints[index]));
+    if (sameKeys && normalizedState === state) {
+        return {
+            state,
+            changed: false,
+        };
+    }
+    if (sameKeys) {
+        return {
+            state: normalizedState,
+            changed: true,
+        };
+    }
+    return {
+        state: {
+            ...normalizedState,
+            proactiveReserveOutpoints,
+        },
+        changed: true,
+    };
+}
+function collectInactiveTemporaryBuilderLockCleanup(state) {
+    const normalizedState = normalizeWalletStateRecord(state);
+    const stale = new Map();
+    let familiesChanged = false;
+    let mutationsChanged = false;
+    const proactiveFamilies = normalizedState.proactiveFamilies.map((family) => {
+        let nextFamily = family;
+        for (const key of ["tx1", "tx2"]) {
+            const record = nextFamily[key];
+            if (record == null || isActiveTrackedTransaction(record) || record.temporaryBuilderLockedOutpoints.length === 0) {
+                continue;
+            }
+            for (const outpoint of record.temporaryBuilderLockedOutpoints) {
+                stale.set(outpointKey(outpoint), outpoint);
+            }
+            nextFamily = {
+                ...nextFamily,
+                [key]: {
+                    ...record,
+                    temporaryBuilderLockedOutpoints: [],
+                },
+            };
+            familiesChanged = true;
+        }
+        return nextFamily;
+    });
+    const pendingMutations = (normalizedState.pendingMutations ?? []).map((mutation) => {
+        if (isActiveTrackedStatus(mutation.status) || mutation.temporaryBuilderLockedOutpoints.length === 0) {
+            return mutation;
+        }
+        for (const outpoint of mutation.temporaryBuilderLockedOutpoints) {
+            stale.set(outpointKey(outpoint), outpoint);
+        }
+        mutationsChanged = true;
+        return {
+            ...mutation,
+            temporaryBuilderLockedOutpoints: [],
+        };
+    });
+    if (!familiesChanged && !mutationsChanged && normalizedState === state) {
+        return {
+            state,
+            staleOutpoints: [],
+            changed: false,
+        };
+    }
+    return {
+        state: familiesChanged || mutationsChanged
+            ? {
+                ...normalizedState,
+                proactiveFamilies,
+                pendingMutations,
+            }
+            : normalizedState,
+        staleOutpoints: [...stale.values()],
+        changed: familiesChanged || mutationsChanged || normalizedState !== state,
+    };
+}
+function collectPersistentPolicyLockedOutpoints(state, spendableUtxos) {
+    const outpoints = [];
+    const seen = new Set();
+    const pushUnique = (outpoint) => {
+        if (outpoint === null) {
+            return;
+        }
+        const key = outpointKey(outpoint);
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        outpoints.push(outpoint);
+    };
+    for (const domain of state.domains) {
+        pushUnique(domain.currentCanonicalAnchorOutpoint);
+    }
+    for (const outpoint of deriveAuxiliaryDedicatedOutpoints(state, spendableUtxos)) {
+        pushUnique(outpoint);
+    }
+    for (const outpoint of state.proactiveReserveOutpoints) {
+        pushUnique(outpoint);
+    }
+    if (!miningFamilyMayStillExist(state.miningState)) {
+        pushUnique(state.miningState.sharedMiningConflictOutpoint);
+    }
+    return outpoints;
+}
+export async function reconcilePersistentPolicyLocks(options) {
+    let state = normalizeWalletStateRecord(options.state);
+    let changed = state !== options.state;
+    if (options.cleanupInactiveTemporaryBuilderLocks === true) {
+        const cleaned = collectInactiveTemporaryBuilderLockCleanup(state);
+        state = cleaned.state;
+        changed ||= cleaned.changed;
+        if (cleaned.staleOutpoints.length > 0) {
+            await options.rpc.lockUnspent(options.walletName, true, cleaned.staleOutpoints).catch(() => undefined);
+        }
+    }
+    const spendableUtxos = options.spendableUtxos ?? await options.rpc.listUnspent(options.walletName, 0).catch(() => []);
+    const reserveSynced = syncStateWithComputedReserve(state, spendableUtxos);
+    state = reserveSynced.state;
+    changed ||= reserveSynced.changed;
+    const protectedUniverse = collectPersistentPolicyLockedOutpoints(state, spendableUtxos);
+    if (protectedUniverse.length === 0) {
+        return {
+            state,
+            changed,
+            spendableUtxos,
+        };
+    }
+    const protectedUniverseKeys = new Set(protectedUniverse.map((outpoint) => outpointKey(outpoint)));
+    const fixedInputKeys = new Set((options.fixedInputs ?? []).map((outpoint) => outpointKey(outpoint)));
+    const temporarilyUnlockedKeys = new Set((options.temporarilyUnlockedOutpoints ?? []).map((outpoint) => outpointKey(outpoint)));
+    const locked = await options.rpc.listLockUnspent(options.walletName).catch(() => []);
+    const spendableKeys = new Set(spendableUtxos.map((entry) => outpointKey(entry)));
+    const expectedLocked = protectedUniverse.filter((outpoint) => {
+        const key = outpointKey(outpoint);
+        return spendableKeys.has(key) && !fixedInputKeys.has(key) && !temporarilyUnlockedKeys.has(key);
+    });
+    const expectedLockedKeys = new Set(expectedLocked.map((outpoint) => outpointKey(outpoint)));
+    const lockedProtected = locked.filter((outpoint) => protectedUniverseKeys.has(outpointKey(outpoint)));
+    const lockedProtectedKeys = new Set(lockedProtected.map((outpoint) => outpointKey(outpoint)));
+    const staleLocked = lockedProtected.filter((outpoint) => !expectedLockedKeys.has(outpointKey(outpoint)) || !spendableKeys.has(outpointKey(outpoint)));
+    const missingLocked = expectedLocked.filter((outpoint) => !lockedProtectedKeys.has(outpointKey(outpoint)));
+    if (staleLocked.length > 0) {
+        await options.rpc.lockUnspent(options.walletName, true, staleLocked).catch(() => undefined);
+    }
+    if (missingLocked.length > 0) {
+        await options.rpc.lockUnspent(options.walletName, false, missingLocked).catch(() => undefined);
+    }
+    return {
+        state,
+        changed,
+        spendableUtxos,
+    };
+}
+export async function persistWalletCoinControlStateIfNeeded(options) {
+    const reconciled = await reconcilePersistentPolicyLocks({
+        rpc: options.rpc,
+        walletName: options.state.managedCoreWallet.walletName,
+        state: options.state,
+        cleanupInactiveTemporaryBuilderLocks: options.cleanupInactiveTemporaryBuilderLocks ?? true,
+    });
+    if (!reconciled.changed) {
+        return {
+            changed: false,
+            session: options.session ?? null,
+            state: reconciled.state,
+        };
+    }
+    const nextState = await persistWalletStateUpdate({
+        state: reconciled.state,
+        access: options.access,
+        paths: options.paths,
+        nowUnixMs: options.nowUnixMs,
+        replacePrimary: options.replacePrimary,
+    });
+    if (options.session == null) {
+        return {
+            changed: true,
+            session: null,
+            state: nextState,
+        };
+    }
+    const nextSession = {
+        ...options.session,
+        walletRootId: nextState.walletRootId,
+        sourceStateRevision: nextState.stateRevision,
+    };
+    await saveUnlockSession(options.paths.walletUnlockSessionPath, nextSession, options.access);
+    return {
+        changed: true,
+        session: nextSession,
+        state: nextState,
+    };
+}

package/dist/wallet/lifecycle.js

@@ -8,6 +8,7 @@ import { resolveManagedServicePaths } from "../bitcoind/service-paths.js";
 import { createRpcClient } from "../bitcoind/node.js";
 import { openSqliteStore } from "../sqlite/index.js";
 import { readPortableWalletArchive, writePortableWalletArchive } from "./archive.js";
+import { DEFAULT_PROACTIVE_RESERVE_SATS, normalizeWalletStateRecord, persistWalletCoinControlStateIfNeeded, } from "./coin-control.js";
 import { normalizeWalletDescriptorState, persistNormalizedWalletDescriptorStateIfNeeded, persistWalletStateUpdate, resolveNormalizedWalletDescriptorState, stripDescriptorChecksum, } from "./descriptor-normalization.js";
 import { acquireFileLock, clearOrphanedFileLock } from "./fs/lock.js";
 import { createInternalCoreWalletPassphrase, createMnemonicConfirmationChallenge, deriveWalletMaterialFromMnemonic, generateWalletMaterial, isEnglishMnemonicWord, validateEnglishMnemonic, } from "./material.js";
@@ -104,6 +105,8 @@ function createInitialWalletState(options) {
         walletRootId: options.walletRootId,
         network: "mainnet",
         anchorValueSats: 2_000,
+        proactiveReserveSats: DEFAULT_PROACTIVE_RESERVE_SATS,
+        proactiveReserveOutpoints: [],
         nextDedicatedIndex: 1,
         fundingIndex: 0,
         mnemonic: {
@@ -239,6 +242,21 @@ async function normalizeUnlockedWalletStateIfNeeded(options) {
             state = normalized.state;
             session = normalized.session ?? session;
             source = normalized.changed ? "primary" : options.source;
+            const coinControl = await persistWalletCoinControlStateIfNeeded({
+                state,
+                access: {
+                    provider: options.provider,
+                    secretReference: createWalletSecretReference(state.walletRootId),
+                },
+                session,
+                paths: options.paths,
+                nowUnixMs: options.nowUnixMs,
+                replacePrimary: source === "backup",
+                rpc: createRpcClient(node.rpc),
+            });
+            state = coinControl.state;
+            session = coinControl.session ?? session;
+            source = coinControl.changed ? "primary" : source;
         }
         finally {
             await node.stop?.().catch(() => undefined);
@@ -246,10 +264,10 @@ async function normalizeUnlockedWalletStateIfNeeded(options) {
     }
     return {
         session,
-        state: {
+        state: normalizeWalletStateRecord({
             ...state,
             miningState: normalizeMiningStateRecord(state.miningState),
-        },
+        }),
         source,
     };
 }
@@ -260,6 +278,8 @@ function createPortableWalletArchivePayload(state, exportedAtUnixMs) {
         walletRootId: state.walletRootId,
         network: state.network,
         anchorValueSats: state.anchorValueSats,
+        proactiveReserveSats: state.proactiveReserveSats,
+        proactiveReserveOutpoints: state.proactiveReserveOutpoints,
         nextDedicatedIndex: state.nextDedicatedIndex,
         fundingIndex: state.fundingIndex,
         mnemonic: {
@@ -306,6 +326,8 @@ function createWalletStateFromPortableArchive(options) {
         walletRootId: options.payload.walletRootId,
         network: options.payload.network,
         anchorValueSats: options.payload.anchorValueSats,
+        proactiveReserveSats: options.payload.proactiveReserveSats,
+        proactiveReserveOutpoints: options.payload.proactiveReserveOutpoints,
         nextDedicatedIndex: options.payload.nextDedicatedIndex,
         fundingIndex: options.payload.fundingIndex,
         walletBirthTime: options.payload.expected.walletBirthTime,
@@ -1842,6 +1864,21 @@ export async function repairWallet(options) {
                 repairedState = normalizedDescriptorState.state;
                 repairStateNeedsPersist = true;
             }
+            const reconciledCoinControl = await persistWalletCoinControlStateIfNeeded({
+                state: repairedState,
+                access: {
+                    provider,
+                    secretReference,
+                },
+                paths,
+                nowUnixMs,
+                replacePrimary: recoveredFromBackup && !repairStateNeedsPersist,
+                rpc: createRpcClient(bitcoindHandle.rpc),
+            });
+            repairedState = reconciledCoinControl.state;
+            if (reconciledCoinControl.changed) {
+                repairStateNeedsPersist = false;
+            }
             let replica = await verifyManagedCoreWalletReplica(repairedState, options.dataDir, {
                 nodeHandle: bitcoindHandle,
                 attachService: options.attachService,