@cogcoin/client 0.5.7 → 0.5.8

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@0.5.7` 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.8` 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/factory.js

@@ -97,7 +97,15 @@ async function createManagedBitcoindClient(options) {
         // The persistent service may already exist from a non-processing attach path
         // that used startHeight 0. Cogcoin replay still begins at the requested
         // processing boundary for this managed client.
-        return new DefaultManagedBitcoindClient(client, options.store, node, rpc, progress, bootstrap, indexerDaemon, options.startHeight, options.syncDebounceMs ?? DEFAULT_SYNC_DEBOUNCE_MS);
+        const databasePath = options.databasePath ?? null;
+        return new DefaultManagedBitcoindClient(client, options.store, node, rpc, progress, bootstrap, indexerDaemon, databasePath
+            ? async () => attachOrStartIndexerDaemon({
+                dataDir,
+                databasePath,
+                walletRootId: options.walletRootId,
+                startupTimeoutMs: options.startupTimeoutMs,
+            })
+            : null, options.startHeight, options.syncDebounceMs ?? DEFAULT_SYNC_DEBOUNCE_MS);
     }
     catch (error) {
         if (progressStarted) {

package/dist/bitcoind/client/managed-client.d.ts

@@ -7,7 +7,7 @@ import type { BitcoinRpcClient } from "../rpc.js";
 import type { ManagedBitcoindClient, ManagedBitcoindNodeHandle, ManagedBitcoindStatus, SyncResult } from "../types.js";
 export declare class DefaultManagedBitcoindClient implements ManagedBitcoindClient {
     #private;
-    constructor(client: Client, store: ClientStoreAdapter, node: ManagedBitcoindNodeHandle, rpc: BitcoinRpcClient, progress: ManagedProgressController, bootstrap: AssumeUtxoBootstrapController, indexerDaemon: IndexerDaemonClient | null, startHeight: number, syncDebounceMs: number);
+    constructor(client: Client, store: ClientStoreAdapter, node: ManagedBitcoindNodeHandle, rpc: BitcoinRpcClient, progress: ManagedProgressController, bootstrap: AssumeUtxoBootstrapController, indexerDaemon: IndexerDaemonClient | null, reattachIndexerDaemon: (() => Promise<IndexerDaemonClient | null>) | null, startHeight: number, syncDebounceMs: number);
     getTip(): Promise<import("../../types.js").ClientTip | null>;
     getState(): Promise<import("@cogcoin/indexer/types").IndexerState>;
     applyBlock(block: BitcoinBlock): Promise<import("../../types.js").ApplyBlockResult>;

package/dist/bitcoind/client/managed-client.js

@@ -10,6 +10,7 @@ export class DefaultManagedBitcoindClient {
     #progress;
     #bootstrap;
     #indexerDaemon;
+    #reattachIndexerDaemon;
     #startHeight;
     #syncDebounceMs;
     #following = false;
@@ -22,7 +23,7 @@ export class DefaultManagedBitcoindClient {
     #syncPromise = Promise.resolve(createInitialSyncResult());
     #debounceTimer = null;
     #syncAbortControllers = new Set();
-    constructor(client, store, node, rpc, progress, bootstrap, indexerDaemon, startHeight, syncDebounceMs) {
+    constructor(client, store, node, rpc, progress, bootstrap, indexerDaemon, reattachIndexerDaemon, startHeight, syncDebounceMs) {
         this.#client = client;
         this.#store = store;
         this.#node = node;
@@ -30,6 +31,7 @@ export class DefaultManagedBitcoindClient {
         this.#progress = progress;
         this.#bootstrap = bootstrap;
         this.#indexerDaemon = indexerDaemon;
+        this.#reattachIndexerDaemon = reattachIndexerDaemon;
         this.#startHeight = startHeight;
         this.#syncDebounceMs = syncDebounceMs;
     }
@@ -177,7 +179,7 @@ export class DefaultManagedBitcoindClient {
         await this.#progress.close();
         await this.#node.stop();
         await this.#client.close();
-        await this.#indexerDaemon?.resumeBackgroundFollow().catch(() => undefined);
+        await this.#resumeIndexerBackgroundFollow();
         await this.#indexerDaemon?.close();
     }
     async playSyncCompletionScene() {
@@ -209,4 +211,21 @@ export class DefaultManagedBitcoindClient {
             throw new Error("managed_bitcoind_client_closed");
         }
     }
+    async #resumeIndexerBackgroundFollow() {
+        if (this.#indexerDaemon === null) {
+            return;
+        }
+        try {
+            await this.#indexerDaemon.resumeBackgroundFollow();
+            return;
+        }
+        catch (error) {
+            if (this.#reattachIndexerDaemon === null) {
+                throw error;
+            }
+        }
+        const replacementDaemon = await this.#reattachIndexerDaemon();
+        this.#indexerDaemon = replacementDaemon;
+        await replacementDaemon?.resumeBackgroundFollow();
+    }
 }

package/dist/bitcoind/service.js

@@ -226,8 +226,7 @@ async function waitForRpcReady(rpc, cookieFile, expectedChain, timeoutMs) {
     throw lastError instanceof Error ? lastError : new Error("bitcoind_rpc_timeout");
 }
 function validateManagedBitcoindStatus(status, options, runtimeRoot) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const legacyRuntimeRoot = join(resolveManagedServicePaths(options.dataDir ?? "", walletRootId).runtimeRoot, walletRootId);
+    const legacyRuntimeRoot = join(resolveManagedServicePaths(options.dataDir ?? "", options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID).runtimeRoot, status.walletRootId);
     if (status.serviceApiVersion !== MANAGED_BITCOIND_SERVICE_API_VERSION_VALUE) {
         throw new Error("managed_bitcoind_service_version_mismatch");
     }

package/dist/bitcoind/testing.d.ts

@@ -1,4 +1,5 @@
 export { openManagedBitcoindClientInternal } from "./client.js";
+export { DefaultManagedBitcoindClient } from "./client/managed-client.js";
 export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopIndexerDaemonService, shutdownIndexerDaemonForTesting, } from "./indexer-daemon.js";
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";

package/dist/bitcoind/testing.js

@@ -1,4 +1,5 @@
 export { openManagedBitcoindClientInternal } from "./client.js";
+export { DefaultManagedBitcoindClient } from "./client/managed-client.js";
 export { attachOrStartIndexerDaemon, readIndexerDaemonStatusForTesting, stopIndexerDaemonService, shutdownIndexerDaemonForTesting, } from "./indexer-daemon.js";
 export { normalizeRpcBlock } from "./normalize.js";
 export { BitcoinRpcClient } from "./rpc.js";

package/dist/cli/output.js

@@ -169,6 +169,12 @@ export function classifyCliError(error) {
     if (message === "wallet_import_archive_not_found") {
         return { exitCode: 3, errorCode: message, message };
     }
+    if (message === "wallet_seed_not_found") {
+        return { exitCode: 3, errorCode: message, message };
+    }
+    if (message === "wallet_seed_index_invalid") {
+        return { exitCode: 4, errorCode: message, message };
+    }
     if (message === "reset_process_shutdown_failed"
         || message === "reset_data_root_delete_failed"
         || message === "reset_secret_cleanup_failed"
@@ -331,6 +337,13 @@ export function createCliErrorPresentation(errorCode, fallbackMessage) {
             next: "Check `--seed <name>` and retry.",
         };
     }
+    if (errorCode === "wallet_seed_index_invalid") {
+        return {
+            what: "Wallet seed registry is invalid.",
+            why: "Cogcoin could not parse or trust the local seed registry file, so it cannot safely decide which named wallet seed to use.",
+            next: "Run `cogcoin repair`, then retry the command.",
+        };
+    }
     if (errorCode === "wallet_delete_main_not_supported") {
         return {
             what: "The main wallet cannot be deleted with `wallet delete`.",

package/dist/cli/runner.js

@@ -12,6 +12,14 @@ import { runSyncCommand } from "./commands/sync.js";
 import { runWalletAdminCommand } from "./commands/wallet-admin.js";
 import { runWalletMutationCommand } from "./commands/wallet-mutation.js";
 import { runWalletReadCommand } from "./commands/wallet-read.js";
+import { findWalletSeedRecord, loadWalletSeedIndex } from "../wallet/state/seed-index.js";
+function commandUsesExistingWalletSeed(parsed) {
+    return parsed.seedName !== null
+        && parsed.seedName !== "main"
+        && parsed.command !== "restore"
+        && parsed.command !== "wallet-delete"
+        && parsed.command !== "wallet-restore";
+}
 export async function runCli(argv, contextOverrides = {}) {
     const context = createDefaultContext(contextOverrides);
     let parsed;
@@ -41,6 +49,15 @@ export async function runCli(argv, contextOverrides = {}) {
         return parsed.help ? 0 : 2;
     }
     try {
+        if (commandUsesExistingWalletSeed(parsed)) {
+            const mainPaths = context.resolveWalletRuntimePaths("main");
+            const seedIndex = await loadWalletSeedIndex({
+                paths: mainPaths,
+            });
+            if (seedIndex.seeds.length > 0 && findWalletSeedRecord(seedIndex, parsed.seedName) === null) {
+                throw new Error("wallet_seed_not_found");
+            }
+        }
         if (parsed.command === "sync") {
             return runSyncCommand(parsed, context);
         }

package/dist/cli/signals.js

@@ -19,7 +19,7 @@ export function createStopSignalWatcher(signalSource, stderr, client, forceExit)
         };
         const onFirstSignal = () => {
             closing = true;
-            writeLine(stderr, "Stopping managed Cogcoin client...");
+            writeLine(stderr, "Detaching from managed Cogcoin client...");
             void client.close().then(() => {
                 settle(0);
             }, () => {

package/dist/wallet/lifecycle.d.ts

@@ -227,6 +227,9 @@ export declare function deleteImportedWalletSeed(options: {
     assumeYes?: boolean;
     nowUnixMs?: number;
     paths?: WalletRuntimePaths;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    probeBitcoindService?: typeof probeManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
 }): Promise<WalletDeleteResult>;
 export declare function repairWallet(options: {
     dataDir: string;

package/dist/wallet/lifecycle.js

@@ -1623,6 +1623,31 @@ export async function deleteImportedWalletSeed(options) {
         if (!options.assumeYes) {
             await confirmYesNo(options.prompter, `Delete imported seed "${seedName}" and release its local wallet artifacts? Type yes to continue: `);
         }
+        const probeManagedBitcoind = options.probeBitcoindService ?? probeManagedBitcoindService;
+        const managedBitcoindProbe = await probeManagedBitcoind({
+            dataDir: options.dataDir,
+            chain: "main",
+            startHeight: 0,
+        }).catch(() => ({
+            compatibility: "unreachable",
+            status: null,
+            error: null,
+        }));
+        if (managedBitcoindProbe.compatibility !== "compatible" && managedBitcoindProbe.compatibility !== "unreachable") {
+            throw new Error(managedBitcoindProbe.error ?? "managed_bitcoind_protocol_error");
+        }
+        if (managedBitcoindProbe.compatibility === "compatible") {
+            const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
+                dataDir: options.dataDir,
+                chain: "main",
+                startHeight: 0,
+            });
+            const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
+            const walletName = sanitizeWalletName(seedRecord.walletRootId);
+            if (rpc.unloadWallet != null) {
+                await rpc.unloadWallet(walletName, false).catch(() => undefined);
+            }
+        }
         await clearUnlockSession(paths.walletUnlockSessionPath).catch(() => undefined);
         await clearWalletExplicitLock(paths.walletExplicitLockPath).catch(() => undefined);
         await clearPendingInitialization(paths, provider).catch(() => undefined);

package/dist/wallet/state/seed-index.js

@@ -28,7 +28,7 @@ async function readSeedIndexFile(path) {
         if (error instanceof Error && "code" in error && error.code === "ENOENT") {
             return null;
         }
-        throw error;
+        throw new Error("wallet_seed_index_invalid");
     }
 }
 export function normalizeWalletSeedName(name) {

package/dist/wallet/tx/anchor.js

@@ -319,7 +319,18 @@ function releaseClearedAnchorReservationState(options) {
     }
     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() {
@@ -1320,12 +1331,15 @@ export async function clearPendingAnchor(options) {
         });
         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) {
+            if (domain === null && family === null) {
                 throw new Error("wallet_anchor_clear_domain_not_found");
             }
-            const family = findActiveAnchorFamilyByDomain(readContext.localState.state, normalizedDomainName);
             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");
                 }
@@ -1343,47 +1357,19 @@ export async function clearPendingAnchor(options) {
             if (family.status !== "draft" || family.currentStep !== "reserved") {
                 throw new Error(`wallet_anchor_clear_not_clearable_${family.status}`);
             }
-            if (domain.localAnchorIntent !== "reserved"
-                || domain.dedicatedIndex === null
-                || family.reservedDedicatedIndex === null
-                || domain.dedicatedIndex !== family.reservedDedicatedIndex
+            const reservedDedicatedIndex = family.reservedDedicatedIndex ?? null;
+            if (reservedDedicatedIndex === null
                 || family.tx1?.attemptedTxid !== null
-                || family.tx2?.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, family.reservedDedicatedIndex, options.assumeYes ?? false);
-            const operation = resolveAnchorOperation(readContext, normalizedDomainName, family.foundingMessageText ?? null, family.foundingMessagePayloadHex ?? null);
-            const targetIdentity = deriveAnchorTargetIdentityForIndex(readContext.localState.state, family.reservedDedicatedIndex);
-            const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
-                dataDir: options.dataDir,
-                chain: "main",
-                startHeight: 0,
-                walletRootId: readContext.localState.state.walletRootId,
-            });
-            const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
-            const walletName = readContext.localState.state.managedCoreWallet.walletName;
-            const reconciled = await reconcileAnchorFamily({
-                state: readContext.localState.state,
-                family,
-                operation: {
-                    ...operation,
-                    targetIdentity,
-                },
-                provider,
-                nowUnixMs,
-                paths,
-                unlockUntilUnixMs: readContext.localState.unlockUntilUnixMs,
-                rpc,
-                walletName,
-            });
-            if (reconciled.resolution !== "not-seen") {
-                throw new Error(reconciled.resolution === "repair-required"
-                    ? "wallet_anchor_clear_not_clearable_repair_required"
-                    : `wallet_anchor_clear_not_clearable_${reconciled.resolution}`);
-            }
-            const releasedDedicatedIndex = family.reservedDedicatedIndex;
+            await confirmAnchorClear(options.prompter, normalizedDomainName, reservedDedicatedIndex, options.assumeYes ?? false);
             const releasedState = releaseClearedAnchorReservationState({
-                state: reconciled.state,
+                state: readContext.localState.state,
                 familyId: family.familyId,
                 domainName: normalizedDomainName,
                 nowUnixMs,
@@ -1404,7 +1390,7 @@ export async function clearPendingAnchor(options) {
                 cleared: true,
                 previousFamilyStatus: family.status,
                 previousFamilyStep: family.currentStep ?? null,
-                releasedDedicatedIndex,
+                releasedDedicatedIndex: reservedDedicatedIndex,
             };
         }
         finally {

package/package.json

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