@cogcoin/client 0.5.11 → 0.5.13

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,

package/dist/wallet/mining/runner.js

@@ -8,7 +8,7 @@ import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { COG_OPCODES, COG_PREFIX } from "../cogop/constants.js";
 import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
-import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, saveWalletStatePreservingUnlock, } from "../tx/common.js";
+import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB, assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, buildWalletMutationTransaction, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, saveWalletStatePreservingUnlock, } from "../tx/common.js";
 import { acquireFileLock } from "../fs/lock.js";
 import { loadOrAutoUnlockWalletState } from "../lifecycle.js";
 import { isMineableWalletDomain, openWalletReadContext, } from "../read/index.js";
@@ -584,10 +584,9 @@ function createMiningPlan(options) {
     ]).toString("hex");
     return {
         sender: options.candidate.sender,
-        inputs: [
+        fixedInputs: [
             options.candidate.anchorOutpoint,
             options.conflictOutpoint,
-            ...fundingUtxos.map((entry) => ({ txid: entry.txid, vout: entry.vout })),
         ],
         outputs: [
             { data: Buffer.from(opReturnData).toString("hex") },
@@ -599,6 +598,7 @@ function createMiningPlan(options) {
         expectedAnchorScriptHex: options.candidate.sender.scriptPubKeyHex,
         expectedAnchorValueSats: BigInt(options.state.anchorValueSats),
         allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => walletMutationOutpointKey({ txid: entry.txid, vout: entry.vout }))),
         expectedConflictOutpoint: options.conflictOutpoint,
         feeRateSatVb: options.feeRateSatVb,
     };
@@ -609,17 +609,22 @@ function validateMiningDraft(decoded, funded, plan) {
     if (inputs.length < 2) {
         throw new Error("wallet_mining_missing_inputs");
     }
+    assertFixedInputPrefixMatches(inputs, plan.fixedInputs, "wallet_mining_missing_inputs");
     if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
         throw new Error("wallet_mining_sender_input_mismatch");
     }
-    if (inputs[1]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+    if (inputs[1]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex
+        || inputs[1]?.txid !== plan.expectedConflictOutpoint.txid
+        || inputs[1].vout !== plan.expectedConflictOutpoint.vout) {
         throw new Error("wallet_mining_conflict_input_mismatch");
     }
-    for (let index = 2; index < inputs.length; index += 1) {
-        if (inputs[index]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
-            throw new Error("wallet_mining_unexpected_funding_input");
-        }
-    }
+    assertFundingInputsAfterFixedPrefix({
+        inputs,
+        fixedInputs: plan.fixedInputs,
+        allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
+        eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
+        errorCode: "wallet_mining_unexpected_funding_input",
+    });
     if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
         throw new Error("wallet_mining_opreturn_mismatch");
     }
@@ -637,17 +642,12 @@ async function buildMiningTransaction(options) {
     return buildWalletMutationTransaction({
         rpc: options.rpc,
         walletName: options.walletName,
+        state: options.state,
         plan: options.plan,
         validateFundedDraft: validateMiningDraft,
         finalizeErrorCode: "wallet_mining_finalize_failed",
         mempoolRejectPrefix: "wallet_mining_mempool_rejected",
         feeRate: options.plan.feeRateSatVb,
-        builderOptions: {
-            addInputs: true,
-            includeUnsafe: true,
-            minConf: 0,
-            lockUnspents: true,
-        },
     });
 }
 function resolveEligibleAnchoredRoots(context) {
@@ -1244,30 +1244,6 @@ function miningCandidateIsCurrent(options) {
         && options.nodeBestHeight !== null
         && options.state.currentBlockTargetHeight === (options.nodeBestHeight + 1);
 }
-async function rebuildPersistentAnchorLocks(options) {
-    const walletName = options.state.managedCoreWallet.walletName;
-    const [locked, spendable] = await Promise.all([
-        options.rpc.listLockUnspent(walletName).catch(() => []),
-        options.rpc.listUnspent(walletName, 0).catch(() => []),
-    ]);
-    const spendableKeys = new Set(spendable.map((entry) => `${entry.txid}:${entry.vout}`));
-    const expected = options.state.domains
-        .map((domain) => domain.currentCanonicalAnchorOutpoint)
-        .filter((outpoint) => outpoint !== null)
-        .map((outpoint) => ({ txid: outpoint.txid, vout: outpoint.vout }))
-        .filter((outpoint) => spendableKeys.has(`${outpoint.txid}:${outpoint.vout}`));
-    const expectedKeys = new Set(expected.map((outpoint) => `${outpoint.txid}:${outpoint.vout}`));
-    const lockedKeys = new Set(locked.map((outpoint) => `${outpoint.txid}:${outpoint.vout}`));
-    const staleLocked = locked.filter((outpoint) => !expectedKeys.has(`${outpoint.txid}:${outpoint.vout}`)
-        || !spendableKeys.has(`${outpoint.txid}:${outpoint.vout}`));
-    const missingLocked = expected.filter((outpoint) => !lockedKeys.has(`${outpoint.txid}:${outpoint.vout}`));
-    if (staleLocked.length > 0) {
-        await options.rpc.lockUnspent(walletName, true, staleLocked).catch(() => undefined);
-    }
-    if (missingLocked.length > 0) {
-        await options.rpc.lockUnspent(walletName, false, missingLocked).catch(() => undefined);
-    }
-}
 async function reconcileLiveMiningState(options) {
     let state = {
         ...options.state,
@@ -1275,7 +1251,12 @@ async function reconcileLiveMiningState(options) {
     };
     const currentTxid = state.miningState.currentTxid;
     if (currentTxid === null || !miningFamilyMayStillExist(state.miningState)) {
-        await rebuildPersistentAnchorLocks({ state, rpc: options.rpc });
+        await reconcilePersistentPolicyLocks({
+            rpc: options.rpc,
+            walletName: state.managedCoreWallet.walletName,
+            state,
+            fixedInputs: [],
+        });
         return state;
     }
     const walletName = state.managedCoreWallet.walletName;
@@ -1295,7 +1276,12 @@ async function reconcileLiveMiningState(options) {
                 currentPublishDecision: "tx-confirmed-while-down",
             },
         };
-        await rebuildPersistentAnchorLocks({ state, rpc: options.rpc });
+        await reconcilePersistentPolicyLocks({
+            rpc: options.rpc,
+            walletName: state.managedCoreWallet.walletName,
+            state,
+            fixedInputs: [],
+        });
         return state;
     }
     if (inMempool) {
@@ -1319,7 +1305,12 @@ async function reconcileLiveMiningState(options) {
                     : null,
             currentPublishDecision: stale ? "paused-stale-mempool" : "restored-live-family",
         });
-        await rebuildPersistentAnchorLocks({ state, rpc: options.rpc });
+        await reconcilePersistentPolicyLocks({
+            rpc: options.rpc,
+            walletName: state.managedCoreWallet.walletName,
+            state,
+            fixedInputs: [],
+        });
         return state;
     }
     if ((walletTx?.walletconflicts?.length ?? 0) > 0) {
@@ -1333,7 +1324,12 @@ async function reconcileLiveMiningState(options) {
                 ? "repair-required-broadcast-conflict"
                 : "repair-required-wallet-conflict",
         });
-        await rebuildPersistentAnchorLocks({ state, rpc: options.rpc });
+        await reconcilePersistentPolicyLocks({
+            rpc: options.rpc,
+            walletName: state.managedCoreWallet.walletName,
+            state,
+            fixedInputs: [],
+        });
         return state;
     }
     state = defaultMiningStatePatch(state, {
@@ -1342,7 +1338,12 @@ async function reconcileLiveMiningState(options) {
             ? "broadcast-unknown-not-seen"
             : "live-family-not-seen",
     });
-    await rebuildPersistentAnchorLocks({ state, rpc: options.rpc });
+    await reconcilePersistentPolicyLocks({
+        rpc: options.rpc,
+        walletName: state.managedCoreWallet.walletName,
+        state,
+        fixedInputs: [],
+    });
     return state;
 }
 async function publishCandidate(options) {
@@ -1405,6 +1406,7 @@ async function publishCandidate(options) {
     const built = await buildMiningTransaction({
         rpc,
         walletName: state.managedCoreWallet.walletName,
+        state,
         plan,
     });
     const intentFingerprintHex = computeIntentFingerprint(state, options.candidate);