routstrd 0.3.11 → 0.4.0

package/tests/utils/daemon-client.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getDaemonBaseUrl,
+  urlHost,
+  urlHosts,
+} from "../../src/utils/daemon-client";
+import type { RoutstrdConfig } from "../../src/utils/config";
+
+function config(host: string): RoutstrdConfig {
+  return {
+    port: 8008,
+    host,
+    provider: null,
+    cocodPath: null,
+  };
+}
+
+describe("daemon URL host formatting", () => {
+  test("prefers IPv4 loopback for an IPv4 wildcard", () => {
+    expect(urlHosts("0.0.0.0")).toEqual(["127.0.0.1", "[::1]"]);
+    expect(getDaemonBaseUrl(config("0.0.0.0"))).toBe("http://127.0.0.1:8008");
+  });
+
+  test("prefers IPv6 loopback for an IPv6 wildcard", () => {
+    expect(urlHosts("::")).toEqual(["[::1]", "127.0.0.1"]);
+    expect(getDaemonBaseUrl(config("::"))).toBe("http://[::1]:8008");
+  });
+
+  test("brackets IPv6 literals", () => {
+    expect(urlHost("2001:db8::1")).toBe("[2001:db8::1]");
+    expect(getDaemonBaseUrl(config("2001:db8::1"))).toBe(
+      "http://[2001:db8::1]:8008",
+    );
+  });
+
+  test("does not bracket an already-bracketed IPv6 literal twice", () => {
+    expect(urlHost("[::1]")).toBe("[::1]");
+  });
+
+  test("escapes an IPv6 zone identifier for use in a URL", () => {
+    expect(urlHost("fe80::1%en0")).toBe("[fe80::1%25en0]");
+  });
+
+  test("leaves IPv4 addresses and hostnames unchanged", () => {
+    expect(urlHost("127.0.0.1")).toBe("127.0.0.1");
+    expect(urlHost("localhost")).toBe("localhost");
+  });
+
+  test("uses the default loopback when the host is absent", () => {
+    expect(urlHost()).toBe("127.0.0.1");
+  });
+
+  test("preserves an explicitly configured daemon URL", () => {
+    expect(
+      getDaemonBaseUrl({
+        ...config("::"),
+        daemonUrl: "https://daemon.example/",
+      }),
+    ).toBe("https://daemon.example");
+  });
+});

package/tests/wallet/short-keyset-token.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, mock } from "bun:test";
+import {
+  Amount,
+  getDecodedToken,
+  getEncodedToken,
+} from "@cashu/cashu-ts";
+import {
+  createWalletAdapter,
+  decodeCashuTokenAmount,
+} from "../../src/daemon/wallet";
+import type { CocodClient } from "../../src/daemon/wallet/cocod-client";
+
+// A full modern keyset ID with the same format as Minibits' post-migration
+// active keyset. getEncodedToken stores only its first eight bytes in TokenV4.
+const FULL_KEYSET_ID =
+  "01fc0ec0e59cd6fa01b7a88f8cd77fce81fd1e64bca67d752e984992b7a3c3a821";
+const LEGACY_KEYSET_ID = "00107937db0cc865";
+
+function makeToken({
+  amounts = [5],
+  keysetId = FULL_KEYSET_ID,
+  unit = "sat",
+}: {
+  amounts?: number[];
+  keysetId?: string;
+  unit?: string;
+} = {}): string {
+  return getEncodedToken({
+    mint: "https://mint.minibits.cash/Bitcoin",
+    unit,
+    proofs: amounts.map((amount, index) => ({
+      id: keysetId,
+      amount: Amount.from(amount),
+      secret: `short-keyset-regression-fixture-${index}`,
+      C: `02${(index + 1).toString(16).padStart(2, "0").repeat(32)}`,
+    })),
+  });
+}
+
+function makeWalletClient(
+  receiveCashu: CocodClient["receiveCashu"],
+): CocodClient {
+  // createWalletAdapter is intentionally lazy; this receive-path test only
+  // needs the one capability exercised by receiveToken.
+  return { receiveCashu } as CocodClient;
+}
+
+describe("short keyset TokenV4 compatibility", () => {
+  it("reads amount metadata without resolving the shortened proof keyset ID", () => {
+    const token = makeToken({ amounts: [1, 4] });
+
+    // Guard the fixture itself: a full proof decode with no mint keysets must
+    // exercise the same short-ID failure that triggered this regression.
+    expect(() => getDecodedToken(token, [])).toThrow(/short keyset ID/i);
+    expect(decodeCashuTokenAmount(token)).toEqual({
+      amount: 5,
+      unit: "sat",
+    });
+  });
+
+  for (const tokenCase of [
+    {
+      name: "modern keyset with msat unit",
+      input: { amounts: [500, 1000], unit: "msat" },
+      expected: { amount: 1500, unit: "msat" as const },
+    },
+    {
+      name: "legacy v0 keyset",
+      input: { amounts: [2, 8], keysetId: LEGACY_KEYSET_ID },
+      expected: { amount: 10, unit: "sat" as const },
+    },
+  ]) {
+    it(`reads ${tokenCase.name} metadata`, () => {
+      expect(decodeCashuTokenAmount(makeToken(tokenCase.input))).toEqual(
+        tokenCase.expected,
+      );
+    });
+  }
+
+  it("reports success after cocod receives a short-keyset token", async () => {
+    const receiveCashu = mock(async () => "Received 5");
+    const walletClient = makeWalletClient(receiveCashu);
+    const adapter = await createWalletAdapter({ walletClient });
+
+    const result = await adapter.receiveToken(makeToken());
+
+    expect(receiveCashu).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      success: true,
+      amount: 5,
+      unit: "sat",
+      message: "Received 5",
+    });
+  });
+
+  it("does not call the wallet when token metadata is invalid", async () => {
+    const receiveCashu = mock(async () => "should not be called");
+    const walletClient = makeWalletClient(receiveCashu);
+    const adapter = await createWalletAdapter({ walletClient });
+
+    const result = await adapter.receiveToken("cashuBnot-a-valid-token");
+
+    expect(receiveCashu).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+  });
+});