@cogcoin/client 1.2.1 → 1.2.2

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@1.2.1` is the reference 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@1.2.2` is the reference 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/managed-bitcoind-service-status.js

@@ -66,7 +66,9 @@ export async function probeManagedBitcoindStatusCandidate(status, options, runti
     const rpc = createRpcClient(status.rpc);
     try {
         await waitForManagedBitcoindRpcReady(rpc, status.rpc.cookieFile, status.chain, options.startupTimeoutMs ?? DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS);
-        await validateNodeConfigForTesting(rpc, status.chain, status.zmq.endpoint);
+        await validateNodeConfigForTesting(rpc, status.chain, status.zmq.endpoint, {
+            requireRawTxZmq: true,
+        });
         return {
             compatibility: "compatible",
             status,
@@ -96,7 +98,9 @@ export async function refreshManagedBitcoindStatus(status, paths, options) {
     const targetWalletRootId = options.walletRootId ?? status.walletRootId;
     try {
         await waitForManagedBitcoindRpcReady(rpc, status.rpc.cookieFile, status.chain, options.startupTimeoutMs ?? DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS);
-        await validateNodeConfigForTesting(rpc, status.chain, status.zmq.endpoint);
+        await validateNodeConfigForTesting(rpc, status.chain, status.zmq.endpoint, {
+            requireRawTxZmq: true,
+        });
         const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, targetWalletRootId, status.dataDir);
         const nextStatus = {
             ...status,

package/dist/wallet/lifecycle/repair-bitcoind.js

@@ -4,7 +4,7 @@ import { persistWalletCoinControlStateIfNeeded } from "../coin-control.js";
 import { createWalletSecretReference } from "../state/provider.js";
 import { recreateManagedCoreWalletReplica, verifyManagedCoreWalletReplica } from "./managed-core.js";
 import { pathExists } from "./context.js";
-import { clearManagedBitcoindArtifacts, mapBitcoindCompatibilityToRepairIssue, mapBitcoindRepairHealth, waitForProcessExit, } from "./repair-runtime.js";
+import { clearManagedBitcoindArtifacts, isManagedBitcoindRpcUnavailableError, mapBitcoindCompatibilityToRepairIssue, mapBitcoindRepairHealth, waitForProcessExit, } from "./repair-runtime.js";
 export async function repairManagedBitcoindStage(options) {
     let state = options.state;
     let repairStateNeedsPersist = options.repairStateNeedsPersist;
@@ -79,74 +79,105 @@ export async function repairManagedBitcoindStage(options) {
     finally {
         await bitcoindLock.release();
     }
-    const bitcoindHandle = await options.context.attachService({
-        dataDir: options.context.dataDir,
-        chain: "main",
-        startHeight: 0,
-        walletRootId: state.walletRootId,
-    });
-    try {
-        const rpc = options.context.rpcFactory(bitcoindHandle.rpc);
-        const normalizedDescriptorState = await normalizeWalletDescriptorState(state, rpc);
-        if (normalizedDescriptorState.changed) {
-            state = normalizedDescriptorState.state;
-            repairStateNeedsPersist = true;
-        }
-        const reconciledCoinControl = await persistWalletCoinControlStateIfNeeded({
-            state,
-            access: {
-                provider: options.context.provider,
-                secretReference: createWalletSecretReference(state.walletRootId),
-            },
-            paths: options.context.paths,
-            nowUnixMs: options.context.nowUnixMs,
-            replacePrimary: options.recoveredFromBackup && !repairStateNeedsPersist,
-            rpc,
-        });
-        state = reconciledCoinControl.state;
-        if (reconciledCoinControl.changed) {
-            repairStateNeedsPersist = false;
-        }
-        let replica = await verifyManagedCoreWalletReplica(state, options.context.dataDir, {
-            nodeHandle: bitcoindHandle,
-            attachService: options.context.attachService,
-            rpcFactory: options.context.rpcFactory,
-        });
-        if (replica.proofStatus !== "ready") {
-            state = await recreateManagedCoreWalletReplica(state, options.context.provider, options.context.paths, options.context.dataDir, options.context.nowUnixMs, {
-                attachService: options.context.attachService,
-                rpcFactory: options.context.rpcFactory,
+    for (let attachAttempt = 0; attachAttempt < 2; attachAttempt += 1) {
+        let bitcoindHandle = null;
+        let handleClosed = false;
+        try {
+            bitcoindHandle = await options.context.attachService({
+                dataDir: options.context.dataDir,
+                chain: "main",
+                startHeight: 0,
+                walletRootId: state.walletRootId,
             });
-            recreatedManagedCoreWallet = true;
-            managedCoreReplicaAction = "recreated";
-            repairStateNeedsPersist = false;
-            replica = await verifyManagedCoreWalletReplica(state, options.context.dataDir, {
+            const rpc = options.context.rpcFactory(bitcoindHandle.rpc);
+            const normalizedDescriptorState = await normalizeWalletDescriptorState(state, rpc);
+            if (normalizedDescriptorState.changed) {
+                state = normalizedDescriptorState.state;
+                repairStateNeedsPersist = true;
+            }
+            const reconciledCoinControl = await persistWalletCoinControlStateIfNeeded({
+                state,
+                access: {
+                    provider: options.context.provider,
+                    secretReference: createWalletSecretReference(state.walletRootId),
+                },
+                paths: options.context.paths,
+                nowUnixMs: options.context.nowUnixMs,
+                replacePrimary: options.recoveredFromBackup && !repairStateNeedsPersist,
+                rpc,
+            });
+            state = reconciledCoinControl.state;
+            if (reconciledCoinControl.changed) {
+                repairStateNeedsPersist = false;
+            }
+            let replica = await verifyManagedCoreWalletReplica(state, options.context.dataDir, {
                 nodeHandle: bitcoindHandle,
                 attachService: options.context.attachService,
                 rpcFactory: options.context.rpcFactory,
             });
+            if (replica.proofStatus !== "ready") {
+                state = await recreateManagedCoreWalletReplica(state, options.context.provider, options.context.paths, options.context.dataDir, options.context.nowUnixMs, {
+                    attachService: options.context.attachService,
+                    rpcFactory: options.context.rpcFactory,
+                });
+                recreatedManagedCoreWallet = true;
+                managedCoreReplicaAction = "recreated";
+                repairStateNeedsPersist = false;
+                replica = await verifyManagedCoreWalletReplica(state, options.context.dataDir, {
+                    nodeHandle: bitcoindHandle,
+                    attachService: options.context.attachService,
+                    rpcFactory: options.context.rpcFactory,
+                });
+            }
+            const finalBitcoindStatus = await bitcoindHandle.refreshServiceStatus?.() ?? null;
+            const chainInfo = await rpc.getBlockchainInfo();
+            bitcoindPostRepairHealth = mapBitcoindRepairHealth({
+                serviceState: finalBitcoindStatus?.state ?? null,
+                catchingUp: chainInfo.blocks < chainInfo.headers,
+                replica,
+            });
+            if (bitcoindServiceAction === "none" && initialBitcoindProbe.compatibility === "unreachable") {
+                bitcoindServiceAction = "restarted-compatible-service";
+            }
+            return {
+                state,
+                repairStateNeedsPersist,
+                recreatedManagedCoreWallet,
+                bitcoindServiceAction,
+                bitcoindCompatibilityIssue,
+                managedCoreReplicaAction,
+                bitcoindPostRepairHealth,
+            };
         }
-        const finalBitcoindStatus = await bitcoindHandle.refreshServiceStatus?.() ?? null;
-        const chainInfo = await rpc.getBlockchainInfo();
-        bitcoindPostRepairHealth = mapBitcoindRepairHealth({
-            serviceState: finalBitcoindStatus?.state ?? null,
-            catchingUp: chainInfo.blocks < chainInfo.headers,
-            replica,
-        });
-        if (bitcoindServiceAction === "none" && initialBitcoindProbe.compatibility === "unreachable") {
-            bitcoindServiceAction = "restarted-compatible-service";
+        catch (error) {
+            if (bitcoindHandle !== null) {
+                await bitcoindHandle.stop?.().catch(() => undefined);
+                handleClosed = true;
+            }
+            if (attachAttempt === 0 && isManagedBitcoindRpcUnavailableError(error)) {
+                const retryLock = await acquireFileLock(options.servicePaths.bitcoindLockPath, {
+                    purpose: "managed-bitcoind-repair-stale-rpc",
+                    walletRootId: state.walletRootId,
+                    dataDir: options.context.dataDir,
+                });
+                try {
+                    await clearManagedBitcoindArtifacts(options.servicePaths);
+                }
+                finally {
+                    await retryLock.release();
+                }
+                if (bitcoindServiceAction === "none") {
+                    bitcoindServiceAction = "restarted-compatible-service";
+                }
+                continue;
+            }
+            throw error;
+        }
+        finally {
+            if (!handleClosed) {
+                await bitcoindHandle?.stop?.().catch(() => undefined);
+            }
         }
     }
-    finally {
-        await bitcoindHandle.stop?.().catch(() => undefined);
-    }
-    return {
-        state,
-        repairStateNeedsPersist,
-        recreatedManagedCoreWallet,
-        bitcoindServiceAction,
-        bitcoindCompatibilityIssue,
-        managedCoreReplicaAction,
-        bitcoindPostRepairHealth,
-    };
+    throw new Error("managed_bitcoind_repair_retry_exhausted");
 }

package/dist/wallet/lifecycle/repair-runtime.d.ts

@@ -29,6 +29,7 @@ export declare function verifyIndexerPostRepairHealth(options: {
     daemonInstanceId: string;
 }>;
 export declare function isProcessAlive(pid: number | null): Promise<boolean>;
+export declare function isManagedBitcoindRpcUnavailableError(error: unknown): boolean;
 export declare function waitForProcessExit(pid: number, timeoutMs?: number, errorCode?: string): Promise<void>;
 export declare function clearIndexerDaemonArtifacts(servicePaths: ReturnType<typeof resolveManagedServicePaths>): Promise<void>;
 export declare function clearManagedBitcoindArtifacts(servicePaths: ReturnType<typeof resolveManagedServicePaths>): Promise<void>;

package/dist/wallet/lifecycle/repair-runtime.js

@@ -153,6 +153,22 @@ export async function isProcessAlive(pid) {
         return true;
     }
 }
+export function isManagedBitcoindRpcUnavailableError(error) {
+    if (error instanceof Error && "code" in error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE") {
+            return true;
+        }
+    }
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message === "bitcoind_cookie_timeout"
+        || error.message.includes("cookie file is unavailable")
+        || error.message.includes("ECONNREFUSED")
+        || error.message.includes("ECONNRESET")
+        || error.message.includes("socket hang up");
+}
 export async function waitForProcessExit(pid, timeoutMs = 15_000, errorCode = "indexer_daemon_stop_timeout") {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {

package/package.json

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