routstrd 0.4.7 → 0.4.9

package/src/daemon/wallet/diagnostics.test.ts

@@ -1,378 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { Database } from "bun:sqlite";
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import {
-  diagnoseWallets,
-  mnemonicFingerprint,
-  renderWalletDoctor,
-  summarizeWalletDirectory,
-  WalletMigrationConflictError,
-} from "./diagnostics";
-
-const roots: string[] = [];
-function root(): string {
-  const path = mkdtempSync(join(tmpdir(), "routstrd-diagnostics-"));
-  roots.push(path);
-  return path;
-}
-afterEach(() => {
-  for (const path of roots.splice(0)) rmSync(path, { recursive: true, force: true });
-});
-
-const MNEMONIC_A =
-  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
-const MNEMONIC_B =
-  "legal winner thank year wave sausage worth useful legal winner thank yellow";
-
-function writeWalletConfig(dir: string, config: unknown): void {
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "config.json"), JSON.stringify(config));
-}
-
-function writeFakeDbFile(dir: string): void {
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "coco.db"), "not a real sqlite database");
-}
-
-function writeProofsDb(dir: string): void {
-  mkdirSync(dir, { recursive: true });
-  const db = new Database(join(dir, "coco.db"));
-  db.exec(`
-    CREATE TABLE coco_cashu_proofs (mintUrl TEXT, state TEXT, amount INTEGER);
-    INSERT INTO coco_cashu_proofs VALUES ('https://mint.example', 'ready', 100);
-    INSERT INTO coco_cashu_proofs VALUES ('https://mint.example', 'ready', 50);
-    INSERT INTO coco_cashu_proofs VALUES ('https://mint.example', 'pending', 30);
-    INSERT INTO coco_cashu_proofs VALUES ('https://other.example', 'spent', 20);
-    CREATE TABLE coco_cashu_mints (mintUrl TEXT, trusted INTEGER);
-    INSERT INTO coco_cashu_mints VALUES ('https://mint.example', 1);
-    INSERT INTO coco_cashu_mints VALUES ('https://other.example', 1);
-    INSERT INTO coco_cashu_mints VALUES ('https://third.example', 0);
-  `);
-  db.close();
-}
-
-describe("mnemonicFingerprint", () => {
-  it("is deterministic and normalizes whitespace", () => {
-    const base = mnemonicFingerprint(MNEMONIC_A);
-    expect(mnemonicFingerprint(MNEMONIC_A)).toBe(base);
-    expect(
-      mnemonicFingerprint("  abandon abandon   abandon abandon abandon abandon abandon abandon abandon abandon abandon about "),
-    ).toBe(base);
-  });
-
-  it("distinguishes different mnemonics and never returns the mnemonic", () => {
-    const a = mnemonicFingerprint(MNEMONIC_A);
-    const b = mnemonicFingerprint(MNEMONIC_B);
-    expect(a).not.toBe(b);
-    expect(a).not.toContain("abandon");
-    expect(b).not.toContain("legal");
-  });
-});
-
-describe("summarizeWalletDirectory", () => {
-  it("reports an empty directory", () => {
-    const dir = join(root(), "empty");
-    const diag = summarizeWalletDirectory(dir, "canonical");
-    expect(diag.config.exists).toBe(false);
-    expect(diag.db.exists).toBe(false);
-  });
-
-  it("summarizes a decrypted config with fingerprint and metadata", () => {
-    const dir = join(root(), "wallet");
-    writeWalletConfig(dir, {
-      version: 1,
-      mnemonic: MNEMONIC_A,
-      encrypted: false,
-      createdAt: "2026-08-20T14:03:22.000Z",
-      defaultMintUrl: "https://mint.example",
-    });
-    const diag = summarizeWalletDirectory(dir, "canonical");
-    expect(diag.config.exists).toBe(true);
-    expect(diag.config.fingerprint).toBe(mnemonicFingerprint(MNEMONIC_A));
-    expect(diag.config.hasMnemonic).toBe(true);
-    expect(diag.config.encrypted).toBe(false);
-    expect(diag.config.createdAt).toBe("2026-08-20T14:03:22.000Z");
-    expect(diag.config.defaultMintUrl).toBe("https://mint.example");
-    expect(diag.config.mtimeMs).toBeTypeOf("number");
-  });
-
-  it("does not derive a fingerprint for encrypted wallets", () => {
-    const dir = join(root(), "encrypted");
-    writeWalletConfig(dir, { mnemonic: MNEMONIC_A, encrypted: true });
-    const diag = summarizeWalletDirectory(dir, "canonical");
-    expect(diag.config.exists).toBe(true);
-    expect(diag.config.encrypted).toBe(true);
-    expect(diag.config.fingerprint).toBeUndefined();
-  });
-
-  it("degrades gracefully when config.json is malformed", () => {
-    const dir = join(root(), "bad-config");
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "config.json"), "not json");
-    const diag = summarizeWalletDirectory(dir, "canonical");
-    expect(diag.config.exists).toBe(true);
-    expect(diag.config.error).toBeTruthy();
-    expect(diag.config.fingerprint).toBeUndefined();
-  });
-
-  it("summarizes a proof database without opening it read-write", () => {
-    const dir = join(root(), "with-db");
-    writeProofsDb(dir);
-    const diag = summarizeWalletDirectory(dir, "canonical");
-    expect(diag.db.exists).toBe(true);
-    expect(diag.db.summary).toBeDefined();
-    expect(diag.db.summary?.totalProofs).toBe(4);
-    expect(diag.db.summary?.totalAmount).toBe(200);
-    expect(diag.db.summary?.distinctMints).toBe(2);
-    expect(diag.db.summary?.mints).toHaveLength(3);
-    expect(diag.db.summary?.amountByState).toEqual({
-      ready: 150,
-      pending: 30,
-      spent: 20,
-    });
-  });
-});
-
-describe("WalletMigrationConflictError", () => {
-  it("renders a structured conflict message without leaking mnemonics", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    writeWalletConfig(sourceDir, { mnemonic: MNEMONIC_B });
-
-    const err = new WalletMigrationConflictError(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(err.target.dir).toBe(targetDir);
-    expect(err.source.dir).toBe(sourceDir);
-    expect(err.message).toContain(targetDir);
-    expect(err.message).toContain(sourceDir);
-    expect(err.message).toContain("routstrd wallet doctor");
-    expect(err.message).toContain("routstrd stop");
-    expect(err.message).not.toContain("abandon");
-    expect(err.message).not.toContain("legal winner");
-  });
-});
-
-describe("renderWalletDoctor", () => {
-  it("reports different mnemonics as a conflict with resolution steps", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    writeWalletConfig(sourceDir, { mnemonic: MNEMONIC_B });
-
-    const report = renderWalletDoctor(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(report).toContain("DIFFERENT mnemonics");
-    expect(report).toContain("routstrd stop");
-    expect(report).toContain("mv \"");
-  });
-
-  it("reports matching mnemonics and warns startup still refuses", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    // Same mnemonic, but different bytes (extra metadata) — migration compares
-    // files, not mnemonics, so startup still refuses.
-    writeWalletConfig(sourceDir, {
-      mnemonic: MNEMONIC_A,
-      createdAt: "2026-01-01T00:00:00.000Z",
-    });
-
-    const report = renderWalletDoctor(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(report).toContain("share the same mnemonic");
-    expect(report).toContain("startup still refuses");
-    expect(report).toContain("mv \"");
-  });
-
-  it("omits resolution steps when there is nothing to resolve", () => {
-    const targetDir = join(root(), "wallet");
-    const emptyDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-
-    const report = renderWalletDoctor(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(emptyDir, "legacy"),
-    );
-    expect(report).toContain("no migration needed");
-    expect(report).not.toContain("routstrd stop");
-    expect(report).not.toContain("mv \"");
-  });
-
-  it("omits resolution steps for a fresh install", () => {
-    const report = renderWalletDoctor(
-      summarizeWalletDirectory(join(root(), "nope"), "canonical"),
-      summarizeWalletDirectory(join(root(), "alsonope"), "legacy"),
-    );
-    expect(report).toContain("fresh install");
-    expect(report).not.toContain("mv \"");
-  });
-
-  it("counts trusted mints from the mints table and formats amounts", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    writeWalletConfig(sourceDir, { mnemonic: MNEMONIC_B });
-    writeProofsDb(sourceDir);
-
-    const report = renderWalletDoctor(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    // 3 registered mints, not the 2 mints that happen to hold proofs.
-    expect(report).toContain("3 mints");
-  });
-
-  it("formats large balances with thousands separators", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    writeWalletConfig(sourceDir, { mnemonic: MNEMONIC_B });
-    mkdirSync(sourceDir, { recursive: true });
-    const db = new Database(join(sourceDir, "coco.db"));
-    db.exec(`
-      CREATE TABLE coco_cashu_proofs (mintUrl TEXT, state TEXT, amount INTEGER);
-      INSERT INTO coco_cashu_proofs VALUES ('https://mint.example', 'ready', 21000);
-    `);
-    db.close();
-
-    const report = renderWalletDoctor(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(report).toContain("ready: 21,000 sats");
-  });
-});
-
-describe("diagnoseWallets", () => {
-  it("flags conflicting mnemonics as a conflict needing resolution", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    writeWalletConfig(sourceDir, { mnemonic: MNEMONIC_B });
-
-    const verdict = diagnoseWallets(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(verdict.conflict).toBe(true);
-    expect(verdict.showResolution).toBe(true);
-  });
-
-  it("treats a single existing wallet as no conflict", () => {
-    const targetDir = join(root(), "wallet");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-
-    const verdict = diagnoseWallets(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(join(root(), ".cocod"), "legacy"),
-    );
-    expect(verdict.conflict).toBe(false);
-    expect(verdict.showResolution).toBe(false);
-  });
-
-  it("flags a legacy database without config as an incomplete conflict", () => {
-    const sourceDir = join(root(), ".cocod");
-    writeProofsDb(sourceDir);
-
-    const verdict = diagnoseWallets(
-      summarizeWalletDirectory(join(root(), "wallet"), "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(verdict.conflict).toBe(true);
-    expect(verdict.text).toContain("incomplete");
-  });
-
-  it("treats a stray legacy database as already-current when the canonical wallet exists", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    writeFakeDbFile(sourceDir);
-
-    const verdict = diagnoseWallets(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(verdict.conflict).toBe(false);
-    expect(verdict.showResolution).toBe(false);
-  });
-
-  it("flags an incomplete canonical database as a conflict", () => {
-    const targetDir = join(root(), "wallet");
-    writeFakeDbFile(targetDir);
-
-    const verdict = diagnoseWallets(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(join(root(), ".cocod"), "legacy"),
-    );
-    expect(verdict.conflict).toBe(true);
-    expect(verdict.showResolution).toBe(false);
-  });
-
-  it("flags orphaned legacy sidecars as a conflict", () => {
-    const sourceDir = join(root(), ".cocod");
-    mkdirSync(sourceDir, { recursive: true });
-    writeFileSync(join(sourceDir, "coco.db-wal"), "wal");
-    writeFileSync(join(sourceDir, "coco.db-shm"), "shm");
-
-    const verdict = diagnoseWallets(
-      summarizeWalletDirectory(join(root(), "wallet"), "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(verdict.conflict).toBe(true);
-    expect(verdict.showResolution).toBe(false);
-  });
-
-  it("treats byte-identical wallets as already-current", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    writeWalletConfig(targetDir, { mnemonic: MNEMONIC_A });
-    writeWalletConfig(sourceDir, { mnemonic: MNEMONIC_A });
-
-    const verdict = diagnoseWallets(
-      summarizeWalletDirectory(targetDir, "canonical"),
-      summarizeWalletDirectory(sourceDir, "legacy"),
-    );
-    expect(verdict.conflict).toBe(false);
-    expect(verdict.showResolution).toBe(false);
-  });
-
-  it("survives an unreadable wallet file without crashing", () => {
-    const targetDir = join(root(), "wallet");
-    const sourceDir = join(root(), ".cocod");
-    // Equal sizes force the classifier's filesEqual past the size check into
-    // raw reads, where the permission error would otherwise crash the doctor.
-    mkdirSync(targetDir, { recursive: true });
-    mkdirSync(sourceDir, { recursive: true });
-    writeFileSync(join(targetDir, "config.json"), `{"mnemonic":"${"a".repeat(50)}"}`);
-    const sourceConfig = join(sourceDir, "config.json");
-    writeFileSync(sourceConfig, `{"mnemonic":"${"b".repeat(50)}"}`);
-    chmodSync(sourceConfig, 0o000);
-
-    try {
-      const target = summarizeWalletDirectory(targetDir, "canonical");
-      const source = summarizeWalletDirectory(sourceDir, "legacy");
-      expect(source.config.error).toBeTruthy();
-
-      const verdict = diagnoseWallets(target, source);
-      expect(verdict.conflict).toBe(true);
-      expect(verdict.showResolution).toBe(true);
-      expect(verdict.text).toContain("could not be fully read");
-
-      // The full report must render too — this is the user-facing path.
-      const report = renderWalletDoctor(target, source);
-      expect(report).toContain("could not be fully read");
-      expect(report).toContain("mv \"");
-    } finally {
-      chmodSync(sourceConfig, 0o600);
-    }
-  });
-});

package/src/daemon/wallet/migration.test.ts

@@ -1,171 +0,0 @@
-import { afterEach, describe, expect, it, mock } from "bun:test";
-import { Database } from "bun:sqlite";
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { migrateLegacyWallet } from "./migration";
-import { WalletMigrationConflictError } from "./diagnostics";
-
-const roots: string[] = [];
-function root(): string {
-  const path = mkdtempSync(join(tmpdir(), "routstrd-migration-"));
-  roots.push(path);
-  return path;
-}
-afterEach(() => {
-  for (const path of roots.splice(0)) rmSync(path, { recursive: true, force: true });
-});
-
-describe("migrateLegacyWallet", () => {
-  it("snapshots committed WAL data and leaves process files behind", async () => {
-    const base = root();
-    const legacyDir = join(base, ".cocod");
-    const walletDir = join(base, ".routstrd", "wallet");
-    mkdirSync(legacyDir);
-    const config = JSON.stringify({
-      mnemonic: "seed words",
-      encrypted: false,
-      defaultMintUrl: "https://mint.example",
-      unknown: { preserved: true },
-    });
-    writeFileSync(join(legacyDir, "config.json"), config);
-    writeFileSync(join(legacyDir, "cocod.pid"), "123");
-    writeFileSync(join(legacyDir, "cocod.sock"), "not-a-real-socket");
-
-    const source = new Database(join(legacyDir, "coco.db"));
-    source.exec("PRAGMA journal_mode=WAL; PRAGMA wal_autocheckpoint=0");
-    source.exec(`
-      CREATE TABLE coco_cashu_proofs (mintUrl TEXT, state TEXT, amount INTEGER);
-      CREATE TABLE coco_cashu_counters (mintUrl TEXT, keysetId TEXT, counter INTEGER);
-      CREATE TABLE coco_cashu_mint_operations (state TEXT);
-      CREATE TABLE coco_cashu_send_operations (state TEXT);
-      CREATE TABLE coco_cashu_melt_operations (state TEXT);
-      CREATE TABLE coco_cashu_mints (mintUrl TEXT, trusted INTEGER);
-      INSERT INTO coco_cashu_proofs VALUES ('https://mint.example', 'ready', 21);
-      INSERT INTO coco_cashu_counters VALUES ('https://mint.example', 'keyset', 3);
-      INSERT INTO coco_cashu_mints VALUES ('https://mint.example', 1);
-    `);
-    expect(existsSync(join(legacyDir, "coco.db-wal"))).toBe(true);
-
-    const assertStopped = mock(async () => {});
-    const releaseLock = mock(() => {});
-    const acquireLock = mock(() => releaseLock);
-    const result = await migrateLegacyWallet({
-      walletDir,
-      legacyDir,
-      assertLegacyStopped: assertStopped,
-      acquireLegacyLock: acquireLock,
-    });
-    source.close();
-
-    expect(result.status).toBe("migrated");
-    expect(assertStopped).toHaveBeenCalledTimes(2);
-    expect(acquireLock).toHaveBeenCalledTimes(1);
-    expect(releaseLock).toHaveBeenCalledTimes(1);
-    expect(readFileSync(join(walletDir, "config.json"), "utf8")).toBe(config);
-    const migrated = new Database(join(walletDir, "coco.db"), { readonly: true });
-    expect(migrated.query("PRAGMA quick_check").values()).toEqual([["ok"]]);
-    expect(migrated.query("SELECT state, amount FROM coco_cashu_proofs").values()).toEqual([
-      ["ready", 21],
-    ]);
-    expect(migrated.query("SELECT counter FROM coco_cashu_counters").get()).toEqual({
-      counter: 3,
-    });
-    migrated.close();
-    expect(existsSync(join(walletDir, "coco.db-wal"))).toBe(false);
-    expect(statSync(walletDir).mode & 0o777).toBe(0o700);
-    expect(statSync(join(walletDir, "config.json")).mode & 0o777).toBe(0o600);
-    expect(existsSync(join(walletDir, "cocod.pid"))).toBe(false);
-    expect(existsSync(join(walletDir, "cocod.sock"))).toBe(false);
-    expect(existsSync(join(legacyDir, "config.json"))).toBe(false);
-    expect(existsSync(join(legacyDir, "coco.db"))).toBe(false);
-    expect(existsSync(join(legacyDir, "cocod.pid"))).toBe(true);
-    expect(existsSync(join(legacyDir, "cocod.sock"))).toBe(true);
-    const archive = readdirSync(legacyDir).find((name) => name.startsWith("wallet-migrated-"));
-    expect(archive).toBeDefined();
-    expect(existsSync(join(legacyDir, archive!, "config.json"))).toBe(true);
-    expect(existsSync(join(legacyDir, archive!, "coco.db"))).toBe(true);
-  });
-
-  it("treats a config-only initialized wallet as migratable", async () => {
-    const base = root();
-    const legacyDir = join(base, ".cocod");
-    const walletDir = join(base, ".routstrd", "wallet");
-    mkdirSync(legacyDir);
-    writeFileSync(join(legacyDir, "config.json"), '{"mnemonic":"seed"}');
-
-    expect((await migrateLegacyWallet({ walletDir, legacyDir })).status).toBe("migrated");
-    expect(existsSync(join(walletDir, "config.json"))).toBe(true);
-    expect(existsSync(join(walletDir, "coco.db"))).toBe(false);
-  });
-
-  it("refuses a database without its mnemonic config", async () => {
-    const base = root();
-    const legacyDir = join(base, ".cocod");
-    mkdirSync(legacyDir);
-    writeFileSync(join(legacyDir, "coco.db"), "database");
-
-    await expect(migrateLegacyWallet({ walletDir: join(base, "wallet"), legacyDir })).rejects.toThrow(
-      "without config.json",
-    );
-  });
-
-  it("refuses orphaned SQLite sidecars", async () => {
-    const base = root();
-    const legacyDir = join(base, ".cocod");
-    mkdirSync(legacyDir);
-    writeFileSync(join(legacyDir, "coco.db-wal"), "orphaned WAL");
-
-    await expect(migrateLegacyWallet({ walletDir: join(base, "wallet"), legacyDir })).rejects.toThrow(
-      "sidecar files without coco.db",
-    );
-  });
-
-  it("refuses when both canonical and legacy configs exist", async () => {
-    const base = root();
-    const legacyDir = join(base, ".cocod");
-    const walletDir = join(base, ".routstrd", "wallet");
-    mkdirSync(legacyDir, { recursive: true });
-    mkdirSync(walletDir, { recursive: true });
-    writeFileSync(
-      join(legacyDir, "config.json"),
-      JSON.stringify({ mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" }),
-    );
-    writeFileSync(
-      join(walletDir, "config.json"),
-      JSON.stringify({ mnemonic: "legal winner thank year wave sausage worth useful legal winner thank yellow" }),
-    );
-
-    let thrown: unknown;
-    try {
-      await migrateLegacyWallet({ walletDir, legacyDir });
-    } catch (error) {
-      thrown = error;
-    }
-
-    expect(thrown).toBeInstanceOf(WalletMigrationConflictError);
-    const err = thrown as WalletMigrationConflictError;
-    expect(err.target.dir).toBe(walletDir);
-    expect(err.source.dir).toBe(legacyDir);
-    expect(err.message).toContain("two different wallets were found");
-    expect(err.message).toContain(walletDir);
-    expect(err.message).toContain(legacyDir);
-    expect(err.message).not.toContain("abandon");
-    expect(err.message).not.toContain("legal winner");
-    expect(readFileSync(join(walletDir, "config.json"), "utf8")).toContain(
-      "legal winner",
-    );
-    expect(readFileSync(join(legacyDir, "config.json"), "utf8")).toContain(
-      "abandon abandon",
-    );
-  });
-});