@getalby/cli 0.7.0 → 0.9.0

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", [
@@ -55,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", [

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

@@ -10,7 +10,7 @@ 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
@@ -20,7 +20,7 @@ describe("NWC Payment Commands", () => {
     });
     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 "${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

@@ -1,5 +1,7 @@
 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`);
@@ -16,44 +18,82 @@ describe("pay command — destination detection", () => {
         expect(result.output.error).toContain("--amount");
     });
     test("keysend pubkey without --amount is rejected before wallet load", () => {
-        const pubkey = "02" + "a".repeat(64);
         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 0x000000000000000000000000000000000000dead`);
+        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 0x000000000000000000000000000000000000dead --amount 10 --network arbitrum`);
+        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 0x000000000000000000000000000000000000dead --amount 10 --currency USDC`);
+        const result = runCli(`pay ${evm} --amount 10 --currency USDC`);
         expect(result.success).toBe(false);
         expect(result.output.error).toContain("--network");
     });
-    test("--currency on a BOLT-11 invoice is rejected as not applicable", () => {
+    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("not applicable to invoice payment");
+        expect(result.output.error).toContain("zero-amount invoice");
     });
     test("testnet/signet invoice prefixes (lntb...) are recognized as invoices", () => {
-        // Same path as the lnbc test above — exercises that lntb is treated as
-        // an invoice (not falling through to the unknown-destination error).
         const result = runCli(`pay lntb1junk --currency USDT`);
         expect(result.success).toBe(false);
-        expect(result.output.error).toContain("not applicable to invoice payment");
+        expect(result.output.error).toContain("zero-amount invoice");
     });
     test("--comment on a keysend pubkey is rejected as not applicable", () => {
-        const pubkey = "02" + "a".repeat(64);
-        const result = runCli(`pay ${pubkey} --amount 100 --comment hi`);
+        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;
@@ -63,21 +103,28 @@ describe("pay command — live integration", () => {
         receiver = await createTestWallet();
     }, 60000);
     test("pay <bolt11> pays an invoice end-to-end", () => {
-        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);
         const paymentResult = runCli(`-c "${sender.nwcUrl}" pay "${invoiceResult.output.invoice}"`);
         expect(paymentResult.success).toBe(true);
         expect(paymentResult.output.preimage).toBeDefined();
     });
-    test("pay <lightning-address> --amount fetches an invoice and pays it", () => {
-        const paymentResult = runCli(`-c "${sender.nwcUrl}" pay ${receiver.lightningAddress} --amount 100`);
+    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> --amount sends a keysend payment", () => {
+    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`);
+        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();
     });

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

@@ -129,17 +129,24 @@ describe("pay-crypto validation", () => {
         test("--amount 0 is rejected", async () => {
             const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 0 --currency USDC --network arbitrum");
             expect(result.success).toBe(false);
-            expect(result.output.error).toContain("Invalid --amount");
+            expect(result.output.error).toContain("Amount must be a positive number");
         });
         test("--amount -1 is rejected", async () => {
             const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount -1 --currency USDC --network arbitrum");
             expect(result.success).toBe(false);
-            expect(result.output.error).toContain("Invalid --amount");
+            expect(result.output.error).toContain("Amount must be a positive number");
         });
         test("--amount abc (NaN) is rejected", async () => {
             const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount abc --currency USDC --network arbitrum");
             expect(result.success).toBe(false);
-            expect(result.output.error).toContain("Invalid --amount");
+            expect(result.output.error).toContain("Amount must be a positive number");
+        });
+        // Unit-suffixed input must not be truncated to its leading digits
+        // (Number("123usd") is NaN, unlike parseFloat which would yield 123).
+        test("--amount 123usd is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 123usd --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Amount must be a positive number");
         });
     });
     describe("missing required options", () => {

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

@@ -6,15 +6,40 @@ describe("receive command — validation", () => {
         expect(result.success).toBe(false);
         expect(result.output.error).toContain("--description requires --amount");
     });
-    test("--amount 0 is rejected", () => {
+    test("--currency without --amount is rejected", () => {
+        const result = runCli(`receive --currency USD`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency requires --amount");
+    });
+    test("--amount 0 is rejected at parse time", () => {
         const result = runCli(`receive --amount 0`);
         expect(result.success).toBe(false);
-        expect(result.output.error).toContain("Invalid --amount");
+        expect(result.output.error).toContain("Amount must be a positive number");
     });
-    test("--amount abc (NaN) is rejected", () => {
+    test("--amount abc (NaN) is rejected at parse time", () => {
         const result = runCli(`receive --amount abc`);
         expect(result.success).toBe(false);
-        expect(result.output.error).toContain("Invalid --amount");
+        expect(result.output.error).toContain("Amount must be a positive number");
+    });
+    test("--amount without --currency is rejected", () => {
+        const result = runCli(`receive --amount 100 --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency");
+    });
+    test("--amount --currency BTC without --unit is rejected", () => {
+        const result = runCli(`receive --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(`receive --amount 5 --currency USD --unit sats --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit is not valid");
+    });
+    test("a chain network is rejected (invoices are lightning-only)", () => {
+        const result = runCli(`receive --amount 10 --currency USDC --network arbitrum`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("lightning");
     });
 });
 describe("receive command — live integration", () => {
@@ -27,14 +52,26 @@ describe("receive command — live integration", () => {
         expect(result.success).toBe(true);
         expect(result.output.lightning_address).toBe(wallet.lightningAddress);
     });
-    test("receive --amount returns a BOLT-11 invoice", () => {
-        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 100`);
+    test("receive --amount --currency BTC --unit sats returns a BOLT-11 invoice", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 100 --currency BTC --unit sats --network lightning`);
         expect(result.success).toBe(true);
         expect(result.output.invoice).toMatch(/^lnbc/i);
         expect(result.output.amount_in_sats).toBe(100);
     });
+    test("receive --unit BTC converts to sats", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 0.000001 --currency BTC --unit BTC --network lightning`);
+        expect(result.success).toBe(true);
+        expect(result.output.amount_in_sats).toBe(100);
+    });
+    test("receive --amount --currency USD resolves fiat to sats", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 5 --currency USD --network lightning`);
+        expect(result.success).toBe(true);
+        expect(result.output.invoice).toMatch(/^lnbc/i);
+        expect(result.output.amount_in_sats).toBeGreaterThan(0);
+        expect(result.output.fiat).toEqual({ amount: 5, currency: "USD" });
+    });
     test("receive --amount --description produces an invoice", () => {
-        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 100 --description "test"`);
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 100 --currency BTC --unit sats --network lightning --description "test"`);
         expect(result.success).toBe(true);
         expect(result.output.invoice).toMatch(/^lnbc/i);
         expect(result.output.amount_in_sats).toBe(100);

package/build/tools/lightning/discover.js

@@ -9,7 +9,7 @@ export async function discover(params) {
         url.searchParams.set("health", params.health);
     if (params.sort)
         url.searchParams.set("sort", params.sort);
-    // Filter to BTC (Lightning) services server-side
+    // Filter to BTC (lightning) services server-side
     url.searchParams.set("payment_asset", "BTC");
     url.searchParams.set("limit", String(requestedLimit));
     const controller = new AbortController();

package/build/tools/lightning/fetch.js

@@ -1,4 +1,4 @@
-import { fetch402 as fetch402Lib } from "@getalby/lightning-tools/402";
+import { fetch402 as fetch402Lib, } from "@getalby/lightning-tools/402";
 const DEFAULT_MAX_AMOUNT_SATS = 5000;
 export async function fetch402(client, params) {
     const method = params.method?.toUpperCase();
@@ -7,10 +7,15 @@ export async function fetch402(client, params) {
     };
     if (method && method !== "GET" && method !== "HEAD") {
         requestOptions.body = params.body;
-        requestOptions.headers = {
-            "Content-Type": "application/json",
-            ...params.headers,
-        };
+        // A body is always passed as JSON, so default the Content-Type. The agent
+        // isn't required to set the header itself but might do so anyway, so only
+        // add our default when it's absent to avoid a duplicate Content-Type.
+        const headers = { ...params.headers };
+        const hasContentType = Object.keys(headers).some((key) => key.toLowerCase() === "content-type");
+        if (!hasContentType) {
+            headers["Content-Type"] = "application/json";
+        }
+        requestOptions.headers = headers;
     }
     else if (params.headers) {
         requestOptions.headers = params.headers;
@@ -18,7 +23,8 @@ export async function fetch402(client, params) {
     const maxAmountSats = params.maxAmountSats ?? DEFAULT_MAX_AMOUNT_SATS;
     const result = await fetch402Lib(params.url, requestOptions, {
         wallet: client,
-        maxAmount: maxAmountSats || undefined,
+        maxAmount: maxAmountSats,
+        credentials: params.credentials,
     });
     const responseContent = await result.text();
     if (!result.ok) {
@@ -26,5 +32,11 @@ export async function fetch402(client, params) {
     }
     return {
         content: responseContent,
+        // Payment metadata attached by the 402 helper: whether a payment was made,
+        // the amount, routing fees (feesPaid, in millisatoshis), and the reusable
+        // credential. Pass `credentials` back via --credentials on a follow-up
+        // request to authorize it without paying again. Absent when no 402 payment
+        // was involved (e.g. an already-open resource).
+        payment: result.payment,
     };
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@getalby/cli",
   "description": "CLI for Nostr Wallet Connect (NIP-47) with a few additional useful lightning tools",
   "repository": "https://github.com/getAlby/cli.git",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "main": "build/index.js",
   "bin": {
@@ -36,9 +36,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@getalby/lightning-tools": "^8.1.1",
-    "@getalby/sdk": "^8.0.1",
-    "@lendasat/lendaswap-sdk-pure": "^0.2.36",
+    "@getalby/lightning-tools": "^8.2.0",
+    "@getalby/sdk": "^8.0.3",
+    "@lendasat/lendaswap-sdk-pure": "^0.2.38",
     "@noble/hashes": "^2.0.1",
     "commander": "^14.0.3",
     "nostr-tools": "^2.23.3"