@cogcoin/client 0.5.6 → 0.5.8

package/dist/wallet/tx/anchor.js

@@ -10,6 +10,7 @@ import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeDomainAnchor, serializeDomainTransfer, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
 import { assertWalletMutationContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, } from "./common.js";
+import { confirmYesNo } from "./confirm.js";
 const ACTIVE_FAMILY_STATUSES = new Set([
     "draft",
     "broadcasting",
@@ -117,21 +118,62 @@ function findActiveAnchorFamilyByDomain(state, domainName) {
 function findAnchorFamilyById(state, familyId) {
     return state.proactiveFamilies.find((family) => family.familyId === familyId) ?? null;
 }
-function selectNextDedicatedIdentityTarget(state) {
+function collectActivelyReservedDedicatedIndices(state) {
     const reservedIndices = new Set();
     for (const domain of state.domains) {
-        if (domain.dedicatedIndex !== null) {
+        if (domain.dedicatedIndex !== null && domain.localAnchorIntent !== "none") {
             reservedIndices.add(domain.dedicatedIndex);
         }
     }
     for (const family of state.proactiveFamilies) {
-        if (family.type === "anchor" && family.reservedDedicatedIndex !== null && family.reservedDedicatedIndex !== undefined) {
+        if (family.type === "anchor"
+            && ACTIVE_FAMILY_STATUSES.has(family.status)
+            && family.reservedDedicatedIndex !== null
+            && family.reservedDedicatedIndex !== undefined) {
             reservedIndices.add(family.reservedDedicatedIndex);
         }
     }
+    return reservedIndices;
+}
+function selectReusableDedicatedIdentityTarget(state) {
+    const reservedIndices = collectActivelyReservedDedicatedIndices(state);
+    const reusableIdentity = state.identities
+        .filter((identity) => identity.status === "dedicated"
+        && identity.address !== null
+        && identity.assignedDomainNames.length === 0
+        && !reservedIndices.has(identity.index))
+        .sort((left, right) => left.index - right.index)[0];
+    if (reusableIdentity == null) {
+        return null;
+    }
+    const material = deriveWalletIdentityMaterial(state.keys.accountXprv, reusableIdentity.index);
+    const reusableAddress = reusableIdentity.address;
+    if (reusableAddress === null) {
+        return null;
+    }
+    return {
+        ...material,
+        localIndex: reusableIdentity.index,
+        address: reusableAddress,
+        scriptPubKeyHex: reusableIdentity.scriptPubKeyHex,
+    };
+}
+function selectFreshDedicatedIdentityTarget(state) {
+    const unavailableIndices = new Set();
+    for (const identity of state.identities) {
+        unavailableIndices.add(identity.index);
+    }
+    for (const domain of state.domains) {
+        if (domain.dedicatedIndex !== null) {
+            unavailableIndices.add(domain.dedicatedIndex);
+        }
+    }
+    for (const index of collectActivelyReservedDedicatedIndices(state)) {
+        unavailableIndices.add(index);
+    }
     const startIndex = Math.max(1, state.nextDedicatedIndex);
     for (let index = startIndex; index <= state.descriptor.rangeEnd; index += 1) {
-        if (reservedIndices.has(index)) {
+        if (unavailableIndices.has(index)) {
             continue;
         }
         const material = deriveWalletIdentityMaterial(state.keys.accountXprv, index);
@@ -142,6 +184,20 @@ function selectNextDedicatedIdentityTarget(state) {
     }
     throw new Error("wallet_anchor_no_fresh_dedicated_index");
 }
+function selectNextDedicatedIdentityTarget(state) {
+    return selectReusableDedicatedIdentityTarget(state) ?? selectFreshDedicatedIdentityTarget(state);
+}
+function deriveAnchorTargetIdentityForIndex(state, localIndex) {
+    const existingIdentity = state.identities.find((identity) => identity.index === localIndex
+        && identity.address !== null) ?? null;
+    const material = deriveWalletIdentityMaterial(state.keys.accountXprv, localIndex);
+    return {
+        ...material,
+        localIndex,
+        address: existingIdentity?.address ?? material.address,
+        scriptPubKeyHex: existingIdentity?.scriptPubKeyHex ?? material.scriptPubKeyHex,
+    };
+}
 function encodeFoundingMessage(foundingMessageText) {
     const trimmed = foundingMessageText?.trim() ?? "";
     if (trimmed === "") {
@@ -190,6 +246,17 @@ async function confirmAnchor(prompter, operation) {
         throw new Error("wallet_anchor_confirmation_rejected");
     }
 }
+async function confirmAnchorClear(prompter, domainName, dedicatedIndex, assumeYes = false) {
+    const releaseLine = dedicatedIndex === null
+        ? "This will cancel the local pending anchor reservation."
+        : `This will cancel the local pending anchor reservation and release dedicated index ${dedicatedIndex} for reuse.`;
+    await confirmYesNo(prompter, releaseLine, {
+        assumeYes,
+        errorCode: "wallet_anchor_clear_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_anchor_clear_requires_tty",
+        prompt: `Clear pending anchor for "${domainName}"? [y/N]: `,
+    });
+}
 function resolveAnchorOperation(context, domainName, foundingMessageText, foundingMessagePayloadHex) {
     assertWalletMutationContextReady(context, "wallet_anchor");
     const chainDomain = lookupDomain(context.snapshot.state, domainName);
@@ -231,6 +298,41 @@ function resolveAnchorOperation(context, domainName, foundingMessageText, foundi
         hadListing: getListing(context.snapshot.state, chainDomain.domainId) !== null,
     };
 }
+function releaseClearedAnchorReservationState(options) {
+    const family = findAnchorFamilyById(options.state, options.familyId);
+    const domains = options.state.domains.map((domain) => {
+        if (domain.name !== options.domainName) {
+            return domain;
+        }
+        return {
+            ...domain,
+            dedicatedIndex: null,
+            localAnchorIntent: "none",
+        };
+    });
+    const nextState = {
+        ...options.state,
+        domains,
+    };
+    if (family === null) {
+        return nextState;
+    }
+    return upsertProactiveFamily(nextState, {
+        ...family,
+        status: "canceled",
+        lastUpdatedAtUnixMs: options.nowUnixMs,
+        tx1: family.tx1 == null ? family.tx1 : {
+            ...family.tx1,
+            status: "canceled",
+            temporaryBuilderLockedOutpoints: [],
+        },
+        tx2: family.tx2 == null ? family.tx2 : {
+            ...family.tx2,
+            status: "canceled",
+            temporaryBuilderLockedOutpoints: [],
+        },
+    });
+}
 function createFamilyTransactionRecord() {
     return {
         status: "draft",
@@ -1020,10 +1122,7 @@ export async function anchorDomain(options) {
             let workingState = operation.state;
             if (existingFamily !== null) {
                 const existingReservedIndex = existingFamily.reservedDedicatedIndex ?? operation.targetIdentity.localIndex;
-                const existingTargetIdentity = {
-                    ...deriveWalletIdentityMaterial(operation.state.keys.accountXprv, existingReservedIndex),
-                    localIndex: existingReservedIndex,
-                };
+                const existingTargetIdentity = deriveAnchorTargetIdentityForIndex(operation.state, existingReservedIndex);
                 const reconciled = await reconcileAnchorFamily({
                     state: operation.state,
                     family: existingFamily,
@@ -1209,3 +1308,97 @@ export async function anchorDomain(options) {
         await controlLock.release();
     }
 }
+export async function clearPendingAnchor(options) {
+    const provider = options.provider ?? createDefaultWalletSecretProvider();
+    const nowUnixMs = options.nowUnixMs ?? Date.now();
+    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    const controlLock = await acquireFileLock(paths.walletControlLockPath, {
+        purpose: "wallet-anchor-clear",
+        walletRootId: null,
+    });
+    const normalizedDomainName = normalizeDomainName(options.domainName);
+    try {
+        const miningPreemption = await pauseMiningForWalletMutation({
+            paths,
+            reason: "wallet-anchor-clear",
+        });
+        const readContext = await (options.openReadContext ?? openWalletReadContext)({
+            dataDir: options.dataDir,
+            databasePath: options.databasePath,
+            secretProvider: provider,
+            walletControlLockHeld: true,
+            paths,
+        });
+        try {
+            assertWalletMutationContextReady(readContext, "wallet_anchor_clear");
+            const family = findActiveAnchorFamilyByDomain(readContext.localState.state, normalizedDomainName);
+            const domain = readContext.localState.state.domains.find((entry) => entry.name === normalizedDomainName) ?? null;
+            if (domain === null && family === null) {
+                throw new Error("wallet_anchor_clear_domain_not_found");
+            }
+            if (family === null) {
+                if (domain === null) {
+                    throw new Error("wallet_anchor_clear_domain_not_found");
+                }
+                if (domain.localAnchorIntent !== "none") {
+                    throw new Error("wallet_anchor_clear_inconsistent_state");
+                }
+                return {
+                    domainName: normalizedDomainName,
+                    cleared: false,
+                    previousFamilyStatus: null,
+                    previousFamilyStep: null,
+                    releasedDedicatedIndex: null,
+                };
+            }
+            if (family.type !== "anchor") {
+                throw new Error("wallet_anchor_clear_inconsistent_state");
+            }
+            if (family.status !== "draft" || family.currentStep !== "reserved") {
+                throw new Error(`wallet_anchor_clear_not_clearable_${family.status}`);
+            }
+            const reservedDedicatedIndex = family.reservedDedicatedIndex ?? null;
+            if (reservedDedicatedIndex === null
+                || family.tx1?.attemptedTxid !== null
+                || family.tx2?.attemptedTxid !== null
+                || (domain !== null
+                    && (domain.localAnchorIntent !== "reserved"
+                        || domain.dedicatedIndex === null
+                        || domain.dedicatedIndex !== reservedDedicatedIndex))) {
+                throw new Error("wallet_anchor_clear_inconsistent_state");
+            }
+            await confirmAnchorClear(options.prompter, normalizedDomainName, reservedDedicatedIndex, options.assumeYes ?? false);
+            const releasedState = releaseClearedAnchorReservationState({
+                state: readContext.localState.state,
+                familyId: family.familyId,
+                domainName: normalizedDomainName,
+                nowUnixMs,
+            });
+            await saveWalletStatePreservingUnlock({
+                state: {
+                    ...releasedState,
+                    stateRevision: releasedState.stateRevision + 1,
+                    lastWrittenAtUnixMs: nowUnixMs,
+                },
+                provider,
+                unlockUntilUnixMs: readContext.localState.unlockUntilUnixMs,
+                nowUnixMs,
+                paths,
+            });
+            return {
+                domainName: normalizedDomainName,
+                cleared: true,
+                previousFamilyStatus: family.status,
+                previousFamilyStep: family.currentStep ?? null,
+                releasedDedicatedIndex: reservedDedicatedIndex,
+            };
+        }
+        finally {
+            await readContext.close();
+            await miningPreemption.release();
+        }
+    }
+    finally {
+        await controlLock.release();
+    }
+}

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

@@ -1,7 +1,7 @@
 export { extractOpReturnPayloadFromScriptHex, registerDomain, type RegisterDomainResult, } from "./register.js";
 export { buyDomain, parseCogAmountToCogtoshi, sellDomain, transferDomain, type DomainMarketMutationResult, } from "./domain-market.js";
 export { claimCogLock, lockCogToDomain, reclaimCogLock, sendCog, type CogMutationResult, } from "./cog.js";
-export { anchorDomain, type AnchorDomainResult, } from "./anchor.js";
+export { anchorDomain, clearPendingAnchor, type AnchorDomainResult, type ClearPendingAnchorResult, } from "./anchor.js";
 export { clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, type DomainAdminMutationResult, } from "./domain-admin.js";
 export { clearField, createField, setField, type ClearFieldOptions, type CreateFieldOptions, type FieldMutationResult, type FieldValueInputSource, type SetFieldOptions, } from "./field.js";
 export { giveReputation, revokeReputation, type GiveReputationOptions, type ReputationMutationResult, type RevokeReputationOptions, } from "./reputation.js";

package/dist/wallet/tx/index.js

@@ -1,7 +1,7 @@
 export { extractOpReturnPayloadFromScriptHex, registerDomain, } from "./register.js";
 export { buyDomain, parseCogAmountToCogtoshi, sellDomain, transferDomain, } from "./domain-market.js";
 export { claimCogLock, lockCogToDomain, reclaimCogLock, sendCog, } from "./cog.js";
-export { anchorDomain, } from "./anchor.js";
+export { anchorDomain, clearPendingAnchor, } from "./anchor.js";
 export { clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, } from "./domain-admin.js";
 export { clearField, createField, setField, } from "./field.js";
 export { giveReputation, revokeReputation, } from "./reputation.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",