routstrd 0.4.7 → 0.4.9

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

@@ -1,168 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { selectCleanupOperations } from "./cleanup";
-
-const NOW_MS = 1_800_000_000_000;
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-function mint(overrides: Record<string, unknown>) {
-  return {
-    id: "mint-1",
-    state: "pending",
-    expiry: NOW_MS / 1000 - 1000, // expired
-    updatedAt: NOW_MS - 2 * DAY_MS,
-    lastObservedRemoteState: undefined,
-    ...overrides,
-  };
-}
-
-function send(overrides: Record<string, unknown>) {
-  return {
-    id: "send-1",
-    state: "pending",
-    updatedAt: NOW_MS - 2 * DAY_MS,
-    ...overrides,
-  };
-}
-
-function melt(overrides: Record<string, unknown>) {
-  return {
-    id: "melt-1",
-    state: "prepared",
-    updatedAt: NOW_MS - 2 * DAY_MS,
-    ...overrides,
-  };
-}
-
-describe("selectCleanupOperations", () => {
-  it("selects expired pending mint quotes that are old enough", () => {
-    const result = selectCleanupOperations({
-      mints: [mint({ id: "a" })],
-      sends: [],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.mintsToFail.map((op) => op.id)).toEqual(["a"]);
-  });
-
-  it("ignores mint quotes that have not expired", () => {
-    const result = selectCleanupOperations({
-      mints: [mint({ id: "a", expiry: NOW_MS / 1000 + 1000 })],
-      sends: [],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.mintsToFail).toEqual([]);
-  });
-
-  it("ignores expired mint quotes already observed as PAID", () => {
-    const result = selectCleanupOperations({
-      mints: [mint({ id: "a", lastObservedRemoteState: "PAID" })],
-      sends: [],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.mintsToFail).toEqual([]);
-  });
-
-  it("ignores expired mint quotes already observed as ISSUED", () => {
-    const result = selectCleanupOperations({
-      mints: [mint({ id: "a", lastObservedRemoteState: "ISSUED" })],
-      sends: [],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.mintsToFail).toEqual([]);
-  });
-
-  it("ignores mint quotes without an expiry", () => {
-    const result = selectCleanupOperations({
-      mints: [mint({ id: "a", expiry: 0 })],
-      sends: [],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.mintsToFail).toEqual([]);
-  });
-
-  it("selects expired mint quotes even when the watcher recently touched them", () => {
-    const result = selectCleanupOperations({
-      mints: [mint({ id: "a", updatedAt: NOW_MS - 60_000 })],
-      sends: [],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.mintsToFail.map((op) => op.id)).toEqual(["a"]);
-  });
-
-  it("selects stale pending sends for reclaim", () => {
-    const result = selectCleanupOperations({
-      mints: [],
-      sends: [send({ id: "s" })],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.sendsToReclaim.map((op) => op.id)).toEqual(["s"]);
-  });
-
-  it("ignores recent pending sends", () => {
-    const result = selectCleanupOperations({
-      mints: [],
-      sends: [send({ id: "s", updatedAt: NOW_MS - 60_000 })],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.sendsToReclaim).toEqual([]);
-  });
-
-  it("ignores non-pending sends even when old", () => {
-    const result = selectCleanupOperations({
-      mints: [],
-      sends: [send({ id: "s", state: "executing" })],
-      melts: [],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.sendsToReclaim).toEqual([]);
-  });
-
-  it("selects stale prepared melts for cancellation", () => {
-    const result = selectCleanupOperations({
-      mints: [],
-      sends: [],
-      melts: [melt({ id: "m" })],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.meltsToCancel.map((op) => op.id)).toEqual(["m"]);
-  });
-
-  it("ignores non-prepared melts", () => {
-    const result = selectCleanupOperations({
-      mints: [],
-      sends: [],
-      melts: [melt({ id: "m", state: "pending" })],
-      nowMs: NOW_MS,
-      minAgeMs: DAY_MS,
-    });
-
-    expect(result.meltsToCancel).toEqual([]);
-  });
-});

package/src/daemon/wallet/coco-client.npc.test.ts

@@ -1,252 +0,0 @@
-import { afterEach, describe, expect, it, mock } from "bun:test";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-// The real NPCPlugin opens a websocket to npubx.cash once the wallet is ready.
-// Mock the module before importing coco-client so tests never touch the network.
-const npcState = {
-  info: { name: "alice" as string | null, pubkey: "ab".repeat(32) },
-  usernameResult: { success: true } as
-    | { success: true }
-    | { success: false; pr: { amount: number; mints: string[] } },
-  setUsernameCalls: [] as Array<{ username: string; attemptPayment?: boolean }>,
-  syncCalls: 0,
-};
-
-class MockNPCPlugin {
-  readonly name = "npc";
-  readonly required = [] as const;
-  private readonly api = {
-    getInfo: async () => npcState.info,
-    setUsername: async (username: string, attemptPayment?: boolean) => {
-      npcState.setUsernameCalls.push({ username, attemptPayment });
-      return npcState.usernameResult;
-    },
-    sync: async () => {
-      npcState.syncCalls += 1;
-    },
-  };
-
-  onInit(ctx: { registerExtension: (key: string, api: unknown) => void }) {
-    ctx.registerExtension("npc", this.api);
-    return () => {};
-  }
-}
-
-mock.module("coco-cashu-plugin-npc", () => ({
-  NPCPlugin: MockNPCPlugin,
-}));
-
-const { createCocoClient } = await import("./coco-client");
-const { createCocodClient, CocodHttpError } = await import("./cocod-client");
-
-const TEST_MNEMONIC =
-  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
-
-const tempDirs: string[] = [];
-
-function makeWalletDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "routstrd-coco-npc-test-"));
-  tempDirs.push(dir);
-  const walletDir = join(dir, "wallet");
-  mkdirSync(walletDir, { recursive: true });
-  writeFileSync(
-    join(walletDir, "config.json"),
-    JSON.stringify({ version: 1, mnemonic: TEST_MNEMONIC, encrypted: false }),
-  );
-  return walletDir;
-}
-
-function testClientOptions(walletDir = makeWalletDir()) {
-  return {
-    walletDir,
-    legacySocketPath: join(walletDir, "legacy-cocod.sock"),
-    legacyPidPath: join(walletDir, "legacy-cocod.pid"),
-  };
-}
-
-function resetNpcState(): void {
-  npcState.info = { name: "alice", pubkey: "ab".repeat(32) };
-  npcState.usernameResult = { success: true };
-  npcState.setUsernameCalls = [];
-  npcState.syncCalls = 0;
-}
-
-afterEach(() => {
-  resetNpcState();
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("in-process coco client NPC integration", () => {
-  it("registers the plugin and exposes the wallet's NPC lightning address", async () => {
-    const client = await createCocoClient(testClientOptions());
-    try {
-      const info = await client.getNpcAddress();
-      expect(info).toEqual({
-        address: "alice@npubx.cash",
-        name: "alice",
-        pubkey: "ab".repeat(32),
-      });
-    } finally {
-      await client.dispose?.();
-    }
-  });
-
-  it("falls back to the npub address when no username is set", async () => {
-    npcState.info = { name: null, pubkey: "ab".repeat(32) };
-    const client = await createCocoClient(testClientOptions());
-    try {
-      const info = await client.getNpcAddress();
-      expect(info.address).toStartWith("npub1");
-      expect(info.address).toEndWith("@npubx.cash");
-      expect(info.name).toBeUndefined();
-      expect(info.pubkey).toBe("ab".repeat(32));
-    } finally {
-      await client.dispose?.();
-    }
-  });
-
-  it("maps payment-required username claims without paying", async () => {
-    npcState.usernameResult = {
-      success: false,
-      pr: { amount: 21, mints: ["https://mint.example.com"] },
-    };
-    const client = await createCocoClient(testClientOptions());
-    try {
-      const result = await client.setNpcUsername("bob");
-      expect(result).toEqual({
-        success: false,
-        paymentRequest: { amount: 21, mints: ["https://mint.example.com"] },
-      });
-      expect(npcState.setUsernameCalls).toEqual([
-        { username: "bob", attemptPayment: false },
-      ]);
-    } finally {
-      await client.dispose?.();
-    }
-  });
-
-  it("confirms the claim fee payment when requested", async () => {
-    const client = await createCocoClient(testClientOptions());
-    try {
-      const result = await client.setNpcUsername("bob", true);
-      expect(result).toEqual({ success: true });
-      expect(npcState.setUsernameCalls).toEqual([
-        { username: "bob", attemptPayment: true },
-      ]);
-    } finally {
-      await client.dispose?.();
-    }
-  });
-
-  it("triggers a manual quote sync", async () => {
-    const client = await createCocoClient(testClientOptions());
-    try {
-      await client.syncNpc();
-      expect(npcState.syncCalls).toBe(1);
-    } finally {
-      await client.dispose?.();
-    }
-  });
-
-  it("rejects NPC calls with a clear error when the plugin is disabled", async () => {
-    const client = await createCocoClient({
-      ...testClientOptions(),
-      enableNpc: false,
-    });
-    try {
-      await expect(client.getNpcAddress()).rejects.toThrow(
-        "NPC plugin is not enabled",
-      );
-      await expect(client.syncNpc()).rejects.toThrow(
-        "NPC plugin is not enabled",
-      );
-    } finally {
-      await client.dispose?.();
-    }
-  });
-});
-
-describe("legacy cocod client NPC passthroughs", () => {
-  type FetchImpl = (
-    input: string | URL | Request,
-    init?: RequestInit & { unix: string },
-  ) => Promise<Response>;
-
-  function legacyClient(handler: (path: string, body?: unknown) => Response) {
-    const requests: Array<{ path: string; body?: unknown }> = [];
-    const fetchImpl: FetchImpl = async (input, init) => {
-      const path = String(input).replace("http://localhost", "");
-      const body =
-        typeof init?.body === "string" ? JSON.parse(init.body) : undefined;
-      if (path !== "/ping") requests.push({ path, body });
-      if (path === "/ping") {
-        return new Response(JSON.stringify({ output: "pong" }));
-      }
-      return handler(path, body);
-    };
-    const client = createCocodClient({
-      socketPath: "/tmp/routstrd-test-legacy-npc/cocod.sock",
-      fetchImpl,
-    });
-    return { client, requests };
-  }
-
-  it("fetches and parses a username NPC address", async () => {
-    const { client, requests } = legacyClient(
-      () => new Response(JSON.stringify({ output: "alice@npubx.cash" })),
-    );
-    const info = await client.getNpcAddress();
-    expect(info).toEqual({ address: "alice@npubx.cash", name: "alice" });
-    expect(requests[0]?.path).toBe("/npc/address");
-  });
-
-  it("omits the name for npub fallback addresses", async () => {
-    const { client } = legacyClient(
-      () =>
-        new Response(JSON.stringify({ output: "npub1abc123@npubx.cash" })),
-    );
-    const info = await client.getNpcAddress();
-    expect(info).toEqual({ address: "npub1abc123@npubx.cash" });
-  });
-
-  it("posts username claims with the confirm flag", async () => {
-    const { client, requests } = legacyClient(
-      () => new Response(JSON.stringify({ output: { success: true } })),
-    );
-    const result = await client.setNpcUsername("bob", true);
-    expect(result).toEqual({ success: true });
-    expect(requests[0]).toEqual({
-      path: "/npc/username",
-      body: { username: "bob", confirm: true },
-    });
-  });
-
-  it("preserves the 402 payment-required error from cocod", async () => {
-    const { client } = legacyClient(
-      () =>
-        new Response(
-          JSON.stringify({ error: "Payment required to set username" }),
-          { status: 402 },
-        ),
-    );
-    try {
-      await client.setNpcUsername("bob");
-      expect.unreachable("should have thrown");
-    } catch (error) {
-      expect(error).toBeInstanceOf(CocodHttpError);
-      expect((error as InstanceType<typeof CocodHttpError>).status).toBe(402);
-      expect((error as Error).message).toContain("Payment required");
-    }
-  });
-
-  it("reports manual sync as unsupported", async () => {
-    const { client } = legacyClient(
-      () => new Response(JSON.stringify({ output: {} })),
-    );
-    await expect(client.syncNpc()).rejects.toThrow("not supported");
-  });
-});