@getalby/cli 0.6.1 → 0.8.0

package/build/test/amount-model.test.js

@@ -0,0 +1,111 @@
+import { describe, test, expect } from "vitest";
+import { runCli } from "./helpers.js";
+// Exercises the shared amount model (src/amount.ts) wired into every
+// amount-bearing command. Every check here resolves *before* network I/O or
+// wallet load: structural validation (currency/network/unit rules) and the
+// BTC sats/BTC arithmetic are all synchronous. We sanitize the environment so
+// that, when an input is fully valid, the command fails only at wallet load
+// ("No wallet connection found") — proving the input cleared every gate.
+//
+// The two cross-rail *currency* mismatches that need a downstream resolver to
+// surface (a token on the lightning rail → rate lookup; a fiat code's live
+// rate) are intentionally covered by the live suites, not here, since the
+// model is network-first (the rail is chosen by --network alone, with no
+// hardcoded currency/token catalog).
+const SANITIZED_ENV = {
+    HOME: "/tmp/nonexistent-alby-cli-test-home",
+    NWC_URL: "",
+};
+function run(command) {
+    return runCli(command, SANITIZED_ENV);
+}
+describe("amount model — currency and network are always required", () => {
+    test("amount without --currency is rejected", () => {
+        const result = run("pay alice@getalby.com --amount 100 --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency");
+    });
+    test("amount without --network is rejected", () => {
+        const result = run("pay alice@getalby.com --amount 100 --currency BTC --unit sats");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--network");
+    });
+});
+describe("amount model — --unit is required for BTC, rejected otherwise", () => {
+    test("BTC without --unit is rejected (sats vs BTC must be explicit)", () => {
+        const result = run("pay alice@getalby.com --amount 1 --currency BTC --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit");
+    });
+    test("--unit on a fiat currency is rejected", () => {
+        const result = run("pay alice@getalby.com --amount 5 --currency USD --unit sats --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit is not valid");
+    });
+    test('an invalid --unit value is rejected', () => {
+        const result = run("pay alice@getalby.com --amount 1 --currency BTC --unit bits --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain('--unit must be "sats" or "BTC"');
+    });
+});
+describe("amount model — BTC --unit sats is whole-number only", () => {
+    test.each(["1.5", "1abc", "0"])("make-invoice rejects --amount %s for BTC/sats", (value) => {
+        const result = run(`make-invoice --amount ${value} --currency BTC --unit sats --network lightning`);
+        expect(result.success).toBe(false);
+        // "1.5" is rejected by the sats whole-number check; "1abc"/"0" by the
+        // strict --amount parser at parse time.
+        expect(result.output.error).toMatch(/whole number|Amount must be a positive number/);
+    });
+});
+describe("amount model — BTC --unit BTC converts to sats", () => {
+    test("a fractional-sat BTC amount is rejected", () => {
+        // 0.000000001 BTC = 0.1 sats — not a whole number of sats.
+        const result = run("make-invoice --amount 0.000000001 --currency BTC --unit BTC --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("whole number of sats");
+    });
+    test("a whole-sat BTC amount clears validation (fails only at wallet load)", () => {
+        // 0.000001 BTC = 100 sats. Resolution is synchronous, so the only thing
+        // left to fail is the (absent) wallet.
+        const result = run("make-invoice --amount 0.000001 --currency BTC --unit BTC --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("No wallet connection found");
+    });
+});
+describe("amount model — rail mismatch on a lightning-only command", () => {
+    test("BTC on a chain network is rejected", () => {
+        const result = run("make-invoice --amount 1 --currency BTC --network arbitrum");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("only supported on --network lightning");
+    });
+    test("a chain network is rejected (invoices settle over Lightning)", () => {
+        const result = run("make-invoice --amount 10 --currency USDC --network arbitrum");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("lightning");
+    });
+});
+// Representative coverage proving the shared helper is wired into more than
+// one command, not just make-invoice / pay.
+describe("amount model — wired across commands", () => {
+    test("make-hold-invoice enforces --unit for BTC", () => {
+        const result = run("make-hold-invoice --amount 1 --currency BTC --network lightning --payment-hash " +
+            "a".repeat(64));
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit");
+    });
+    test("pay-keysend enforces --unit for BTC", () => {
+        const result = run(`pay-keysend -p 02${"a".repeat(64)} --amount 1 --currency BTC --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit");
+    });
+    test("request-invoice-from-lightning-address rejects --unit for fiat", () => {
+        const result = run("request-invoice-from-lightning-address -a a@b.com --amount 5 --currency USD --unit sats --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit is not valid");
+    });
+    test("sats-to-fiat rejects an invalid --unit", () => {
+        const result = run("sats-to-fiat --amount 1000 --unit bits --currency USD");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain('--unit must be "sats" or "BTC"');
+    });
+});

package/build/test/connection-secret.test.js

@@ -50,12 +50,12 @@ describe("Connection Secret Handling", () => {
             NWC_URL: "",
         });
         expect(result.success).toBe(false);
-        expect(result.output.error).toContain("No connection secret provided");
+        expect(result.output.error).toContain("No wallet connection found");
     });
     test("errors when connection string is malformed", () => {
         const result = runCli(`-c "nostr+walletconnect://asdf" get-balance`);
         expect(result.success).toBe(false);
-        expect(result.output.error).toContain("Invalid connection secret");
+        expect(result.output.error).toContain("Invalid NWC URL");
     });
     test("reads connection secret from NWC_URL environment variable", () => {
         const result = runCli("get-balance", { NWC_URL: wallet.nwcUrl });

package/build/test/fetch-max-amount.test.js

@@ -0,0 +1,30 @@
+import { describe, test, expect } from "vitest";
+import { runCli } from "./helpers.js";
+// fetch's `--max-amount` is the unified spend-cap flag. Its value is a strict
+// sats integer (see `parseMaxAmountSats` in src/commands/fetch.ts) because the
+// cap is currently restricted to BTC/sats over lightning; the denomination flags are
+// validated through the shared amount model (src/amount.ts). Parsing happens at
+// commander parse time — before any network I/O — so these assertions are
+// deterministic and need no wallet. Payment/invoice amounts are covered by
+// amount-model.test.ts.
+describe("fetch --max-amount strict parsing", () => {
+    // The cap is a positive whole number of sats. Malformed input must be
+    // rejected, not coerced (parseInt("abc") → NaN, parseInt("0.5") → 0), so a
+    // typo can't silently weaken the limit. Negatives are rejected by the
+    // digits-only check, and 0 is no longer a "no limit" escape hatch.
+    test.each(["0.5", "abc", "-1", "1e3", "0"])("rejects malformed/non-positive --max-amount %s", (value) => {
+        const result = runCli(`fetch http://example.invalid --max-amount ${value}`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Sats must be");
+    });
+    test("a positive --max-amount requires its denomination (--currency)", () => {
+        const result = runCli("fetch http://example.invalid --max-amount 1000");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency");
+    });
+    test("a positive --max-amount rejects a non-BTC/sats/lightning denomination", () => {
+        const result = runCli("fetch http://example.invalid --max-amount 5 --currency USD --network lightning");
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("currently supports only --currency BTC --unit sats --network lightning");
+    });
+});

package/build/test/lightning-tools.test.js

@@ -1,16 +1,29 @@
 import { describe, test, expect } from "vitest";
 import { runCli } from "./helpers.js";
 const exampleInvoice = "lnbc1u1p5hlrr8dqqnp4qwmtpr4p72ms7gnq3pkfk2876y2msvl33s3840dlp6xsv2w59dpscpp55utq6s8u5407namwt4jvhgsaf9fyszppjfwyxp7qsw6cyc8vxukqsp583usez9yhmkcavvvjz8cq56v3nglh2q37xkf4ufrgwxfrfjkm54s9qyysgqcqzp2xqyz5vqgtyysw64zt9sj6kfpqnekzwc37y2uyg0xdapgxqqth4uahff0x89sjfsvukjlllasg5dn05u2uha6qcvxz2y3ye5k7958qtes4pv4ggqtnjyky";
-const exampleLightningAddress = "nwc1769966844@getalby.com";
+const exampleLightningAddress = "nwc1779952113427@getalby.com";
 describe("Lightning Tools (no wallet required)", () => {
     test("fiat-to-sats converts USD to sats", () => {
-        const result = runCli("fiat-to-sats -a 1 --currency USD");
+        const result = runCli("fiat-to-sats --amount 1 --currency USD");
         expect(result.success).toBe(true);
         expect(result.output.amount_in_sats).toBeTypeOf("number");
         expect(result.output.amount_in_sats).toBeGreaterThan(0);
     });
+    test("fiat-to-sats accepts a decimal --amount", () => {
+        const result = runCli("fiat-to-sats --amount 10.5 --currency USD");
+        expect(result.success).toBe(true);
+        expect(result.output.amount_in_sats).toBeGreaterThan(0);
+    });
+    // --amount is parsed by the shared strict parser (parseAmountNumber), so
+    // partial/invalid input is rejected rather than silently truncated (e.g.
+    // "10abc" → 10), as are non-positive values.
+    test.each(["10abc", "abc", "0", "-5"])("fiat-to-sats rejects invalid --amount %s", (value) => {
+        const result = runCli(`fiat-to-sats --amount ${value} --currency USD`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Amount must be a positive number");
+    });
     test("sats-to-fiat converts sats to USD", () => {
-        const result = runCli("sats-to-fiat -a 1000 --currency USD");
+        const result = runCli("sats-to-fiat --amount 1000 --unit sats --currency USD");
         expect(result.success).toBe(true);
         expect(result.output.amount).toBeTypeOf("number");
         expect(result.output.amount).toBeGreaterThan(0);
@@ -29,7 +42,7 @@ describe("Lightning Tools (no wallet required)", () => {
         expect(result.output.valid).toBe(false);
     });
     test("request-invoice-from-lightning-address requests invoice from lightning address", async () => {
-        const result = runCli(`request-invoice-from-lightning-address -a "${exampleLightningAddress}" -s 100`);
+        const result = runCli(`request-invoice-from-lightning-address -a "${exampleLightningAddress}" --amount 100 --currency BTC --unit sats --network lightning`);
         expect(result.success).toBe(true);
         expect(result.output.paymentRequest.toLowerCase()).toMatch(/^lnbc/);
     });

package/build/test/list-wallets.test.js

@@ -0,0 +1,75 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { runCli } from "./helpers.js";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+describe("list-wallets command", () => {
+    let testHome;
+    let albyDir;
+    beforeEach(() => {
+        testHome = mkdtempSync(join(tmpdir(), "alby-cli-test-"));
+        albyDir = join(testHome, ".alby-cli");
+    });
+    afterEach(() => {
+        rmSync(testHome, { recursive: true, force: true });
+    });
+    function writeWallet(filename) {
+        mkdirSync(albyDir, { recursive: true });
+        writeFileSync(join(albyDir, filename), "nostr+walletconnect://test");
+    }
+    test("returns empty list when no .alby-cli directory exists", () => {
+        const result = runCli("list-wallets", { HOME: testHome });
+        expect(result.success).toBe(true);
+        expect(result.output.wallets).toEqual([]);
+    });
+    test("lists the default (unnamed) wallet", () => {
+        writeWallet("connection-secret.key");
+        const result = runCli("list-wallets", { HOME: testHome });
+        expect(result.success).toBe(true);
+        expect(result.output.wallets).toEqual([
+            { name: null, isDefault: true, status: "connected" },
+        ]);
+    });
+    test("lists named wallets sorted with default first", () => {
+        writeWallet("connection-secret.key");
+        writeWallet("connection-secret-work.key");
+        writeWallet("connection-secret-personal.key");
+        const result = runCli("list-wallets", { HOME: testHome });
+        expect(result.success).toBe(true);
+        expect(result.output.wallets).toEqual([
+            { name: null, isDefault: true, status: "connected" },
+            { name: "personal", isDefault: false, status: "connected" },
+            { name: "work", isDefault: false, status: "connected" },
+        ]);
+    });
+    test("reports pending connections", () => {
+        writeWallet("pending-connection-secret-test.key");
+        const result = runCli("list-wallets", { HOME: testHome });
+        expect(result.success).toBe(true);
+        expect(result.output.wallets).toEqual([
+            { name: "test", isDefault: false, status: "pending" },
+        ]);
+    });
+    test("connected status takes precedence over pending for the same wallet", () => {
+        writeWallet("connection-secret-dual.key");
+        writeWallet("pending-connection-secret-dual.key");
+        const result = runCli("list-wallets", { HOME: testHome });
+        expect(result.success).toBe(true);
+        expect(result.output.wallets).toEqual([
+            { name: "dual", isDefault: false, status: "connected" },
+        ]);
+    });
+    test("does not reveal secret contents", () => {
+        writeWallet("connection-secret.key");
+        const result = runCli("list-wallets", { HOME: testHome });
+        expect(JSON.stringify(result.output)).not.toContain("nostr+walletconnect://");
+    });
+    test("ignores unrelated files", () => {
+        mkdirSync(albyDir, { recursive: true });
+        writeFileSync(join(albyDir, "pending-connection-relay-test.txt"), "wss://relay");
+        writeFileSync(join(albyDir, "notes.txt"), "hello");
+        const result = runCli("list-wallets", { HOME: testHome });
+        expect(result.success).toBe(true);
+        expect(result.output.wallets).toEqual([]);
+    });
+});

package/build/test/nwc-hold-invoices.test.js

@@ -11,7 +11,7 @@ describe("NWC HOLD Invoice Commands", () => {
     }, 60000);
     test("make-hold-invoice creates hold invoice", () => {
         const { paymentHash } = generateHoldInvoiceParams();
-        const result = runCli(`-c "${receiver.nwcUrl}" make-hold-invoice -a 100 --payment-hash "${paymentHash}"`);
+        const result = runCli(`-c "${receiver.nwcUrl}" make-hold-invoice --amount 100 --currency BTC --unit sats --network lightning --payment-hash "${paymentHash}"`);
         expect(result.success).toBe(true);
         expect(result.output.invoice).toBeDefined();
         expect(result.output.payment_hash).toBe(paymentHash);
@@ -19,7 +19,7 @@ describe("NWC HOLD Invoice Commands", () => {
     test("settle-hold-invoice settles with preimage", async () => {
         const { preimage, paymentHash } = generateHoldInvoiceParams();
         // Create a hold invoice
-        const holdResult = runCli(`-c "${receiver.nwcUrl}" make-hold-invoice -a 100 --payment-hash "${paymentHash}"`);
+        const holdResult = runCli(`-c "${receiver.nwcUrl}" make-hold-invoice --amount 100 --currency BTC --unit sats --network lightning --payment-hash "${paymentHash}"`);
         expect(holdResult.success).toBe(true);
         // Start wait-for-payment in background
         const waitProcess = spawn("node", [
@@ -40,7 +40,6 @@ describe("NWC HOLD Invoice Commands", () => {
             "-c",
             sender.nwcUrl,
             "pay-invoice",
-            "-i",
             holdResult.output.invoice,
         ], { stdio: ["ignore", "pipe", "pipe"] });
         // Wait for the hold invoice to be accepted
@@ -56,7 +55,7 @@ describe("NWC HOLD Invoice Commands", () => {
     test("cancel-hold-invoice cancels hold invoice", async () => {
         const { paymentHash } = generateHoldInvoiceParams();
         // Create a hold invoice
-        const holdResult = runCli(`-c "${receiver.nwcUrl}" make-hold-invoice -a 100 --payment-hash "${paymentHash}"`);
+        const holdResult = runCli(`-c "${receiver.nwcUrl}" make-hold-invoice --amount 100 --currency BTC --unit sats --network lightning --payment-hash "${paymentHash}"`);
         expect(holdResult.success).toBe(true);
         // Pay the invoice from sender (this will put it in held state)
         const payProcess = spawn("node", [
@@ -64,7 +63,6 @@ describe("NWC HOLD Invoice Commands", () => {
             "-c",
             sender.nwcUrl,
             "pay-invoice",
-            "-i",
             holdResult.output.invoice,
         ], { stdio: ["ignore", "pipe", "pipe"] });
         // Wait for the hold invoice to be in held state

package/build/test/nwc-payments.test.js

@@ -10,20 +10,20 @@ describe("NWC Payment Commands", () => {
     }, 60000);
     test("make-invoice and pay-invoice", () => {
         // Create invoice with receiver wallet
-        const invoiceResult = runCli(`-c "${receiver.nwcUrl}" make-invoice -a 100`);
+        const invoiceResult = runCli(`-c "${receiver.nwcUrl}" make-invoice --amount 100 --currency BTC --unit sats --network lightning`);
         expect(invoiceResult.success).toBe(true);
         expect(invoiceResult.output.invoice).toBeDefined();
         // Pay with sender wallet
-        const paymentResult = runCli(`-c "${sender.nwcUrl}" pay-invoice -i "${invoiceResult.output.invoice}"`);
+        const paymentResult = runCli(`-c "${sender.nwcUrl}" pay-invoice "${invoiceResult.output.invoice}"`);
         expect(paymentResult.success).toBe(true);
         expect(paymentResult.output.preimage).toBeDefined();
     });
     test("lookup-invoice finds paid invoice", () => {
         // Create an invoice
-        const invoiceResult = runCli(`-c "${receiver.nwcUrl}" make-invoice -a 50`);
+        const invoiceResult = runCli(`-c "${receiver.nwcUrl}" make-invoice --amount 50 --currency BTC --unit sats --network lightning`);
         expect(invoiceResult.success).toBe(true);
         // Pay the invoice first (unpaid invoices may not be found)
-        const payResult = runCli(`-c "${sender.nwcUrl}" pay-invoice -i "${invoiceResult.output.invoice}"`);
+        const payResult = runCli(`-c "${sender.nwcUrl}" pay-invoice "${invoiceResult.output.invoice}"`);
         expect(payResult.success).toBe(true);
         // Lookup the paid invoice using the invoice string
         const lookupResult = runCli(`-c "${receiver.nwcUrl}" lookup-invoice -i "${invoiceResult.output.invoice}"`);
@@ -35,7 +35,7 @@ describe("NWC Payment Commands", () => {
         const infoResult = runCli(`-c "${receiver.nwcUrl}" get-info`);
         expect(infoResult.success).toBe(true);
         // Send keysend payment
-        const keysendResult = runCli(`-c "${sender.nwcUrl}" pay-keysend -p "${infoResult.output.pubkey}" -a 100`);
+        const keysendResult = runCli(`-c "${sender.nwcUrl}" pay-keysend -p "${infoResult.output.pubkey}" --amount 100 --currency BTC --unit sats --network lightning`);
         expect(keysendResult.success).toBe(true);
         expect(keysendResult.output.preimage).toBeDefined();
     });

package/build/test/pay-command.test.js

@@ -0,0 +1,131 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { createTestWallet, runCli } from "./helpers.js";
+const pubkey = "02" + "a".repeat(64);
+const evm = "0x000000000000000000000000000000000000dead";
+describe("pay command — destination detection", () => {
+    test("unknown destination format lists all 4 accepted shapes", () => {
+        const result = runCli(`pay notavaliddestination`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Could not detect destination type");
+        expect(result.output.error).toContain("BOLT-11 invoice");
+        expect(result.output.error).toContain("Lightning address");
+        expect(result.output.error).toContain("Node pubkey");
+        expect(result.output.error).toContain("EVM address");
+    });
+    test("lightning address without --amount is rejected before wallet load", () => {
+        const result = runCli(`pay alice@getalby.com`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--amount");
+    });
+    test("keysend pubkey without --amount is rejected before wallet load", () => {
+        const result = runCli(`pay ${pubkey}`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--amount");
+    });
+    test("EVM address without --amount is rejected before wallet load", () => {
+        const result = runCli(`pay ${evm}`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--amount");
+    });
+});
+describe("pay command — unified amount model validation", () => {
+    test("lightning address with --amount but no --currency is rejected", () => {
+        const result = runCli(`pay alice@getalby.com --amount 100 --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency");
+    });
+    test("lightning address with --amount but no --network is rejected", () => {
+        const result = runCli(`pay alice@getalby.com --amount 100 --currency BTC`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--network");
+    });
+    test("--currency BTC without --unit is rejected (sats/BTC ambiguity)", () => {
+        const result = runCli(`pay alice@getalby.com --amount 100 --currency BTC --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit");
+    });
+    test("--unit on a fiat currency is rejected", () => {
+        const result = runCli(`pay alice@getalby.com --amount 5 --currency USD --unit sats --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit is not valid");
+    });
+    test("a lightning address on a chain network is rejected (lightning-only)", () => {
+        const result = runCli(`pay alice@getalby.com --amount 10 --currency USDC --network arbitrum`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("lightning");
+    });
+    test("a non-numeric --amount is rejected at parse time", () => {
+        const result = runCli(`pay alice@getalby.com --amount 123usd --currency BTC --unit sats --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Amount must be a positive number");
+    });
+    test("EVM address with --currency BTC --network lightning is rejected", () => {
+        const result = runCli(`pay ${evm} --amount 10 --currency BTC --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("EVM address");
+    });
+    test("EVM address without --currency is rejected", () => {
+        const result = runCli(`pay ${evm} --amount 10 --network arbitrum`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency");
+    });
+    test("EVM address without --network is rejected", () => {
+        const result = runCli(`pay ${evm} --amount 10 --currency USDC`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--network");
+    });
+    test("amount flags on a BOLT-11 invoice without --amount are rejected", () => {
+        const result = runCli(`pay lnbc1junk --currency USDT`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("zero-amount invoice");
+    });
+    test("testnet/signet invoice prefixes (lntb...) are recognized as invoices", () => {
+        const result = runCli(`pay lntb1junk --currency USDT`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("zero-amount invoice");
+    });
+    test("--comment on a keysend pubkey is rejected as not applicable", () => {
+        const result = runCli(`pay ${pubkey} --amount 100 --currency BTC --unit sats --network lightning --comment hi`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("not applicable to keysend payment");
+    });
+    test("--unit on an EVM (crypto) destination is rejected", () => {
+        const result = runCli(`pay ${evm} --amount 10 --currency USDC --unit sats --network arbitrum`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit");
+    });
+});
+describe("pay command — live integration", () => {
+    let sender;
+    let receiver;
+    beforeAll(async () => {
+        sender = await createTestWallet();
+        receiver = await createTestWallet();
+    }, 60000);
+    test("pay <bolt11> pays an invoice end-to-end", () => {
+        const invoiceResult = runCli(`-c "${receiver.nwcUrl}" make-invoice --amount 100 --currency BTC --unit sats --network lightning`);
+        expect(invoiceResult.success).toBe(true);
+        const paymentResult = runCli(`-c "${sender.nwcUrl}" pay "${invoiceResult.output.invoice}"`);
+        expect(paymentResult.success).toBe(true);
+        expect(paymentResult.output.preimage).toBeDefined();
+    });
+    test("pay <lightning-address> --currency BTC --unit sats pays it", () => {
+        const paymentResult = runCli(`-c "${sender.nwcUrl}" pay ${receiver.lightningAddress} --amount 100 --currency BTC --unit sats --network lightning`);
+        expect(paymentResult.success).toBe(true);
+        expect(paymentResult.output.preimage).toBeDefined();
+    });
+    test("pay <lightning-address> --currency USD resolves fiat to sats and pays", () => {
+        const paymentResult = runCli(`-c "${sender.nwcUrl}" pay ${receiver.lightningAddress} --amount 1 --currency USD --network lightning`);
+        expect(paymentResult.success).toBe(true);
+        expect(paymentResult.output.preimage).toBeDefined();
+        expect(paymentResult.output.amount_in_sats).toBeGreaterThan(0);
+        expect(paymentResult.output.fiat).toEqual({ amount: 1, currency: "USD" });
+    });
+    test("pay <pubkey> --currency BTC --unit sats sends a keysend payment", () => {
+        const infoResult = runCli(`-c "${receiver.nwcUrl}" get-info`);
+        expect(infoResult.success).toBe(true);
+        const paymentResult = runCli(`-c "${sender.nwcUrl}" pay ${infoResult.output.pubkey} --amount 100 --currency BTC --unit sats --network lightning`);
+        expect(paymentResult.success).toBe(true);
+        expect(paymentResult.output.preimage).toBeDefined();
+    });
+});