@cogcoin/client 0.5.13 → 0.5.14

package/dist/cli/commands/wallet-mutation.js

@@ -47,6 +47,7 @@ export async function runWalletMutationCommand(parsed, context) {
             const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
             const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
             const prompter = createCommandPrompter(parsed, context);
+            const interactive = prompter.isInteractive;
             if (isAnchorClearMutationCommand(parsed.command)) {
                 const result = await context.clearPendingAnchor({
                     domainName: parsed.args[0],
@@ -65,6 +66,7 @@ export async function runWalletMutationCommand(parsed, context) {
                     previewData: buildAnchorClearPreviewData(result),
                     reusedExisting: false,
                     reusedMessage: "",
+                    interactive,
                     outcome: result.cleared ? "cleared" : "noop",
                     nextSteps,
                     text: {
@@ -83,6 +85,7 @@ export async function runWalletMutationCommand(parsed, context) {
                 const result = await context.anchorDomain({
                     domainName: parsed.args[0],
                     foundingMessageText: parsed.anchorMessage,
+                    promptForFoundingMessageWhenMissing: parsed.anchorMessage === null,
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
@@ -92,13 +95,15 @@ export async function runWalletMutationCommand(parsed, context) {
                 const nextSteps = getAnchorNextSteps(result.domainName);
                 return writeMutationCommandSuccess(parsed, context, {
                     data: buildAnchorMutationData(result, {
-                        foundingMessageText: parsed.anchorMessage,
+                        foundingMessageText: result.foundingMessageText ?? parsed.anchorMessage,
                     }),
                     previewData: buildAnchorPreviewData(result, {
-                        foundingMessageText: parsed.anchorMessage,
+                        foundingMessageText: result.foundingMessageText ?? parsed.anchorMessage,
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing anchor family was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.tx2Txid,
                     nextSteps: workflowMutationNextSteps(nextSteps),
                     text: {
                         heading: "Anchor family submitted.",
@@ -136,6 +141,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending registration was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: workflowMutationNextSteps(nextSteps),
                     text: {
                         heading: "Registration submitted.",
@@ -171,6 +178,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending transfer was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
                     text: {
                         heading: "Transfer submitted.",
@@ -208,6 +217,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending listing mutation was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
                     text: {
                         heading: result.listedPriceCogtoshi === 0n ? "Listing cancellation submitted." : "Listing submitted.",
@@ -256,6 +267,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending endpoint mutation was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
                     text: {
                         heading: parsed.command === "domain-endpoint-set" ? "Endpoint update submitted." : "Endpoint clear submitted.",
@@ -300,6 +313,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending delegate mutation was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
                     text: {
                         heading: parsed.command === "domain-delegate-set" ? "Delegate update submitted." : "Delegate clear submitted.",
@@ -344,6 +359,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending miner mutation was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
                     text: {
                         heading: parsed.command === "domain-miner-set" ? "Miner update submitted." : "Miner clear submitted.",
@@ -377,6 +394,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending canonical mutation was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
                     text: {
                         heading: "Canonical update submitted.",
@@ -415,6 +434,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     reusedMessage: result.family
                         ? "The existing pending field family was reconciled instead of creating a duplicate."
                         : "The existing pending field creation was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.family ? (result.tx2Txid ?? null) : result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin field show ${result.domainName} ${result.fieldName}`),
                     text: {
                         heading: result.family ? "Field create+write family submitted." : "Field creation submitted.",
@@ -450,6 +471,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     previewData: buildFieldPreviewData(result),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending field update was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin field show ${result.domainName} ${result.fieldName}`),
                     text: {
                         heading: "Field update submitted.",
@@ -481,6 +504,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     previewData: buildFieldPreviewData(result),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending field clear was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin field show ${result.domainName} ${result.fieldName}`),
                     text: {
                         heading: "Field clear submitted.",
@@ -518,6 +543,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending COG transfer was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps("cogcoin balance"),
                     text: {
                         heading: "COG transfer submitted.",
@@ -563,6 +590,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending lock was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps("cogcoin locks"),
                     text: {
                         heading: "COG lock submitted.",
@@ -597,6 +626,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending claim was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps("cogcoin locks --claimable"),
                     text: {
                         heading: "Lock claim submitted.",
@@ -631,6 +662,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending reclaim was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps("cogcoin locks --reclaimable"),
                     text: {
                         heading: "Lock reclaim submitted.",
@@ -676,6 +709,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     previewData: buildReputationPreviewData(result),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending reputation mutation was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.targetDomainName}`),
                     text: {
                         heading: parsed.command === "rep-give" ? "Reputation support submitted." : "Reputation revoke submitted.",
@@ -714,6 +749,8 @@ export async function runWalletMutationCommand(parsed, context) {
                     }),
                     reusedExisting: result.reusedExisting,
                     reusedMessage: "The existing pending purchase was reconciled instead of creating a duplicate.",
+                    interactive,
+                    explorerTxid: result.txid,
                     nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
                     text: {
                         heading: "Purchase submitted.",

package/dist/cli/context.js

@@ -17,9 +17,26 @@ import { createLazyDefaultWalletSecretProvider } from "../wallet/state/provider.
 import { anchorDomain, clearPendingAnchor, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain, } from "../wallet/tx/index.js";
 import { createTerminalPrompter } from "./prompt.js";
 export async function readPackageVersionFromDisk() {
-    const raw = await readFile(new URL("../../package.json", import.meta.url), "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed.version ?? "0.0.0";
+    const packageUrls = [
+        new URL("../../package.json", import.meta.url),
+        new URL("../../../package.json", import.meta.url),
+    ];
+    for (const packageUrl of packageUrls) {
+        try {
+            const raw = await readFile(packageUrl, "utf8");
+            const parsed = JSON.parse(raw);
+            return parsed.version ?? "0.0.0";
+        }
+        catch (error) {
+            const code = typeof error === "object" && error !== null && "code" in error
+                ? String(error.code)
+                : null;
+            if (code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return "0.0.0";
 }
 export function createDefaultContext(overrides = {}) {
     return {

package/dist/cli/mutation-success.d.ts

@@ -11,6 +11,8 @@ export declare function writeMutationCommandSuccess(parsed: ParsedCliArgs, conte
     previewData?: unknown;
     reusedExisting: boolean;
     reusedMessage: string;
+    interactive?: boolean;
+    explorerTxid?: string | null;
     nextSteps: MutationSuccessNextSteps;
     outcome?: string;
     text: {

package/dist/cli/mutation-success.js

@@ -42,6 +42,8 @@ export function writeMutationCommandSuccess(parsed, context, options) {
         reusedExisting: options.reusedExisting,
         reusedMessage: options.reusedMessage,
         trailerLines: options.nextSteps.text,
+        interactive: options.interactive,
+        explorerTxid: options.explorerTxid,
     });
     return 0;
 }

package/dist/cli/mutation-text-write.d.ts

@@ -10,4 +10,6 @@ export declare function writeMutationTextResult(stream: WritableLike, options: {
     reusedExisting?: boolean;
     reusedMessage?: string;
     trailerLines?: string[];
+    interactive?: boolean;
+    explorerTxid?: string | null;
 }): void;

package/dist/cli/mutation-text-write.js

@@ -1,4 +1,7 @@
 import { writeLine } from "./io.js";
+function mutationExplorerUrl(txid) {
+    return `https://mempool.space/tx/${txid}`;
+}
 export function writeMutationTextResult(stream, options) {
     writeLine(stream, options.heading);
     for (const field of options.fields) {
@@ -13,4 +16,8 @@ export function writeMutationTextResult(stream, options) {
     for (const line of options.trailerLines ?? []) {
         writeLine(stream, line);
     }
+    if (options.interactive === true && options.explorerTxid) {
+        writeLine(stream, "");
+        writeLine(stream, `View at: ${mutationExplorerUrl(options.explorerTxid)}`);
+    }
 }

package/dist/cli/output.js

@@ -188,7 +188,8 @@ export function classifyCliError(error) {
 }
 function isBlockedError(message) {
     if (message === "wallet_control_lock_busy"
-        || message.startsWith("file_lock_busy_")) {
+        || message.startsWith("file_lock_busy_")
+        || message.startsWith("wallet_anchor_clear_pending_first_")) {
         return true;
     }
     if (message === "wallet_locked"
@@ -439,6 +440,14 @@ export function createCliErrorPresentation(errorCode, fallbackMessage) {
             next: "Run `cogcoin repair`, then inspect the domain again before retrying `cogcoin anchor clear`.",
         };
     }
+    if (errorCode.startsWith("wallet_anchor_clear_pending_first_")) {
+        const domainName = errorCode.slice("wallet_anchor_clear_pending_first_".length) || "<domain>";
+        return {
+            what: `A local pending anchor already exists for "${domainName}".`,
+            why: "The wallet found a same-domain anchor reservation that is still local-only and safely clearable, so it stopped before creating a conflicting family.",
+            next: `Run \`cogcoin anchor clear ${domainName}\`, then rerun \`cogcoin anchor ${domainName}\`.`,
+        };
+    }
     if (errorCode.startsWith("wallet_anchor_clear_not_clearable_")) {
         return {
             what: "Pending anchor cannot be cleared safely.",
@@ -488,6 +497,18 @@ export function createCliErrorPresentation(errorCode, fallbackMessage) {
             next: "Rerun the command and confirm it. If this command uses a plain yes/no path, you can also add `--yes`.",
         };
     }
+    if (errorCode === "wallet_anchor_invalid_message" || errorCode.startsWith("wallet_anchor_invalid_message_")) {
+        const reason = errorCode.startsWith("wallet_anchor_invalid_message_")
+            ? errorCode.slice("wallet_anchor_invalid_message_".length).trim()
+            : null;
+        return {
+            what: "Founding message cannot be encoded in canonical Coglex.",
+            why: reason === null || reason === ""
+                ? "The supplied founding message could not be encoded into the canonical on-chain Coglex sentence format."
+                : reason,
+            next: "Retry with a different founding message, or rerun `cogcoin anchor <domain>` without `--message` to skip it.",
+        };
+    }
     if (errorCode === "wallet_prompt_value_required") {
         return {
             what: "Required input was not provided.",

package/dist/cli/types.d.ts

@@ -1,5 +1,6 @@
 import type { inspectPassiveClientStatus } from "../passive-status.js";
 import { createRpcClient } from "../bitcoind/node.js";
+import type { ManagedBitcoindProgressEvent } from "../bitcoind/types.js";
 import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, stopIndexerDaemonService } from "../bitcoind/indexer-daemon.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService } from "../bitcoind/service.js";
 import { openSqliteStore } from "../sqlite/index.js";
@@ -99,6 +100,7 @@ export interface CliRunnerContext {
         dataDir?: string;
         walletRootId?: string;
         progressOutput?: ProgressOutput;
+        onProgress?: (event: ManagedBitcoindProgressEvent) => void;
         confirmGetblockArchiveRestart?: (options: {
             currentArchiveEndHeight: number | null;
             nextArchiveEndHeight: number;

package/dist/cli/wallet-format.d.ts

@@ -1,7 +1,7 @@
 import type { WalletDomainView, WalletReadContext } from "../wallet/read/index.js";
 export declare function getRepairRecommendation(context: WalletReadContext): string | null;
 export declare function getMutationRecommendation(context: WalletReadContext): string | null;
-export declare function formatWalletOverviewReport(context: WalletReadContext): string;
+export declare function formatWalletOverviewReport(context: WalletReadContext, version: string): string;
 export declare function formatDetailedWalletStatusReport(context: WalletReadContext): string;
 export declare function formatFundingAddressReport(context: WalletReadContext): string;
 export declare function formatIdentityListReport(context: WalletReadContext, options?: {

package/dist/cli/wallet-format.js

@@ -459,9 +459,9 @@ function getOverviewNextStep(context) {
     }
     return getMutationRecommendation(context);
 }
-export function formatWalletOverviewReport(context) {
+export function formatWalletOverviewReport(context, version) {
     const parts = [
-        "\n⛭ Cogcoin Status ⛭",
+        `\n⛭ Cogcoin Status v${version} ⛭`,
         formatOverviewSection("Paths", buildOverviewPathsSection(context)),
         formatOverviewSection("Wallet", buildOverviewWalletSection(context)),
         formatOverviewSection("Services", buildOverviewServicesSection(context)),

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

@@ -2,7 +2,7 @@ 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 declare const DEFAULT_PROACTIVE_RESERVE_SATS = 1000;
 export interface WalletCoinControlRpc {
     listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
     listLockUnspent(walletName: string): Promise<RpcLockedUnspent[]>;

package/dist/wallet/coin-control.js

@@ -1,7 +1,7 @@
 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;
+export const DEFAULT_PROACTIVE_RESERVE_SATS = 1_000;
 function btcNumberToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }
@@ -33,7 +33,11 @@ function normalizeReserveSats(raw) {
     if (typeof raw !== "number" || !Number.isFinite(raw)) {
         return DEFAULT_PROACTIVE_RESERVE_SATS;
     }
-    return Math.max(0, Math.trunc(raw));
+    const normalized = Math.max(0, Math.trunc(raw));
+    if (normalized === 0) {
+        return 0;
+    }
+    return DEFAULT_PROACTIVE_RESERVE_SATS;
 }
 function sameOutpointList(left, right) {
     if (left.length !== (right?.length ?? 0)) {
@@ -42,8 +46,12 @@ function sameOutpointList(left, right) {
     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 rawProactiveReserveSats = state.proactiveReserveSats;
+    const proactiveReserveSats = normalizeReserveSats(rawProactiveReserveSats);
+    const reserveValueChanged = proactiveReserveSats !== rawProactiveReserveSats;
+    const proactiveReserveOutpoints = normalizeOutpointRecordList(proactiveReserveSats <= 0 || reserveValueChanged
+        ? []
+        : state.proactiveReserveOutpoints);
     const pendingMutations = state.pendingMutations ?? [];
     if (proactiveReserveSats === state.proactiveReserveSats
         && sameOutpointList(proactiveReserveOutpoints, state.proactiveReserveOutpoints)
@@ -58,8 +66,12 @@ export function normalizeWalletStateRecord(state) {
     };
 }
 export function normalizePortableWalletArchivePayload(payload) {
-    const proactiveReserveSats = normalizeReserveSats(payload.proactiveReserveSats);
-    const proactiveReserveOutpoints = normalizeOutpointRecordList(payload.proactiveReserveOutpoints);
+    const rawProactiveReserveSats = payload.proactiveReserveSats;
+    const proactiveReserveSats = normalizeReserveSats(rawProactiveReserveSats);
+    const reserveValueChanged = proactiveReserveSats !== rawProactiveReserveSats;
+    const proactiveReserveOutpoints = normalizeOutpointRecordList(proactiveReserveSats <= 0 || reserveValueChanged
+        ? []
+        : payload.proactiveReserveOutpoints);
     if (proactiveReserveSats === payload.proactiveReserveSats
         && sameOutpointList(proactiveReserveOutpoints, payload.proactiveReserveOutpoints)) {
         return payload;
@@ -161,6 +173,9 @@ export function computeDesignatedProactiveReserveOutpoints(state, spendableUtxos
             break;
         }
     }
+    if (total < target) {
+        return [];
+    }
     return selected;
 }
 function syncStateWithComputedReserve(state, spendableUtxos) {
@@ -275,8 +290,11 @@ function collectPersistentPolicyLockedOutpoints(state, spendableUtxos) {
     return outpoints;
 }
 export async function reconcilePersistentPolicyLocks(options) {
+    const rawReserveOutpoints = normalizeOutpointRecordList(options.state.proactiveReserveOutpoints);
     let state = normalizeWalletStateRecord(options.state);
     let changed = state !== options.state;
+    const fixedInputKeys = new Set((options.fixedInputs ?? []).map((outpoint) => outpointKey(outpoint)));
+    const temporarilyUnlockedKeys = new Set((options.temporarilyUnlockedOutpoints ?? []).map((outpoint) => outpointKey(outpoint)));
     if (options.cleanupInactiveTemporaryBuilderLocks === true) {
         const cleaned = collectInactiveTemporaryBuilderLockCleanup(state);
         state = cleaned.state;
@@ -285,12 +303,24 @@ export async function reconcilePersistentPolicyLocks(options) {
             await options.rpc.lockUnspent(options.walletName, true, cleaned.staleOutpoints).catch(() => undefined);
         }
     }
-    const spendableUtxos = options.spendableUtxos ?? await options.rpc.listUnspent(options.walletName, 0).catch(() => []);
+    const lockedBeforeReserveInspection = await options.rpc.listLockUnspent(options.walletName).catch(() => []);
+    const lockedBeforeReserveInspectionKeys = new Set(lockedBeforeReserveInspection.map((outpoint) => outpointKey(outpoint)));
+    const reserveInspectionUnlocks = rawReserveOutpoints.filter((outpoint) => {
+        const key = outpointKey(outpoint);
+        return lockedBeforeReserveInspectionKeys.has(key) && !fixedInputKeys.has(key);
+    });
+    if (reserveInspectionUnlocks.length > 0) {
+        await options.rpc.lockUnspent(options.walletName, true, reserveInspectionUnlocks).catch(() => undefined);
+    }
+    const spendableUtxos = reserveInspectionUnlocks.length > 0 || options.spendableUtxos === undefined
+        ? await options.rpc.listUnspent(options.walletName, 0).catch(() => [])
+        : options.spendableUtxos;
+    const previouslyProtectedUniverse = collectPersistentPolicyLockedOutpoints(state, spendableUtxos);
     const reserveSynced = syncStateWithComputedReserve(state, spendableUtxos);
     state = reserveSynced.state;
     changed ||= reserveSynced.changed;
     const protectedUniverse = collectPersistentPolicyLockedOutpoints(state, spendableUtxos);
-    if (protectedUniverse.length === 0) {
+    if (protectedUniverse.length === 0 && previouslyProtectedUniverse.length === 0) {
         return {
             state,
             changed,
@@ -298,19 +328,30 @@ export async function reconcilePersistentPolicyLocks(options) {
         };
     }
     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 previouslyProtectedUniverseKeys = new Set(previouslyProtectedUniverse.map((outpoint) => outpointKey(outpoint)));
+    const managedProtectedKeys = new Set([
+        ...protectedUniverseKeys,
+        ...previouslyProtectedUniverseKeys,
+    ]);
     const locked = await options.rpc.listLockUnspent(options.walletName).catch(() => []);
     const spendableKeys = new Set(spendableUtxos.map((entry) => outpointKey(entry)));
+    const lockedKeys = new Set(locked.map((outpoint) => outpointKey(outpoint)));
     const expectedLocked = protectedUniverse.filter((outpoint) => {
         const key = outpointKey(outpoint);
-        return spendableKeys.has(key) && !fixedInputKeys.has(key) && !temporarilyUnlockedKeys.has(key);
+        return (spendableKeys.has(key) || lockedKeys.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)));
+    const lockedManaged = locked.filter((outpoint) => managedProtectedKeys.has(outpointKey(outpoint)));
+    const staleLocked = lockedManaged.filter((outpoint) => !expectedLockedKeys.has(outpointKey(outpoint)));
+    const missingLocked = protectedUniverse.filter((outpoint) => {
+        const key = outpointKey(outpoint);
+        return spendableKeys.has(key)
+            && !fixedInputKeys.has(key)
+            && !temporarilyUnlockedKeys.has(key)
+            && !lockedKeys.has(key);
+    });
     if (staleLocked.length > 0) {
         await options.rpc.lockUnspent(options.walletName, true, staleLocked).catch(() => undefined);
     }

package/dist/wallet/tx/anchor.d.ts

@@ -18,6 +18,7 @@ interface WalletAnchorRpcClient extends WalletMutationRpcClient {
 export interface AnchorDomainOptions {
     domainName: string;
     foundingMessageText?: string | null;
+    promptForFoundingMessageWhenMissing?: boolean;
     dataDir: string;
     databasePath: string;
     provider?: WalletSecretProvider;
@@ -36,6 +37,7 @@ export interface AnchorDomainResult {
     dedicatedIndex: number;
     status: "live" | "confirmed";
     reusedExisting: boolean;
+    foundingMessageText?: string | null;
 }
 export interface ClearPendingAnchorOptions {
     domainName: string;