routstrd 0.4.0 → 0.4.1

package/dist/daemon/index.js

@@ -84491,7 +84491,7 @@ var require_public_api = __commonJS((exports) => {
 
 // src/daemon/index.ts
 import { createServer } from "http";
-import { existsSync as existsSync11, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync13, unlinkSync as unlinkSync2 } from "fs";
 
 // node_modules/applesauce-relay/dist/group.js
 init_event_store2();
@@ -113595,11 +113595,11 @@ function startAutoRefillLoop(cocod, getWallet, getConfig, intervalMs = 5000) {
     if (now4 - lastRefillAt < config2.cooldownMs) {
       return;
     }
-    checkInProgress = true;
     const backoffInterval = Math.min(intervalMs * Math.pow(2, consecutiveFailures), 5 * 60 * 1000);
     if (now4 - lastAttemptAt < backoffInterval) {
       return;
     }
+    checkInProgress = true;
     try {
       const balances = await cocod.getBalances();
       const totalBalance = Object.values(balances).reduce((sum, b2) => sum + (typeof b2 === "number" ? b2 : 0), 0);
@@ -113607,10 +113607,9 @@ function startAutoRefillLoop(cocod, getWallet, getConfig, intervalMs = 5000) {
         return;
       }
       logger5.log(`[auto-refill] Balance ${totalBalance} sats < threshold ${config2.threshold}. Refilling ${config2.amount} sats...`);
-      const mints = await cocod.listMints();
-      const mintUrl = mints[0];
+      const mintUrl = await cocod.getDefaultMint();
       if (!mintUrl) {
-        logger5.error("[auto-refill] No active mint configured");
+        logger5.error("[auto-refill] No default mint configured");
         return;
       }
       logger5.log(`[auto-refill] Creating BOLT-11 invoice for ${config2.amount} sats via ${mintUrl}...`);
@@ -128194,26 +128193,6 @@ var PluginHost = class {
     };
   }
 };
-async function initializeCoco(config2) {
-  await config2.repo.init();
-  const coco = new Manager(config2.repo, config2.seedGetter, config2.logger, config2.webSocketFactory, config2.plugins, config2.watchers, config2.processors, config2.subscriptions);
-  await coco.initPlugins();
-  await coco.reconcileLegacyMintQuotes();
-  const mintOperationWatcherConfig = config2.watchers?.mintOperationWatcher;
-  if (!mintOperationWatcherConfig?.disabled)
-    await coco.enableMintOperationWatcher(mintOperationWatcherConfig);
-  const proofStateWatcherConfig = config2.watchers?.proofStateWatcher;
-  if (!proofStateWatcherConfig?.disabled)
-    await coco.enableProofStateWatcher(proofStateWatcherConfig);
-  const mintOperationProcessorConfig = config2.processors?.mintOperationProcessor;
-  if (!mintOperationProcessorConfig?.disabled)
-    await coco.enableMintOperationProcessor(mintOperationProcessorConfig);
-  await coco.ops.send.recovery.run();
-  await coco.ops.melt.recovery.run();
-  await coco.ops.receive.recovery.run();
-  await coco.recoverPendingMintOperations();
-  return coco;
-}
 var Manager = class {
   mint;
   wallet;
@@ -136926,6 +136905,8 @@ function getWalletStateMessage(state) {
       return "Wallet is locked. Unlock it before performing wallet operations.";
     case "UNINITIALIZED":
       return "Wallet is not initialized. Run 'routstrd onboard' first.";
+    case "RECOVERING":
+      return "Wallet is recovering from a previous run. Balance and send/receive operations will be available once recovery completes.";
     case "ERROR":
       return "Wallet is in an error state.";
     default:
@@ -136982,6 +136963,15 @@ async function buildStatusOutput(deps) {
   const mode = getCurrentMode(deps);
   try {
     const walletState = await deps.walletClient.getStatus();
+    if (walletState === "RECOVERING") {
+      return {
+        daemon: "running",
+        wallet: "recovering",
+        walletState,
+        mode,
+        error: getWalletStateMessage(walletState)
+      };
+    }
     if (walletState !== "UNLOCKED") {
       return {
         daemon: "running",
@@ -137011,8 +137001,9 @@ async function buildStatusOutput(deps) {
 }
 async function buildWalletDetails(deps) {
   const state = await deps.walletClient.getStatus();
+  const recovery = await deps.walletClient.getRecoveryProgress?.();
   if (state !== "UNLOCKED") {
-    return { state, ready: false };
+    return { state, ready: false, ...recovery ? { recovery } : {} };
   }
   const [balances, defaultMint] = await Promise.all([
     deps.walletAdapter.getBalances(),
@@ -137024,7 +137015,8 @@ async function buildWalletDetails(deps) {
     balances,
     unit: "sat",
     activeMint: deps.walletAdapter.getActiveMintUrl(),
-    defaultMint
+    defaultMint,
+    ...recovery ? { recovery } : {}
   };
 }
 function makeSdkLogger(prefix) {
@@ -137086,6 +137078,21 @@ function createDaemonRequestHandler(deps) {
       });
       return;
     }
+    if (req.method === "POST" && url5.pathname === "/wallet/cleanup") {
+      await respond(res, async () => {
+        if (!deps.walletClient.cleanupStuckOperations) {
+          throw new CocodHttpError(501, "Wallet cleanup is not supported by this wallet client.");
+        }
+        const body = await readJsonBody(req);
+        const result = await deps.walletClient.cleanupStuckOperations({
+          mintUrl: optionalStringField(body, "mintUrl"),
+          minAgeMs: typeof body.minAgeMs === "number" && Number.isFinite(body.minAgeMs) ? body.minAgeMs : undefined,
+          dryRun: body.dryRun === true
+        });
+        return { output: result };
+      });
+      return;
+    }
     if (req.method === "POST" && url5.pathname === "/wallet/receive/cashu") {
       await respond(res, async () => {
         const body = await readJsonBody(req);
@@ -137550,11 +137557,7 @@ function createDaemonRequestHandler(deps) {
         }
         if (!mintUrl) {
           try {
-            const walletBalances = await deps.walletAdapter.getBalances();
-            const mintUrls = Object.keys(walletBalances);
-            if (mintUrls.length > 0) {
-              mintUrl = mintUrls[0];
-            }
+            mintUrl = deps.walletAdapter.getActiveMintUrl() ?? Object.keys(await deps.walletAdapter.getBalances())[0];
           } catch {}
         }
         let refunded = false;
@@ -157221,6 +157224,216 @@ function mnemonicToSeedSync2(mnemonic, passphrase = "") {
   });
 }
 
+// src/daemon/wallet/cleanup.ts
+function selectCleanupOperations(options) {
+  const { mints, sends, melts, nowMs, minAgeMs } = options;
+  const mintsToFail = mints.filter((op) => op.state === "pending" && op.expiry > 0 && op.expiry * 1000 <= nowMs && op.lastObservedRemoteState !== "PAID" && op.lastObservedRemoteState !== "ISSUED");
+  const sendsToReclaim = sends.filter((op) => op.state === "pending" && nowMs - op.updatedAt >= minAgeMs);
+  const meltsToCancel = melts.filter((op) => op.state === "prepared" && nowMs - op.updatedAt >= minAgeMs);
+  return { mintsToFail, sendsToReclaim, meltsToCancel };
+}
+
+// src/daemon/wallet/receive-dedup.ts
+import { createHash as createHash3 } from "crypto";
+var TOKEN_TABLE = "routstrd_receive_tokens";
+var MAINTENANCE_TABLE = "routstrd_wallet_maintenance";
+var RECONCILE_BACKUP_KEY = "receive_reconcile_v1_backup";
+function hashReceiveToken(token) {
+  return createHash3("sha256").update(token).digest("hex");
+}
+function initReceiveDedupSchema(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS ${TOKEN_TABLE} (
+      tokenHash TEXT PRIMARY KEY,
+      state TEXT NOT NULL CHECK (state IN ('processing', 'succeeded', 'failed')),
+      operationId TEXT,
+      error TEXT,
+      createdAt INTEGER NOT NULL,
+      updatedAt INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS ${MAINTENANCE_TABLE} (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updatedAt INTEGER NOT NULL
+    );
+  `);
+}
+function listProcessingReceiveTokens(database) {
+  return database.query(`SELECT tokenHash, state, operationId, error
+       FROM ${TOKEN_TABLE} WHERE state = 'processing'`).all();
+}
+function deleteReceiveTokenReservation(database, tokenHash) {
+  database.query(`DELETE FROM ${TOKEN_TABLE} WHERE tokenHash = ?`).run(tokenHash);
+}
+function clearInterruptedReceiveReservations(database) {
+  const result = database.query(`DELETE FROM ${TOKEN_TABLE}
+       WHERE state = 'processing' AND operationId IS NULL`).run();
+  return result.changes;
+}
+function reserveReceiveToken(database, token) {
+  const tokenHash = hashReceiveToken(token);
+  const now5 = Math.floor(Date.now() / 1000);
+  const result = database.query(`INSERT OR IGNORE INTO ${TOKEN_TABLE}
+       (tokenHash, state, operationId, error, createdAt, updatedAt)
+       VALUES (?, 'processing', NULL, NULL, ?, ?)`).run(tokenHash, now5, now5);
+  if (result.changes > 0)
+    return { acquired: true, tokenHash };
+  const existing = database.query(`SELECT tokenHash, state, operationId, error
+       FROM ${TOKEN_TABLE} WHERE tokenHash = ?`).get(tokenHash);
+  return { acquired: false, tokenHash, ...existing ? { existing } : {} };
+}
+function releaseReceiveToken(database, tokenHash) {
+  database.query(`DELETE FROM ${TOKEN_TABLE} WHERE tokenHash = ? AND operationId IS NULL`).run(tokenHash);
+}
+function updateReceiveToken(database, tokenHash, update) {
+  database.query(`UPDATE ${TOKEN_TABLE}
+       SET state = ?, operationId = COALESCE(?, operationId), error = ?, updatedAt = ?
+       WHERE tokenHash = ?`).run(update.state, update.operationId ?? null, update.error ?? null, Math.floor(Date.now() / 1000), tokenHash);
+}
+function receiveInputFingerprint(operation) {
+  const proofs = operation.inputProofs.map((proof) => ({
+    amount: proof.amount,
+    id: proof.id,
+    secret: proof.secret,
+    C: proof.C,
+    witness: proof.witness ?? null
+  })).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+  return createHash3("sha256").update(JSON.stringify([operation.mintUrl, operation.unit, proofs])).digest("hex");
+}
+function groupExecutingReceives(operations) {
+  const groups = new Map;
+  for (const operation of operations) {
+    if (operation.state !== "executing")
+      continue;
+    const key = receiveInputFingerprint(operation);
+    const group2 = groups.get(key) ?? [];
+    group2.push(operation);
+    groups.set(key, group2);
+  }
+  return [...groups.values()].map((group2) => group2.sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)));
+}
+function outputData(operation) {
+  const value = operation.outputData;
+  if (!value || typeof value !== "object")
+    return null;
+  const candidate = value;
+  if (!Array.isArray(candidate.keep) || !Array.isArray(candidate.send))
+    return null;
+  return { keep: candidate.keep, send: candidate.send };
+}
+function outputBlindedMessages(operation) {
+  const data = outputData(operation);
+  if (!data)
+    return [];
+  return [...data.keep, ...data.send].map((entry) => entry?.blindedMessage).filter((message) => Boolean(message && typeof message.B_ === "string" && message.B_ && typeof message.id === "string" && Number.isFinite(message.amount)));
+}
+async function rollBackOthers(source, group2, retainedIds, reason) {
+  let count = 0;
+  for (const operation of group2) {
+    if (retainedIds.has(operation.id))
+      continue;
+    await source.rollBack(operation, reason);
+    count++;
+  }
+  return count;
+}
+async function reconcileExecutingReceives(source) {
+  const executing = (await source.listExecuting()).filter((operation) => operation.state === "executing");
+  const groups = groupExecutingReceives(executing);
+  const result = {
+    executing: executing.length,
+    uniqueGroups: groups.length,
+    rolledBack: 0,
+    retained: 0,
+    unresolved: 0,
+    recoveryOperationIds: []
+  };
+  for (const group2 of groups) {
+    try {
+      const savedOwners = new Set;
+      for (const operation of group2) {
+        if (await source.hasSavedOutputs(operation))
+          savedOwners.add(operation.id);
+      }
+      if (savedOwners.size > 0) {
+        result.rolledBack += await rollBackOthers(source, group2, savedOwners, "Duplicate receive: outputs already persisted by another operation");
+        result.retained += savedOwners.size;
+        result.recoveryOperationIds.push(...savedOwners);
+        continue;
+      }
+      const states = await source.checkProofStates(group2[0]);
+      const completeStates = states.length === group2[0].inputProofs.length;
+      const allUnspent = completeStates && states.every((state) => state.state === "UNSPENT");
+      const allSpent = completeStates && states.every((state) => state.state === "SPENT");
+      if (allUnspent) {
+        const canonical = group2.find((operation) => outputBlindedMessages(operation).length > 0);
+        if (!canonical) {
+          result.unresolved += group2.length;
+          continue;
+        }
+        result.rolledBack += await rollBackOthers(source, group2, new Set([canonical.id]), "Duplicate receive: identical inputs retained by canonical operation");
+        result.retained++;
+        result.recoveryOperationIds.push(canonical.id);
+        continue;
+      }
+      if (!allSpent) {
+        result.unresolved += group2.length;
+        continue;
+      }
+      const outputOwners = new Map;
+      let malformed = false;
+      for (const operation of group2) {
+        const outputs = outputBlindedMessages(operation);
+        if (outputs.length === 0) {
+          malformed = true;
+          continue;
+        }
+        for (const output12 of outputs) {
+          const entry = outputOwners.get(output12.B_) ?? {
+            message: output12,
+            owners: new Set
+          };
+          entry.owners.add(operation.id);
+          outputOwners.set(output12.B_, entry);
+        }
+      }
+      if (malformed || outputOwners.size === 0) {
+        result.unresolved += group2.length;
+        continue;
+      }
+      const restored = await source.restoreOutputs(group2[0].mintUrl, [...outputOwners.values()].map((entry) => entry.message));
+      const restoredOwners = new Set;
+      for (const output12 of restored) {
+        for (const owner of outputOwners.get(output12.B_)?.owners ?? []) {
+          restoredOwners.add(owner);
+        }
+      }
+      if (restoredOwners.size === 0) {
+        for (const operation of group2) {
+          await source.rollBack(operation, "Recovered: input proofs spent without recoverable outputs");
+          result.rolledBack++;
+        }
+        continue;
+      }
+      result.rolledBack += await rollBackOthers(source, group2, restoredOwners, "Duplicate receive: recoverable outputs belong to another operation");
+      result.retained += restoredOwners.size;
+      result.recoveryOperationIds.push(...restoredOwners);
+    } catch {
+      result.unresolved += group2.length;
+    }
+  }
+  return result;
+}
+function getReceiveReconcileBackup(database) {
+  const row = database.query(`SELECT value FROM ${MAINTENANCE_TABLE} WHERE key = ?`).get(RECONCILE_BACKUP_KEY);
+  return row?.value ?? null;
+}
+function setReceiveReconcileBackup(database, path2) {
+  database.query(`INSERT INTO ${MAINTENANCE_TABLE} (key, value, updatedAt)
+       VALUES (?, ?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updatedAt = excluded.updatedAt`).run(RECONCILE_BACKUP_KEY, path2, Math.floor(Date.now() / 1000));
+}
+
 // src/daemon/wallet/paths.ts
 import { join as join10 } from "path";
 function homeDir() {
@@ -157258,6 +157471,12 @@ function startupProgress(message) {
   logger5.info(message);
   console.log(`${STARTUP_LOG_PREFIX} ${message}`);
 }
+var surfacingRecoveryProgress = false;
+var RECOVERY_STALL_MARKERS = new Map([
+  ["SendOperationService\x00Could not reach mint for recovery, will retry later", "Send recovery: mint unreachable"],
+  ["ReceiveOperationService\x00Could not reach mint for receive recovery, will retry later", "Receive recovery: mint unreachable"],
+  ["MintOperationService\x00Failed to reconcile stale pending mint operation", "Mint recovery: pending operation check failed"]
+]);
 var SAFE_COCO_LOG_FIELDS = new Set([
   "module",
   "mintUrl",
@@ -157289,6 +157508,16 @@ function safeCocoMetadata(values2) {
 function createCocoLogger(bindings = {}) {
   const write = (level, message, meta3) => {
     const metadata = safeCocoMetadata([bindings, ...meta3]);
+    if (surfacingRecoveryProgress) {
+      const module = typeof bindings.module === "string" ? bindings.module : undefined;
+      if (module) {
+        const stall = RECOVERY_STALL_MARKERS.get(`${module}\x00${message}`);
+        if (stall) {
+          const mintUrl = typeof metadata.mintUrl === "string" ? metadata.mintUrl : undefined;
+          startupProgress(mintUrl ? `${stall} (${mintUrl})` : stall);
+        }
+      }
+    }
     cocoLogger[level](`[coco] ${message}`, ...Object.keys(metadata).length > 0 ? [metadata] : []);
   };
   return {
@@ -157325,13 +157554,22 @@ function saveConfig(config2, configFile) {
     throw error53;
   }
 }
+function isZombieProcess(pid, readFile7 = (path2) => readFileSync2(path2, "utf-8")) {
+  try {
+    const stat2 = readFile7(`/proc/${pid}/stat`);
+    const commandEnd = stat2.lastIndexOf(")");
+    return commandEnd >= 0 && stat2.charAt(commandEnd + 2) === "Z";
+  } catch {
+    return false;
+  }
+}
 function defaultIsProcessRunning(pid) {
   try {
     process.kill(pid, 0);
-    return true;
   } catch (error53) {
     return error53.code === "EPERM";
   }
+  return !isZombieProcess(pid);
 }
 function hasErrorCode(error53, codes) {
   let current = error53;
@@ -157348,24 +157586,7 @@ function hasErrorCode(error53, codes) {
 }
 async function assertLegacyCocodNotRunning(options = {}) {
   const socketPath = options.socketPath || legacyCocodSocketPath();
-  const pidFilePath = options.pidFilePath || legacyCocodPidPath();
   const pathExists = options.pathExists || existsSync9;
-  const readFile7 = options.readFile || ((path2) => readFileSync2(path2, "utf-8"));
-  const isProcessRunning2 = options.isProcessRunning || defaultIsProcessRunning;
-  const getRunningLegacyPid = () => {
-    if (!pathExists(pidFilePath))
-      return null;
-    try {
-      const pid = Number.parseInt(readFile7(pidFilePath).trim(), 10);
-      return Number.isInteger(pid) && pid > 0 && pid !== options.ignorePid && isProcessRunning2(pid) ? pid : null;
-    } catch {
-      return null;
-    }
-  };
-  const runningPid = getRunningLegacyPid();
-  if (runningPid !== null) {
-    throw new Error(`Legacy cocod daemon is still running with PID ${runningPid}. ` + "Refusing to open the wallet database because cocod and coco-core cannot safely use it at the same time. " + `Run 'cocod stop' or 'kill ${runningPid}' and try again.`);
-  }
   if (!pathExists(socketPath))
     return;
   const fetchImpl = options.fetchImpl || fetch;
@@ -157378,12 +157599,8 @@ async function assertLegacyCocodNotRunning(options = {}) {
     await response3.body?.cancel();
   } catch (error53) {
     if (hasErrorCode(error53, STALE_SOCKET_ERROR_CODES)) {
-      const newlyRunningPid = getRunningLegacyPid();
-      if (newlyRunningPid === null) {
-        logger5.debug(`Ignoring stale legacy cocod socket at ${socketPath}`);
-        return;
-      }
-      throw new Error(`Legacy cocod daemon is still running with PID ${newlyRunningPid}. ` + "Refusing to open the wallet database because cocod and coco-core cannot safely use it at the same time. " + `Run 'cocod stop' or 'kill ${newlyRunningPid}' and try again.`, { cause: error53 });
+      logger5.debug(`Ignoring stale legacy cocod socket at ${socketPath}`);
+      return;
     }
     throw new Error(`Cannot verify whether the legacy cocod daemon has stopped at ${socketPath}. ` + "Refusing to open the wallet database to prevent concurrent access. " + "Run 'cocod stop', verify the daemon has exited, and try again.", { cause: error53 });
   }
@@ -157447,12 +157664,14 @@ async function stopLegacyCocod(options = {}) {
 function claimLegacyCocodPidFile(options = {}) {
   return claimPidFile({
     ...options,
-    pidFilePath: options.pidFilePath || legacyCocodPidPath()
+    pidFilePath: options.pidFilePath || legacyCocodPidPath(),
+    label: options.label || "legacy cocod exclusion lock"
   });
 }
 function claimPidFile(options) {
   const pidFilePath = options.pidFilePath;
   const pid = options.pid ?? process.pid;
+  const label = options.label || "wallet process lock";
   const openExclusive = options.openExclusive || ((path2) => openSync(path2, "wx", 384));
   const writePid = options.writePid || ((fd2, ownerPid) => writeFileSync(fd2, String(ownerPid)));
   const closeFile = options.closeFile || closeSync;
@@ -157469,16 +157688,17 @@ function claimPidFile(options) {
     try {
       stalePid = Number.parseInt(readFile7(pidFilePath).trim(), 10);
     } catch {
-      throw new Error(`Cannot claim the wallet process lock at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: error53 });
+      throw new Error(`Cannot claim the ${label} at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: error53 });
     }
     if (!Number.isInteger(stalePid) || stalePid <= 0 || isProcessRunning2(stalePid)) {
-      throw new Error(`Cannot claim the wallet process lock at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: error53 });
+      const ownerMessage = Number.isInteger(stalePid) && stalePid > 0 ? `PID ${stalePid} is still running and holds it. ` + `Stop that process first ('routstrd stop' or 'kill ${stalePid}').` : "Another cocod or routstrd process may be starting. Stop it and try again.";
+      throw new Error(`Cannot claim the ${label} at ${pidFilePath}: ${ownerMessage}`, { cause: error53 });
     }
     try {
       removeFile(pidFilePath);
       fd = openExclusive(pidFilePath);
     } catch (retryError) {
-      throw new Error(`Cannot claim the wallet process lock at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: retryError });
+      throw new Error(`Cannot claim the ${label} at ${pidFilePath}. ` + "Another cocod or routstrd process may be starting. Stop it and try again.", { cause: retryError });
     }
   }
   try {
@@ -157492,20 +157712,180 @@ function claimPidFile(options) {
     closeFile(fd);
   }
   let released = false;
-  return () => {
+  const release = () => {
     if (released)
       return;
     released = true;
+    process.removeListener("exit", release);
     try {
       if (readFile7(pidFilePath).trim() === String(pid)) {
         removeFile(pidFilePath);
       }
     } catch (error53) {
       if (error53.code !== "ENOENT") {
-        logger5.warn(`Failed to release wallet process lock at ${pidFilePath}:`, error53);
+        logger5.warn(`Failed to release ${label} at ${pidFilePath}:`, error53);
       }
     }
   };
+  process.once("exit", release);
+  return release;
+}
+function constructCocoManager(repo, seed) {
+  return new Manager(repo, async () => seed, createCocoLogger());
+}
+async function enableCocoManager(coco) {
+  await coco.initPlugins();
+  await coco.reconcileLegacyMintQuotes();
+  await coco.enableMintOperationWatcher();
+  await coco.enableProofStateWatcher();
+  await coco.enableMintOperationProcessor();
+}
+var EXPIRED_MINT_OBSERVATION_DEADLINE_MS = 15000;
+function withTimeout(promise2, timeoutMs) {
+  let timer6;
+  const timeout6 = new Promise((_resolve, reject) => {
+    timer6 = setTimeout(() => reject(new Error("Timed out contacting mint")), timeoutMs);
+  });
+  return Promise.race([promise2, timeout6]).finally(() => {
+    if (timer6 !== undefined)
+      clearTimeout(timer6);
+  });
+}
+async function settleExpiredMintQuotes(source, nowMs, deadlineMs = EXPIRED_MINT_OBSERVATION_DEADLINE_MS) {
+  const pendingMints = await source.ops.mint.listPending();
+  const selection = selectCleanupOperations({
+    mints: pendingMints,
+    sends: [],
+    melts: [],
+    nowMs,
+    minAgeMs: 0
+  });
+  const settlement = {
+    failed: 0,
+    leftForRecovery: 0,
+    unobserved: 0
+  };
+  const candidates = selection.mintsToFail;
+  if (candidates.length === 0)
+    return settlement;
+  const startedAt = Date.now();
+  for (const op of candidates) {
+    const remainingMs = deadlineMs - (Date.now() - startedAt);
+    if (remainingMs <= 0) {
+      const skipped = candidates.length - settlement.failed - settlement.leftForRecovery - settlement.unobserved;
+      settlement.unobserved += skipped;
+      startupProgress(`Expired mint quote check budget exhausted; ${skipped} quote(s) left for mint recovery.`);
+      break;
+    }
+    try {
+      const result = await withTimeout(source.mintOperationService.observePendingOperation(op.id), remainingMs);
+      if (result.category === "waiting") {
+        await source.mintOperationService.failPendingOperation({ id: op.id }, {
+          reason: "Expired mint quote confirmed unpaid by mint",
+          retryable: false,
+          observedAt: Date.now()
+        });
+        settlement.failed++;
+      } else {
+        settlement.leftForRecovery++;
+        const observed = result.category === "ready" ? "was paid at the mint" : result.category === "completed" ? "was already issued at the mint" : "failed terminally at the mint";
+        startupProgress(`Expired mint quote ${op.quoteId ?? op.id} at ${op.mintUrl} ${observed}; leaving it for mint recovery.`);
+      }
+    } catch (error53) {
+      settlement.unobserved++;
+      logger5.warn("Could not check expired mint quote; leaving it pending", {
+        operationId: op.id,
+        mintUrl: op.mintUrl,
+        error: error53 instanceof Error ? error53.message : String(error53)
+      });
+    }
+  }
+  return settlement;
+}
+async function reconcileDuplicateReceiveOperations(coco, repo) {
+  const internals = coco;
+  const unavailableMints = new Set;
+  const deadline = Date.now() + 45000;
+  const ensureMintBudget = (mintUrl) => {
+    if (Date.now() >= deadline)
+      throw new Error("Receive cleanup time budget exhausted");
+    if (unavailableMints.has(mintUrl))
+      throw new Error("Mint already failed receive cleanup");
+  };
+  const markMintFailure = (mintUrl, error53) => {
+    unavailableMints.add(mintUrl);
+    throw error53;
+  };
+  const source = {
+    listExecuting: () => repo.receiveOperationRepository.getByState("executing"),
+    checkProofStates: async (operation) => {
+      ensureMintBudget(operation.mintUrl);
+      try {
+        return await withTimeout(internals.receiveOperationService.checkProofStatesWithMint(operation.mintUrl, operation.inputProofs), Math.min(15000, Math.max(1, deadline - Date.now())));
+      } catch (error53) {
+        return markMintFailure(operation.mintUrl, error53);
+      }
+    },
+    restoreOutputs: async (mintUrl, outputs) => {
+      ensureMintBudget(mintUrl);
+      const restored = [];
+      const mint = internals.mintAdapter.getCashuMint(mintUrl);
+      for (let index = 0;index < outputs.length; index += 300) {
+        try {
+          const response3 = await withTimeout(mint.restore({ outputs: outputs.slice(index, index + 300) }), Math.min(15000, Math.max(1, deadline - Date.now())));
+          restored.push(...response3.outputs);
+        } catch (error53) {
+          return markMintFailure(mintUrl, error53);
+        }
+      }
+      return restored;
+    },
+    hasSavedOutputs: (operation) => internals.receiveOperationService.hasSavedOutputs(operation),
+    rollBack: async (operation, reason) => {
+      await internals.receiveOperationService.markAsRolledBack(operation, reason);
+    }
+  };
+  return reconcileExecutingReceives(source);
+}
+async function runWalletRecovery(coco, onProgress, receiveOperationIds) {
+  surfacingRecoveryProgress = true;
+  let failedMintQuotes = 0;
+  try {
+    onProgress({ phase: "Settling expired mint quotes", failedMintQuotes });
+    const settlement = await settleExpiredMintQuotes({
+      ops: coco.ops,
+      mintOperationService: coco.mintOperationService
+    }, Date.now());
+    failedMintQuotes = settlement.failed;
+    if (settlement.leftForRecovery > 0 || settlement.unobserved > 0) {
+      startupProgress(`Expired mint quotes: ${settlement.failed} failed locally, ` + `${settlement.leftForRecovery} paid/issued (kept for recovery), ` + `${settlement.unobserved} unverifiable (kept pending).`);
+    }
+    onProgress({ phase: "Settled expired mint quotes", failedMintQuotes });
+    onProgress({ phase: "Send recovery", failedMintQuotes });
+    await coco.ops.send.recovery.run();
+    onProgress({ phase: "Melt recovery", failedMintQuotes });
+    await coco.ops.melt.recovery.run();
+    onProgress({ phase: "Receive recovery", failedMintQuotes });
+    if (receiveOperationIds) {
+      for (const operationId of receiveOperationIds) {
+        try {
+          await withTimeout(coco.ops.receive.refresh(operationId), 15000);
+        } catch (error53) {
+          logger5.warn("Targeted receive recovery did not complete", {
+            operationId,
+            error: error53 instanceof Error ? error53.message : String(error53)
+          });
+        }
+      }
+    } else {
+      await coco.ops.receive.recovery.run();
+    }
+    onProgress({ phase: "Mint recovery", failedMintQuotes });
+    await coco.recoverPendingMintOperations();
+    onProgress({ phase: "done", failedMintQuotes });
+  } finally {
+    surfacingRecoveryProgress = false;
+  }
 }
 async function createCocoClient(options = {}) {
   const configDir = options.walletDir || options.configDir || walletDir();
@@ -157516,12 +157896,12 @@ async function createCocoClient(options = {}) {
   const legacyPidFile = options.legacyPidPath || legacyCocodPidPath();
   const npcBaseUrl = options.npcBaseUrl || NPC_DEFAULT_BASE_URL;
   const npcAddressDomain = new URL(npcBaseUrl).host;
-  await assertLegacyCocodNotRunning({
-    socketPath: legacySocket,
-    pidFilePath: legacyPidFile
-  });
+  await assertLegacyCocodNotRunning({ socketPath: legacySocket });
   mkdirSync8(dirname7(legacyPidFile), { recursive: true, mode: 448 });
-  const releaseWalletPidClaim = claimPidFile({ pidFilePath: walletPidFile });
+  const releaseWalletPidClaim = claimPidFile({
+    pidFilePath: walletPidFile,
+    label: "routstrd wallet lock"
+  });
   let releaseLegacyPidClaim;
   try {
     releaseLegacyPidClaim = claimLegacyCocodPidFile({
@@ -157533,7 +157913,21 @@ async function createCocoClient(options = {}) {
   }
   let database;
   let coco;
+  let findFinalizedReceiveSibling = async () => null;
   let walletConfig = loadConfig2(configFile);
+  let recoveryPhase = "queued";
+  let recoveryFailedMintQuotes = 0;
+  let recoveryDone = false;
+  let recoveryError;
+  const recoveryCounts = {
+    pendingSends: 0,
+    inflightProofs: 0,
+    pendingMints: 0
+  };
+  let recoveryResolve;
+  const recoveryPromise = new Promise((resolve) => {
+    recoveryResolve = resolve;
+  });
   try {
     startupProgress("Opening Cashu wallet database...");
     const mnemonic = walletConfig.mnemonic;
@@ -157541,22 +157935,88 @@ async function createCocoClient(options = {}) {
     database = new Database2(dbPath);
     const repo = new SqliteRepositories({ database });
     await repo.init();
+    initReceiveDedupSchema(database);
+    const interruptedReservations = clearInterruptedReceiveReservations(database);
+    if (interruptedReservations > 0) {
+      logger5.warn("Cleared interrupted receive reservations with no Coco operation", {
+        count: interruptedReservations
+      });
+    }
     const [pendingSends, inflightProofs, pendingMints] = await Promise.all([
       repo.sendOperationRepository.getPending(),
       repo.proofRepository.getInflightProofs(),
       repo.mintOperationRepository.getPending()
     ]);
-    const recoveryCount = pendingSends.length + inflightProofs.length + pendingMints.length;
+    recoveryCounts.pendingSends = pendingSends.length;
+    recoveryCounts.inflightProofs = inflightProofs.length;
+    recoveryCounts.pendingMints = pendingMints.length;
+    const recoveryCount = recoveryCounts.pendingSends + recoveryCounts.inflightProofs + recoveryCounts.pendingMints;
     if (recoveryCount > 0) {
-      startupProgress(`Recovering wallet state: ${pendingSends.length} pending sends, ` + `${inflightProofs.length} in-flight proofs, ${pendingMints.length} pending mints. ` + "This may take a few minutes while Cashu mints are contacted.");
+      startupProgress(`Recovering wallet state in background: ${recoveryCounts.pendingSends} pending sends, ` + `${recoveryCounts.inflightProofs} in-flight proofs, ${recoveryCounts.pendingMints} pending mints.`);
     } else {
       startupProgress("Initializing Cashu wallet...");
     }
-    coco = await initializeCoco({
-      repo,
-      seedGetter: async () => seed,
-      logger: createCocoLogger()
-    });
+    coco = constructCocoManager(repo, seed);
+    const executingReceives = await repo.receiveOperationRepository.getByState("executing");
+    let receiveRecoveryOperationIds;
+    if (executingReceives.length > 0) {
+      startupProgress(`Checking ${executingReceives.length} unfinished Cashu receive operation(s) for duplicates...`);
+      const recordedBackup = getReceiveReconcileBackup(database);
+      if (!recordedBackup || !existsSync9(recordedBackup)) {
+        const backupPath = `${dbPath}.pre-receive-reconcile-${Date.now()}`;
+        database.exec(`VACUUM INTO '${backupPath.replaceAll("'", "''")}'`);
+        setReceiveReconcileBackup(database, backupPath);
+        startupProgress(`Created wallet backup before receive cleanup: ${backupPath}`);
+      }
+      const receiveReconcile = await reconcileDuplicateReceiveOperations(coco, repo);
+      receiveRecoveryOperationIds = receiveReconcile.recoveryOperationIds;
+      startupProgress(`Receive cleanup: ${receiveReconcile.executing} operation(s), ` + `${receiveReconcile.uniqueGroups} unique input set(s), ` + `${receiveReconcile.rolledBack} stale duplicate(s) retired, ` + `${receiveReconcile.unresolved} unresolved.`);
+    }
+    await enableCocoManager(coco);
+    const openDatabase = database;
+    findFinalizedReceiveSibling = async (operation) => {
+      if (!operation)
+        return null;
+      const fingerprint = receiveInputFingerprint(operation);
+      const siblings = await repo.receiveOperationRepository.getByMintUrl(operation.mintUrl);
+      return siblings.find((candidate) => candidate.state === "finalized" && receiveInputFingerprint(candidate) === fingerprint)?.id ?? null;
+    };
+    const syncReceiveReservations = async () => {
+      for (const reservation of listProcessingReceiveTokens(openDatabase)) {
+        if (!reservation.operationId)
+          continue;
+        try {
+          const operation = await coco.ops.receive.get(reservation.operationId);
+          if (operation?.state === "finalized") {
+            updateReceiveToken(openDatabase, reservation.tokenHash, {
+              state: "succeeded",
+              operationId: operation.id
+            });
+          } else if (operation?.state === "rolled_back") {
+            const finalizedSibling = await findFinalizedReceiveSibling(operation);
+            updateReceiveToken(openDatabase, reservation.tokenHash, finalizedSibling ? {
+              state: "succeeded",
+              operationId: finalizedSibling
+            } : {
+              state: "failed",
+              operationId: operation.id,
+              error: operation.error || "Token receive was rolled back"
+            });
+          } else if (operation?.state === "prepared") {
+            await coco.ops.receive.cancel(operation.id, "Cancelled interrupted receive before execution");
+            deleteReceiveTokenReservation(openDatabase, reservation.tokenHash);
+          } else if (!operation) {
+            deleteReceiveTokenReservation(openDatabase, reservation.tokenHash);
+          }
+        } catch (error53) {
+          logger5.warn("Could not reconcile receive token reservation", {
+            operationId: reservation.operationId,
+            error: error53 instanceof Error ? error53.message : String(error53)
+          });
+        }
+      }
+    };
+    await syncReceiveReservations();
     const trustedMints = await coco.mint.getAllTrustedMints();
     const configuredDefault = walletConfig.defaultMintUrl;
     const defaultMintUrl = normalizeMintUrl(configuredDefault || trustedMints[0]?.mintUrl || DEFAULT_MINT_URL);
@@ -157579,6 +158039,25 @@ async function createCocoClient(options = {}) {
       coco.use(npcPlugin);
     }
     startupProgress("Cashu wallet ready.");
+    runWalletRecovery(coco, (progress) => {
+      recoveryPhase = progress.phase;
+      recoveryFailedMintQuotes = progress.failedMintQuotes;
+      if (progress.phase !== "done") {
+        startupProgress(`Wallet recovery: ${progress.phase}...`);
+      }
+    }, receiveRecoveryOperationIds).then(async () => {
+      await syncReceiveReservations();
+      recoveryDone = true;
+      recoveryPhase = "done";
+      recoveryResolve?.();
+      startupProgress("Wallet recovery complete.");
+    }).catch((error53) => {
+      recoveryDone = true;
+      recoveryPhase = "error";
+      recoveryError = error53 instanceof Error ? error53.message : String(error53);
+      recoveryResolve?.();
+      startupProgress(`Wallet recovery failed: ${recoveryError}`);
+    });
   } catch (error53) {
     database?.close();
     releaseLegacyPidClaim();
@@ -157593,6 +158072,13 @@ async function createCocoClient(options = {}) {
     return api2;
   };
   let disposed = false;
+  const waitForRecovery = async () => {
+    if (!recoveryDone)
+      await recoveryPromise;
+    if (recoveryError) {
+      throw new Error(`Wallet is not ready: ${recoveryError}`);
+    }
+  };
   return {
     async ping() {
       try {
@@ -157603,6 +158089,10 @@ async function createCocoClient(options = {}) {
       }
     },
     async getStatus() {
+      if (recoveryError)
+        return "ERROR";
+      if (!recoveryDone)
+        return "RECOVERING";
       try {
         await coco.wallet.balances.total();
         return "UNLOCKED";
@@ -157610,6 +158100,17 @@ async function createCocoClient(options = {}) {
         return "ERROR";
       }
     },
+    async getRecoveryProgress() {
+      return {
+        state: recoveryError ? "ERROR" : recoveryDone ? "UNLOCKED" : "RECOVERING",
+        phase: recoveryPhase,
+        pendingSends: recoveryCounts.pendingSends,
+        inflightProofs: recoveryCounts.inflightProofs,
+        pendingMints: recoveryCounts.pendingMints,
+        failedMintQuotes: recoveryFailedMintQuotes,
+        ...recoveryError ? { error: recoveryError } : {}
+      };
+    },
     async unlock(_passphrase) {
       return "wallet does not require unlocking";
     },
@@ -157621,10 +158122,120 @@ async function createCocoClient(options = {}) {
       ]));
     },
     async receiveCashu(token) {
-      await coco.wallet.receive(token);
-      return "Token received successfully";
+      const reservation = reserveReceiveToken(database, token);
+      if (!reservation.acquired) {
+        if (reservation.existing?.state === "succeeded") {
+          return "Token already received successfully";
+        }
+        if (reservation.existing?.state === "processing" && reservation.existing.operationId) {
+          try {
+            const operation = await withTimeout(coco.ops.receive.refresh(reservation.existing.operationId), 15000);
+            if (operation.state === "finalized") {
+              updateReceiveToken(database, reservation.tokenHash, {
+                state: "succeeded",
+                operationId: operation.id
+              });
+              return "Token received successfully";
+            }
+            if (operation.state === "rolled_back") {
+              const finalizedSibling = await findFinalizedReceiveSibling(operation);
+              if (finalizedSibling) {
+                updateReceiveToken(database, reservation.tokenHash, {
+                  state: "succeeded",
+                  operationId: finalizedSibling
+                });
+                return "Token already received successfully";
+              }
+              updateReceiveToken(database, reservation.tokenHash, {
+                state: "failed",
+                operationId: operation.id,
+                error: operation.error || "Token receive was rolled back"
+              });
+              throw new Error(operation.error || "Token receive was rolled back");
+            }
+          } catch (error53) {
+            const latest = await coco.ops.receive.get(reservation.existing.operationId);
+            if (latest?.state === "finalized") {
+              updateReceiveToken(database, reservation.tokenHash, {
+                state: "succeeded",
+                operationId: latest.id
+              });
+              return "Token received successfully";
+            }
+            throw error53;
+          }
+          throw new Error("Token receive is still unresolved");
+        }
+        if (reservation.existing?.state === "processing") {
+          throw new Error("Token receive is already in progress");
+        }
+        throw new Error(reservation.existing?.error || "Token receive previously failed");
+      }
+      let preparedOperationId;
+      try {
+        await waitForRecovery();
+        const prepared = await coco.ops.receive.prepare({ token });
+        preparedOperationId = prepared.id;
+        updateReceiveToken(database, reservation.tokenHash, {
+          state: "processing",
+          operationId: prepared.id
+        });
+        await coco.ops.receive.execute(prepared.id);
+        updateReceiveToken(database, reservation.tokenHash, {
+          state: "succeeded",
+          operationId: prepared.id
+        });
+        return "Token received successfully";
+      } catch (error53) {
+        const message = error53 instanceof Error ? error53.message : String(error53);
+        if (preparedOperationId) {
+          let latest = null;
+          try {
+            latest = await coco.ops.receive.get(preparedOperationId);
+          } catch (lookupError) {
+            logger5.warn("Could not inspect failed receive operation", {
+              operationId: preparedOperationId,
+              error: lookupError instanceof Error ? lookupError.message : String(lookupError)
+            });
+          }
+          if (latest?.state === "finalized") {
+            updateReceiveToken(database, reservation.tokenHash, {
+              state: "succeeded",
+              operationId: preparedOperationId
+            });
+            return "Token received successfully";
+          }
+          if (latest?.state === "executing") {
+            updateReceiveToken(database, reservation.tokenHash, {
+              state: "processing",
+              operationId: preparedOperationId,
+              error: message
+            });
+          } else if (latest?.state === "rolled_back") {
+            const finalizedSibling = await findFinalizedReceiveSibling(latest);
+            if (finalizedSibling) {
+              updateReceiveToken(database, reservation.tokenHash, {
+                state: "succeeded",
+                operationId: finalizedSibling
+              });
+              return "Token already received successfully";
+            }
+            updateReceiveToken(database, reservation.tokenHash, {
+              state: "failed",
+              operationId: preparedOperationId,
+              error: latest.error || message
+            });
+          } else {
+            deleteReceiveTokenReservation(database, reservation.tokenHash);
+          }
+        } else {
+          releaseReceiveToken(database, reservation.tokenHash);
+        }
+        throw error53;
+      }
     },
     async receiveBolt11(amount, mintUrl) {
+      await waitForRecovery();
       const targetMint = mintUrl ? normalizeMintUrl(mintUrl) : walletConfig.defaultMintUrl;
       if (!targetMint) {
         throw new Error("No trusted mint available for Lightning invoice");
@@ -157640,6 +158251,7 @@ async function createCocoClient(options = {}) {
       return op.request;
     },
     async sendCashu(amount, mintUrl) {
+      await waitForRecovery();
       const targetMint = mintUrl ? normalizeMintUrl(mintUrl) : walletConfig.defaultMintUrl;
       if (!targetMint) {
         throw new Error("No trusted mint available for sending");
@@ -157652,6 +158264,7 @@ async function createCocoClient(options = {}) {
       return ar(token);
     },
     async sendBolt11(invoice, mintUrl) {
+      await waitForRecovery();
       const targetMint = mintUrl ? normalizeMintUrl(mintUrl) : walletConfig.defaultMintUrl;
       if (!targetMint) {
         throw new Error("No trusted mint available for Lightning payment");
@@ -157669,6 +158282,7 @@ async function createCocoClient(options = {}) {
       return mints.map((m2) => m2.mintUrl);
     },
     async addMint(url5) {
+      await waitForRecovery();
       const mintUrl = normalizeMintUrl(url5);
       await coco.mint.addMint(mintUrl, { trusted: true });
       return `Mint ${mintUrl} added successfully`;
@@ -157680,6 +158294,7 @@ async function createCocoClient(options = {}) {
       return walletConfig.defaultMintUrl || null;
     },
     async setDefaultMint(url5) {
+      await waitForRecovery();
       const mintUrl = normalizeMintUrl(url5);
       const trustedMints = await coco.mint.getAllTrustedMints();
       if (!trustedMints.some((mint) => mint.mintUrl === mintUrl)) {
@@ -157694,6 +158309,7 @@ async function createCocoClient(options = {}) {
         return;
       disposed = true;
       try {
+        await recoveryPromise;
         await coco.dispose();
       } finally {
         try {
@@ -157718,6 +158334,7 @@ async function createCocoClient(options = {}) {
       };
     },
     async setNpcUsername(username, confirm) {
+      await waitForRecovery();
       const result = await npcApi().setUsername(username, confirm === true);
       if (result.success) {
         return { success: true };
@@ -157728,7 +158345,77 @@ async function createCocoClient(options = {}) {
       };
     },
     async syncNpc() {
+      await waitForRecovery();
       await npcApi().sync();
+    },
+    async cleanupStuckOperations(options2 = {}) {
+      await waitForRecovery();
+      const minAgeMs = options2.minAgeMs ?? 7 * 24 * 60 * 60 * 1000;
+      const dryRun = options2.dryRun === true;
+      const nowMs = Date.now();
+      const [pendingMints, inFlightSends, preparedMelts] = await Promise.all([
+        coco.ops.mint.listPending(),
+        coco.ops.send.listInFlight(),
+        coco.ops.melt.listPrepared()
+      ]);
+      const filteredMints = options2.mintUrl ? pendingMints.filter((op) => op.mintUrl === options2.mintUrl) : pendingMints;
+      const filteredSends = options2.mintUrl ? inFlightSends.filter((op) => op.mintUrl === options2.mintUrl) : inFlightSends;
+      const filteredMelts = options2.mintUrl ? preparedMelts.filter((op) => op.mintUrl === options2.mintUrl) : preparedMelts;
+      const selection = selectCleanupOperations({
+        mints: filteredMints,
+        sends: filteredSends,
+        melts: filteredMelts,
+        nowMs,
+        minAgeMs
+      });
+      const errors5 = [];
+      if (!dryRun) {
+        const mintService = coco.mintOperationService;
+        for (const op of selection.mintsToFail) {
+          try {
+            await mintService.failPendingOperation({ id: op.id }, {
+              reason: "Expired unpaid mint quote cleaned up by routstrd",
+              retryable: false,
+              observedAt: nowMs
+            });
+          } catch (error53) {
+            errors5.push({
+              operationId: op.id,
+              error: error53 instanceof Error ? error53.message : String(error53)
+            });
+          }
+        }
+        for (const op of selection.sendsToReclaim) {
+          try {
+            await coco.ops.send.reclaim(op.id);
+          } catch (error53) {
+            errors5.push({
+              operationId: op.id,
+              error: error53 instanceof Error ? error53.message : String(error53)
+            });
+          }
+        }
+        for (const op of selection.meltsToCancel) {
+          try {
+            await coco.ops.melt.cancel(op.id, "Cancelled by wallet cleanup");
+          } catch (error53) {
+            errors5.push({
+              operationId: op.id,
+              error: error53 instanceof Error ? error53.message : String(error53)
+            });
+          }
+        }
+      }
+      const actedOn = selection.mintsToFail.length + selection.sendsToReclaim.length + selection.meltsToCancel.length;
+      const skipped = filteredMints.length + filteredSends.length + filteredMelts.length - actedOn;
+      return {
+        dryRun,
+        failedMintQuotes: selection.mintsToFail.length,
+        reclaimedSends: selection.sendsToReclaim.length,
+        cancelledMelts: selection.meltsToCancel.length,
+        skipped,
+        errors: errors5
+      };
     }
   };
 }
@@ -157737,16 +158424,25 @@ async function createCocoClient(options = {}) {
 import {
   chmodSync,
   copyFileSync,
-  existsSync as existsSync10,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync3,
   renameSync as renameSync2,
   rmSync,
-  statSync
+  statSync as statSync3
 } from "fs";
+import { Database as Database4 } from "bun:sqlite";
+import { basename, dirname as dirname8, join as join14 } from "path";
+
+// src/daemon/wallet/diagnostics.ts
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { Database as Database3 } from "bun:sqlite";
-import { basename, dirname as dirname8, join as join12 } from "path";
-function state(configPath, dbPath) {
+import { join as join13 } from "path";
+
+// src/daemon/wallet/wallet-state.ts
+import { existsSync as existsSync10, readFileSync as readFileSync3, statSync } from "fs";
+import { join as join12 } from "path";
+function walletState(configPath, dbPath) {
   const hasConfig = existsSync10(configPath);
   const hasDb = existsSync10(dbPath);
   if (hasConfig)
@@ -157762,9 +158458,36 @@ function filesEqual(left, right) {
     return false;
   return readFileSync3(left).equals(readFileSync3(right));
 }
-function sqlString(value) {
-  return `'${value.replaceAll("'", "''")}'`;
+function classifyWalletMigration(targetDir, sourceDir) {
+  const targetConfig = join12(targetDir, "config.json");
+  const targetDb = join12(targetDir, "coco.db");
+  const sourceConfig = join12(sourceDir, "config.json");
+  const sourceDb = join12(sourceDir, "coco.db");
+  const sourceWal = `${sourceDb}-wal`;
+  const sourceShm = `${sourceDb}-shm`;
+  const targetState = walletState(targetConfig, targetDb);
+  const sourceState = walletState(sourceConfig, sourceDb);
+  if (targetState === "initialized" && sourceState === "initialized") {
+    const configsMatch = filesEqual(targetConfig, sourceConfig);
+    const databasesMatch = !existsSync10(targetDb) && !existsSync10(sourceDb) ? true : filesEqual(targetDb, sourceDb);
+    if (configsMatch && databasesMatch)
+      return { kind: "already-current" };
+    return { kind: "conflict" };
+  }
+  if (targetState === "initialized")
+    return { kind: "already-current" };
+  if (!existsSync10(sourceDb) && (existsSync10(sourceWal) || existsSync10(sourceShm))) {
+    return { kind: "orphaned-sidecars" };
+  }
+  if (targetState === "database-only" || sourceState === "database-only") {
+    return { kind: "database-only", targetState, sourceState };
+  }
+  if (sourceState === "absent")
+    return { kind: "fresh" };
+  return { kind: "migrate" };
 }
+
+// src/daemon/wallet/diagnostics.ts
 var SUMMARY_QUERIES = {
   proofs: "SELECT mintUrl, state, COUNT(*) count, COALESCE(SUM(amount), 0) amount FROM coco_cashu_proofs GROUP BY mintUrl, state ORDER BY mintUrl, state",
   counters: "SELECT mintUrl, keysetId, counter FROM coco_cashu_counters ORDER BY mintUrl, keysetId",
@@ -157786,8 +158509,241 @@ function verifyDatabase(database, label) {
   }
   return summary;
 }
+function mnemonicFingerprint(mnemonic) {
+  const normalized = mnemonic.trim().split(/\s+/).join(" ");
+  const hex9 = createHash4("sha256").update(normalized).digest("hex");
+  return hex9.slice(0, 16).match(/.{1,4}/g)?.join("-") ?? hex9.slice(0, 16);
+}
+function summarizeDbReadonly(dbPath) {
+  let database;
+  try {
+    database = new Database3(dbPath, { readonly: true });
+    const raw = verifyDatabase(database, "Wallet database");
+    const proofs = raw.proofs ?? [];
+    const mints = raw.mints ?? [];
+    const amountByState = {};
+    let totalProofs = 0;
+    let totalAmount = 0;
+    for (const row of proofs) {
+      const count = typeof row.count === "number" ? row.count : 0;
+      const amount = typeof row.amount === "number" ? row.amount : 0;
+      totalProofs += count;
+      totalAmount += amount;
+      const state = row.state || "unknown";
+      amountByState[state] = (amountByState[state] ?? 0) + amount;
+    }
+    return {
+      summary: {
+        proofs,
+        mints,
+        totalProofs,
+        totalAmount,
+        amountByState,
+        distinctMints: new Set(proofs.map((row) => row.mintUrl).filter(Boolean)).size
+      }
+    };
+  } catch (error53) {
+    return { error: error53 instanceof Error ? error53.message : String(error53) };
+  } finally {
+    database?.close();
+  }
+}
+function summarizeConfig(configPath) {
+  const result = { exists: false, path: configPath };
+  try {
+    if (!existsSync11(configPath))
+      return result;
+    result.exists = true;
+    result.mtimeMs = statSync2(configPath).mtimeMs;
+    const parsed = JSON.parse(readFileSync4(configPath, "utf-8"));
+    result.encrypted = parsed.encrypted === true;
+    if (typeof parsed.createdAt === "string")
+      result.createdAt = parsed.createdAt;
+    if (typeof parsed.version === "number")
+      result.version = parsed.version;
+    if (typeof parsed.defaultMintUrl === "string") {
+      result.defaultMintUrl = parsed.defaultMintUrl;
+    }
+    if (typeof parsed.mnemonic === "string") {
+      result.hasMnemonic = true;
+      if (!result.encrypted)
+        result.fingerprint = mnemonicFingerprint(parsed.mnemonic);
+    }
+  } catch (error53) {
+    result.error = error53 instanceof Error ? error53.message : String(error53);
+  }
+  return result;
+}
+function summarizeDb(dbPath) {
+  const result = { exists: false, path: dbPath };
+  try {
+    if (!existsSync11(dbPath))
+      return result;
+    result.exists = true;
+    const stats = statSync2(dbPath);
+    result.mtimeMs = stats.mtimeMs;
+    result.sizeBytes = stats.size;
+    const { summary, error: error53 } = summarizeDbReadonly(dbPath);
+    if (summary)
+      result.summary = summary;
+    if (error53)
+      result.error = error53;
+  } catch (error53) {
+    result.error = error53 instanceof Error ? error53.message : String(error53);
+  }
+  return result;
+}
+function summarizeWalletDirectory(dir, role) {
+  return {
+    dir,
+    role,
+    config: summarizeConfig(join13(dir, "config.json")),
+    db: summarizeDb(join13(dir, "coco.db"))
+  };
+}
+
+class WalletMigrationConflictError extends Error {
+  target;
+  source;
+  constructor(target, source) {
+    super(renderWalletConflict(target, source));
+    this.name = "WalletMigrationConflictError";
+    this.target = target;
+    this.source = source;
+  }
+}
+function timeAgo(ms) {
+  if (ms === undefined || !Number.isFinite(ms))
+    return;
+  const elapsed = Date.now() - ms;
+  if (elapsed < 0)
+    return;
+  const seconds = Math.floor(elapsed / 1000);
+  if (seconds < 5)
+    return "just now";
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 60)
+    return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  if (months < 24)
+    return `${months}mo ago`;
+  return `${Math.floor(days / 365)}y ago`;
+}
+function modifiedDescription(config2) {
+  if (config2.createdAt)
+    return `created ${config2.createdAt}`;
+  const ago = timeAgo(config2.mtimeMs);
+  if (ago)
+    return `modified ${ago}`;
+  return "modified time unknown";
+}
+function roleLabel(role) {
+  return role === "canonical" ? "current routstrd wallet" : "legacy cocod wallet";
+}
+function configLine(config2) {
+  if (!config2.exists)
+    return "config.json  absent";
+  if (config2.error)
+    return `config.json  present (unreadable: ${config2.error})`;
+  const parts = ["config.json  present"];
+  if (config2.fingerprint)
+    parts.push(`fingerprint ${config2.fingerprint}`);
+  else if (config2.encrypted)
+    parts.push("encrypted (mnemonic not readable)");
+  else
+    parts.push("no mnemonic found");
+  parts.push(modifiedDescription(config2));
+  if (config2.defaultMintUrl)
+    parts.push(`default mint ${config2.defaultMintUrl}`);
+  return parts.join(" \xB7 ");
+}
+function formatNumber(value) {
+  return value.toLocaleString("en-US");
+}
+function amountByStateLine(summary) {
+  const parts = Object.entries(summary.amountByState).filter(([, amount]) => amount > 0);
+  if (parts.length === 0)
+    return "0 sats";
+  return parts.map(([state, amount]) => `${state}: ${formatNumber(amount)} sats`).join(", ");
+}
+function dbLine(db) {
+  if (!db.exists)
+    return "coco.db     absent";
+  if (db.error && !db.summary)
+    return `coco.db     present (unreadable: ${db.error})`;
+  const parts = ["coco.db     present"];
+  if (db.summary) {
+    const { totalProofs, mints, distinctMints } = db.summary;
+    const mintCount = mints.length > 0 ? mints.length : distinctMints;
+    parts.push(`${formatNumber(totalProofs)} proof${totalProofs === 1 ? "" : "s"}`);
+    parts.push(amountByStateLine(db.summary));
+    parts.push(`${mintCount} mint${mintCount === 1 ? "" : "s"}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function block(diag, letter) {
+  return [
+    `  ${letter}) ${diag.dir} (${roleLabel(diag.role)})`,
+    `     ${configLine(diag.config)}`,
+    `     ${dbLine(diag.db)}`
+  ].join(`
+`);
+}
+function moveAsideCommands(target, source) {
+  return [
+    "  \u2022 If B is your wallet (keep the legacy wallet):",
+    `      mv "${target.dir}" "${target.dir}.old"`,
+    "",
+    "  \u2022 If A is your wallet (keep the normal routstrd wallet):",
+    `      mv "${source.dir}" "${source.dir}.old"`
+  ].join(`
+`);
+}
+function renderResolutionSteps(target, source) {
+  return [
+    "To resolve, decide which wallet is yours, move the other one aside, and run",
+    "'routstrd onboard' (or 'routstrd start') again. Stop the daemon first:",
+    "",
+    "  routstrd stop",
+    "",
+    "Then:",
+    "",
+    moveAsideCommands(target, source)
+  ].join(`
+`);
+}
+function renderWalletConflict(target, source) {
+  return [
+    "Cannot migrate wallet: two different wallets were found, and routstrd will",
+    "not choose a mnemonic or merge databases automatically \u2014 the wrong choice",
+    "could lose access to your funds.",
+    "",
+    block(target, "A"),
+    block(source, "B"),
+    "",
+    "No files were changed.",
+    "",
+    renderResolutionSteps(target, source),
+    "",
+    "For a full comparison and safe cleanup, run: routstrd wallet doctor"
+  ].join(`
+`);
+}
+
+// src/daemon/wallet/migration.ts
+function sqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
 function snapshotDatabase(sourcePath, destinationPath) {
-  const source = new Database3(sourcePath);
+  const source = new Database4(sourcePath);
   let sourceSummary;
   try {
     sourceSummary = verifyDatabase(source, "Legacy wallet database");
@@ -157795,7 +158751,7 @@ function snapshotDatabase(sourcePath, destinationPath) {
   } finally {
     source.close();
   }
-  const destination = new Database3(destinationPath, { readonly: true });
+  const destination = new Database4(destinationPath, { readonly: true });
   try {
     const destinationSummary = verifyDatabase(destination, "Staged wallet database");
     if (JSON.stringify(sourceSummary) !== JSON.stringify(destinationSummary)) {
@@ -157808,48 +158764,42 @@ function snapshotDatabase(sourcePath, destinationPath) {
 async function migrateLegacyWallet(options = {}) {
   const targetDir = options.walletDir || walletDir();
   const sourceDir = options.legacyDir || legacyCocodDir();
-  const targetConfig = join12(targetDir, "config.json");
-  const targetDb = join12(targetDir, "coco.db");
-  const sourceConfig = join12(sourceDir, "config.json");
-  const sourceDb = join12(sourceDir, "coco.db");
+  const sourceConfig = join14(sourceDir, "config.json");
+  const sourceDb = join14(sourceDir, "coco.db");
   const sourceWal = `${sourceDb}-wal`;
   const sourceShm = `${sourceDb}-shm`;
-  const targetState = state(targetConfig, targetDb);
-  const sourceState = state(sourceConfig, sourceDb);
-  if (targetState === "initialized" && sourceState === "initialized") {
-    const configsMatch = filesEqual(targetConfig, sourceConfig);
-    const databasesMatch = !existsSync10(targetDb) && !existsSync10(sourceDb) ? true : filesEqual(targetDb, sourceDb);
-    if (configsMatch && databasesMatch)
+  const classification = classifyWalletMigration(targetDir, sourceDir);
+  switch (classification.kind) {
+    case "fresh":
+      return { status: "fresh" };
+    case "already-current":
       return { status: "already-current" };
-    throw new Error(`Cannot migrate wallet: both ${targetDir} and ${sourceDir} contain different wallet data. ` + "Refusing to choose a mnemonic or merge wallet databases automatically.");
-  }
-  if (targetState === "initialized")
-    return { status: "already-current" };
-  if (!existsSync10(sourceDb) && (existsSync10(sourceWal) || existsSync10(sourceShm))) {
-    throw new Error(`Cannot migrate wallet: ${sourceDir} contains SQLite sidecar files without coco.db. ` + "Restore the matching main database before migration.");
-  }
-  if (targetState === "database-only" || sourceState === "database-only") {
-    throw new Error(`Cannot migrate wallet: ${targetDir} is ${targetState} and ${sourceDir} is ${sourceState}. ` + "A coco.db without config.json cannot be opened; restore the matching config first.");
+    case "migrate":
+      break;
+    case "conflict":
+      throw new WalletMigrationConflictError(summarizeWalletDirectory(targetDir, "canonical"), summarizeWalletDirectory(sourceDir, "legacy"));
+    case "orphaned-sidecars":
+      throw new Error(`Cannot migrate wallet: ${sourceDir} contains SQLite sidecar files without coco.db. ` + "Restore the matching main database before migration.");
+    case "database-only":
+      throw new Error(`Cannot migrate wallet: ${targetDir} is ${classification.targetState} and ${sourceDir} is ${classification.sourceState}. ` + "A coco.db without config.json cannot be opened; restore the matching config first.");
   }
-  if (sourceState === "absent")
-    return { status: "fresh" };
   await options.assertLegacyStopped?.();
   const releaseLegacyLock = await options.acquireLegacyLock?.();
-  const stagingDir = join12(dirname8(targetDir), `.${targetDir.split(/[\\/]/).at(-1) || "wallet"}.staging-${process.pid}-${Date.now()}`);
+  const stagingDir = join14(dirname8(targetDir), `.${targetDir.split(/[\\/]/).at(-1) || "wallet"}.staging-${process.pid}-${Date.now()}`);
   try {
     await options.assertLegacyStopped?.();
     mkdirSync9(dirname8(targetDir), { recursive: true, mode: 448 });
     mkdirSync9(stagingDir, { mode: 448 });
-    const stagedConfig = join12(stagingDir, "config.json");
-    const stagedDb = join12(stagingDir, "coco.db");
+    const stagedConfig = join14(stagingDir, "config.json");
+    const stagedDb = join14(stagingDir, "coco.db");
     copyFileSync(sourceConfig, stagedConfig);
     chmodSync(stagedConfig, 384);
-    const hasSourceDb = existsSync10(sourceDb);
+    const hasSourceDb = existsSync12(sourceDb);
     if (hasSourceDb) {
       snapshotDatabase(sourceDb, stagedDb);
       chmodSync(stagedDb, 384);
     }
-    if (statSync(stagedConfig).size !== statSync(sourceConfig).size) {
+    if (statSync3(stagedConfig).size !== statSync3(sourceConfig).size) {
       throw new Error("Cannot migrate wallet: staged config failed size validation.");
     }
     renameSync2(stagingDir, targetDir);
@@ -157860,13 +158810,13 @@ async function migrateLegacyWallet(options = {}) {
     releaseLegacyLock?.();
   }
   const cleanupWarnings = [];
-  const sourceFiles = [sourceConfig, sourceDb, sourceWal, sourceShm].filter(existsSync10);
+  const sourceFiles = [sourceConfig, sourceDb, sourceWal, sourceShm].filter(existsSync12);
   if (sourceFiles.length > 0) {
-    const archiveDir = join12(sourceDir, `wallet-migrated-${Date.now()}`);
+    const archiveDir = join14(sourceDir, `wallet-migrated-${Date.now()}`);
     try {
       mkdirSync9(archiveDir, { mode: 448 });
       for (const path2 of sourceFiles)
-        renameSync2(path2, join12(archiveDir, basename(path2)));
+        renameSync2(path2, join14(archiveDir, basename(path2)));
     } catch (error53) {
       const message = error53 instanceof Error ? error53.message : String(error53);
       cleanupWarnings.push(`Could not archive legacy wallet files: ${message}`);
@@ -157875,6 +158825,19 @@ async function migrateLegacyWallet(options = {}) {
   return { status: "migrated", from: sourceDir, to: targetDir, cleanupWarnings };
 }
 
+// src/daemon/fatal-error.ts
+function exitOnUncaughtException(error53, exit = (code) => process.exit(code)) {
+  logger5.error("UNCAUGHT EXCEPTION:", error53);
+  console.error("UNCAUGHT EXCEPTION:", error53);
+  exit(1);
+}
+function installGlobalErrorHandlers() {
+  process.on("uncaughtException", (error53) => exitOnUncaughtException(error53));
+  process.on("unhandledRejection", (reason) => {
+    logger5.error("UNHANDLED REJECTION:", reason);
+  });
+}
+
 // src/daemon/index.ts
 function makeSdkLogger2(prefix) {
   const tag2 = prefix ? `[${prefix}]` : undefined;
@@ -157893,13 +158856,15 @@ function startupProgress2(message) {
   logger5.info(message);
   console.log(`${STARTUP_LOG_PREFIX2} ${message}`);
 }
-process.on("uncaughtException", (error53) => {
-  logger5.error("UNCAUGHT EXCEPTION:", error53);
-});
-process.on("unhandledRejection", (reason) => {
-  logger5.error("UNHANDLED REJECTION:", reason);
-});
+installGlobalErrorHandlers();
 async function main() {
+  let shutdownDaemon = () => process.exit(0);
+  const shutdownForSignal = (signal) => {
+    logger5.log(`Received ${signal}; shutting down...`);
+    shutdownDaemon();
+  };
+  process.once("SIGINT", shutdownForSignal);
+  process.once("SIGTERM", shutdownForSignal);
   startupProgress2("Loading configuration...");
   const args = parseArgs(process.argv);
   const config2 = await loadDaemonConfig();
@@ -157937,26 +158902,18 @@ async function main() {
     socketPath: legacyCocodSocketPath(),
     pidFilePath: legacyCocodPidPath()
   });
-  let migrationLockOwner;
   const migration = await migrateLegacyWallet({
     assertLegacyStopped: () => assertLegacyCocodNotRunning({
-      socketPath: legacyCocodSocketPath(),
-      pidFilePath: legacyCocodPidPath(),
-      ignorePid: migrationLockOwner
+      socketPath: legacyCocodSocketPath()
     }),
     acquireLegacyLock: () => {
       mkdirSync10(dirname9(legacyCocodPidPath()), {
         recursive: true,
         mode: 448
       });
-      const release = claimLegacyCocodPidFile({
+      return claimLegacyCocodPidFile({
         pidFilePath: legacyCocodPidPath()
       });
-      migrationLockOwner = process.pid;
-      return () => {
-        migrationLockOwner = undefined;
-        release();
-      };
     }
   });
   if (migration.status === "migrated") {
@@ -157984,9 +158941,6 @@ async function main() {
   });
   const refundClient = new RoutstrClient(walletAdapter, storageAdapter, discoveryAdapter, "min", "apikeys", { logger: daemonSdkLogger });
   const server = createServer();
-  let shutdownDaemon = () => {
-    server.close(() => process.exit(0));
-  };
   server.on("request", createDaemonRequestHandler({
     provider,
     server,
@@ -158011,7 +158965,7 @@ async function main() {
   }));
   Bun.write(PID_FILE, String(process.pid));
   try {
-    if (existsSync11(SOCKET_PATH)) {
+    if (existsSync13(SOCKET_PATH)) {
       unlinkSync2(SOCKET_PATH);
     }
   } catch {}
@@ -158051,12 +159005,12 @@ async function main() {
       (async () => {
         logger5.log("Running scheduled refund...");
         try {
-          const state2 = store.getState();
-          const pendingDistribution = (state2.cachedTokens || []).map((t) => ({
+          const state = store.getState();
+          const pendingDistribution = (state.cachedTokens || []).map((t) => ({
             baseUrl: t.baseUrl,
             amount: t.balance || 0
           }));
-          const apiKeysStored = (state2.apiKeys || []).map((k6) => ({
+          const apiKeysStored = (state.apiKeys || []).map((k6) => ({
             baseUrl: k6.baseUrl,
             amount: k6.balance || 0
           }));
@@ -158103,12 +159057,11 @@ async function main() {
       disposeWallet().finally(() => process.exit(0));
     });
   };
-  const shutdownForSignal = (signal) => {
-    logger5.log(`Received ${signal}; shutting down...`);
-    shutdownDaemon();
-  };
-  process.once("SIGINT", shutdownForSignal);
-  process.once("SIGTERM", shutdownForSignal);
+  server.on("error", (error53) => {
+    logger5.error("Failed to start Routstr daemon:", error53);
+    console.error("Failed to start Routstr daemon:", error53 instanceof Error ? error53.message : error53);
+    process.exit(1);
+  });
   startupProgress2("Starting HTTP server...");
   server.listen(port, host, async () => {
     logger5.log(`Routstr daemon listening on http://${host}:${port}/v1`);