@getalby/cli 0.6.1 → 0.7.0

package/README.md

@@ -40,7 +40,13 @@ Then pass `--wallet-name` to any command to use that wallet:
 
 ```bash
 npx @getalby/cli --wallet-name work get-balance
-npx @getalby/cli --wallet-name personal pay-invoice --invoice lnbc...
+npx @getalby/cli --wallet-name personal pay lnbc...
+```
+
+List the wallets you've configured (names and connection status only, never the secrets):
+
+```bash
+npx @getalby/cli list-wallets
 ```
 
 ### Connection secret resolution (in order of priority)
@@ -104,11 +110,25 @@ npx @getalby/cli get-wallet-service-info
 # Create an invoice
 npx @getalby/cli make-invoice --amount 1000 --description "Payment"
 
-# Pay an invoice
-npx @getalby/cli pay-invoice --invoice "lnbc..."
-
-# Send a keysend payment
-npx @getalby/cli pay-keysend --pubkey "02abc..." --amount 100
+# Get paid — returns the wallet's lightning address, or a BOLT-11 invoice if --amount is given.
+#   - With no args: returns the wallet's lightning address (errors if the wallet has none)
+npx @getalby/cli receive
+#   - With --amount: returns a BOLT-11 invoice for that amount; --description is optional
+npx @getalby/cli receive --amount 100 --description "coffee"
+
+# Pay any supported destination — auto-detects type from the destination string.
+# Required args depend on the destination type:
+#   - BOLT-11 invoice (lnbc...): no extra args (use --amount only for zero-amount invoices)
+npx @getalby/cli pay "lnbc..."
+#   - Lightning address (user@domain): requires --amount (sats); optional --comment
+npx @getalby/cli pay alice@getalby.com --amount 100 --comment "hi"
+#   - Node pubkey (66-char hex, compressed secp256k1): keysend, requires --amount (sats)
+npx @getalby/cli pay 02abc... --amount 100
+#   - EVM address (0x...): pay crypto/stablecoin, requires --amount, --currency, and --network
+npx @getalby/cli pay 0xabc... --amount 10 --currency USDC --network arbitrum
+
+# The dedicated `pay-invoice`, `pay-keysend`, and `pay-crypto` commands are
+# still available if you want to constrain the destination type explicitly.
 
 # Look up an invoice by payment hash
 npx @getalby/cli lookup-invoice --payment-hash "abc123..."

package/build/commands/auth.js

@@ -1,8 +1,6 @@
 import { NWCClient } from "@getalby/sdk";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { getConnectionSecretPath, getPendingConnectionRelayPath, getPendingConnectionSecretPath, handleError, } from "../utils.js";
+import { getAlbyCliDir, DEFAULT_RELAY_URLS, getConnectionSecretPath, getPendingConnectionRelayPath, getPendingConnectionSecretPath, handleError, } from "../utils.js";
 import { generateSecretKey, getPublicKey } from "nostr-tools";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
 export function registerAuthCommand(program) {
@@ -12,7 +10,7 @@ export function registerAuthCommand(program) {
         "  Step 1: npx @getalby/cli auth https://my.albyhub.com --app-name MyApp\n" +
         "  Step 2: after human confirmation, run any command to finalize the connection")
         .option("--app-name <name>", 'Name of the agent or app that will use this wallet (e.g. "Claude Code")')
-        .option("--relay-url <url>", "Relay URL for the pending connection", "wss://relay.getalby.com/v1")
+        .option("--relay-url <url>", `Relay URL for the pending connection (repeat to use multiple relays, default: ${DEFAULT_RELAY_URLS.join(", ")})`, (value, previous) => previous.concat([value]), [])
         .option("--force", "Overwrite existing connection secret")
         .option("--remove-pending", "Remove a pending connection and start fresh")
         .action(async (walletUrl, options) => {
@@ -43,18 +41,24 @@ export function registerAuthCommand(program) {
             }
             if (existsSync(connectionSecretPath) && !options.force) {
                 console.error(`Error: Already connected. Connection secret exists at ${connectionSecretPath}\n` +
-                    `To overwrite, use --force.`);
+                    `To overwrite, use --force.\n` +
+                    `To connect an additional wallet, use --wallet-name <name>.`);
                 process.exit(1);
             }
+            const relayUrls = options.relayUrl.length > 0 ? options.relayUrl : DEFAULT_RELAY_URLS;
             const secret = bytesToHex(generateSecretKey());
             const pubkey = getPublicKey(hexToBytes(secret));
             const authUrl = NWCClient.getAuthorizationUrl(`${walletUrl}/apps/new`, { name: options.appName }, pubkey).toString();
-            const dir = join(homedir(), ".alby-cli");
+            const dir = getAlbyCliDir();
             if (!existsSync(dir)) {
                 mkdirSync(dir, { recursive: true });
             }
             writeFileSync(pendingSecretPath, secret, { mode: 0o600 });
-            writeFileSync(pendingRelayPath, options.relayUrl, { mode: 0o600 });
+            // Store one relay per line so multiple relays survive the
+            // round-trip to the completion step.
+            writeFileSync(pendingRelayPath, relayUrls.join("\n"), {
+                mode: 0o600,
+            });
             console.log("Click the following URL to approve the connection in your wallet:\n" +
                 authUrl);
             const retryCmd = walletName

package/build/commands/connect.js

@@ -11,7 +11,8 @@ export function registerConnectCommand(program) {
             const connectionSecretPath = getConnectionSecretPath(program.opts().walletName);
             if (existsSync(connectionSecretPath) && !options.force) {
                 console.error(`Error: Already connected. Connection secret exists at ${connectionSecretPath}\n` +
-                    `To overwrite, use --force.`);
+                    `To overwrite, use --force.\n` +
+                    `To connect an additional wallet, use --wallet-name <name>.`);
                 process.exit(1);
             }
             if (!connectionSecret) {

package/build/commands/list-wallets.js

@@ -0,0 +1,12 @@
+import { getAlbyCliDir, handleError, listWallets, output } from "../utils.js";
+export function registerListWalletsCommand(program) {
+    program
+        .command("list-wallets")
+        .description("List configured wallets (names and connection status only, no secrets)")
+        .action(async () => {
+        await handleError(async () => {
+            const wallets = listWallets();
+            output({ directory: getAlbyCliDir(), wallets });
+        });
+    });
+}

package/build/commands/pay-crypto.js

@@ -0,0 +1,47 @@
+import { payInvoice } from "../tools/nwc/pay_invoice.js";
+import { getClient, handleError, output } from "../utils.js";
+import { isPlausibleEvmAddress, payCrypto, findSupportedPair, } from "../lendaswap/swap.js";
+export function registerPayCryptoCommand(program) {
+    program
+        .command("pay-crypto")
+        .description("Pay any supported crypto or stablecoin address from your bitcoin lightning wallet.\n\n" +
+        "If the requested currency/network pair isn't supported you'll get an error listing the pairs that are.")
+        .argument("<address>", "Recipient address on the target network")
+        .requiredOption("-a, --amount <number>", "Amount to send in target-currency units (e.g. 10 = 10 USDC)", Number)
+        .requiredOption("--currency <name>", "Target currency (e.g. USDC)")
+        .requiredOption("--network <name>", "Target network (chain name or id, e.g. arbitrum / 42161)")
+        .addHelpText("after", "\nExample:\n" +
+        "  $ npx @getalby/cli pay-crypto 0xabc... --amount 10 --currency USDC --network arbitrum\n")
+        .action(async (address, options) => {
+        await handleError(async () => {
+            if (!Number.isFinite(options.amount) || options.amount <= 0) {
+                throw new Error(`Invalid --amount: ${options.amount}`);
+            }
+            if (!isPlausibleEvmAddress(address)) {
+                throw new Error(`Recipient address does not look valid (expected 0x + 40 hex chars): ${address}`);
+            }
+            // Validate the pair against the live Lendaswap catalog before
+            // asking the user for their wallet — fast feedback on typos.
+            const pair = await findSupportedPair(options.currency, options.network);
+            const nwc = await getClient(program);
+            const { swapId } = await payCrypto({
+                pair,
+                amount: options.amount,
+                targetAddress: address,
+                payInvoice: async (bolt11Invoice) => {
+                    await payInvoice(nwc, { invoice: bolt11Invoice });
+                },
+            });
+            output({
+                swap_id: swapId,
+                status: "completed",
+                target: {
+                    address,
+                    currency: pair.symbol,
+                    network: pair.network,
+                    amount: options.amount,
+                },
+            });
+        });
+    });
+}

package/build/commands/pay-invoice.js

@@ -4,13 +4,13 @@ export function registerPayInvoiceCommand(program) {
     program
         .command("pay-invoice")
         .description("Pay a lightning invoice")
-        .requiredOption("-i, --invoice <bolt11>", "Invoice to pay")
+        .argument("<bolt11>", "Invoice to pay")
         .option("-a, --amount <sats>", "Amount (for zero-amount invoices)", parseInt)
-        .action(async (options) => {
+        .action(async (invoice, options) => {
         await handleError(async () => {
             const client = await getClient(program);
             const result = await payInvoice(client, {
-                invoice: options.invoice,
+                invoice,
                 amount_in_sats: options.amount,
             });
             output(result);

package/build/commands/pay.js

@@ -0,0 +1,188 @@
+import { LN_ADDRESS_REGEX } from "@getalby/lightning-tools";
+import { payInvoice } from "../tools/nwc/pay_invoice.js";
+import { payKeysend } from "../tools/nwc/pay_keysend.js";
+import { requestInvoiceFromLightningAddress } from "../tools/lightning/request_invoice_from_lightning_address.js";
+import { isPlausibleEvmAddress, payCrypto, findSupportedPair, } from "../lendaswap/swap.js";
+import { getClient, handleError, output } from "../utils.js";
+function detectDestinationType(destination) {
+    if (/^0x[0-9a-fA-F]{40}$/.test(destination))
+        return "crypto";
+    // BOLT-11 prefixes: lnbc = mainnet, lntb = testnet/signet, lnbcrt = regtest, lntbs = signet (e.g. mutinynet).
+    if (/^ln(bcrt|tbs|bc|tb)/i.test(destination))
+        return "invoice";
+    if (LN_ADDRESS_REGEX.test(destination))
+        return "lightning-address";
+    if (/^0[23][0-9a-fA-F]{64}$/.test(destination))
+        return "keysend";
+    return null;
+}
+const ALLOWED_OPTS = {
+    invoice: ["amount"],
+    "lightning-address": ["amount", "comment"],
+    keysend: ["amount", "preimage", "tlvRecords"],
+    crypto: ["amount", "currency", "network"],
+};
+const OPT_FLAG = {
+    amount: "--amount",
+    comment: "--comment",
+    preimage: "--preimage",
+    tlvRecords: "--tlv-records",
+    currency: "--currency",
+    network: "--network",
+};
+function rejectUnusedOpts(type, options, providedKeys) {
+    const allowed = new Set(ALLOWED_OPTS[type]);
+    const used = Object.keys(options).filter((k) => providedKeys.has(k));
+    const stray = used.filter((k) => !allowed.has(k));
+    if (stray.length > 0) {
+        throw new Error(`Option${stray.length > 1 ? "s" : ""} ${stray.map((k) => OPT_FLAG[k] ?? `--${k}`).join(", ")} not applicable to ${type} payment`);
+    }
+}
+export function registerPayCommand(program) {
+    program
+        .command("pay")
+        .description("Pay any supported destination — auto-detects type from the destination string.\n\n" +
+        "Supported destinations:\n" +
+        "  - BOLT-11 invoice (lnbc... / lntb... / lnbcrt... / lntbs...): no extra args (use --amount only for zero-amount invoices)\n" +
+        "  - Lightning address (user@domain): requires --amount (sats); optional --comment\n" +
+        "  - Node pubkey (66-char hex, compressed secp256k1): keysend, requires --amount (sats)\n" +
+        "  - EVM address (0x...): pay crypto/stablecoin, requires --amount, --currency, and --network")
+        .argument("<destination>", "Invoice, lightning address, node pubkey, or EVM address")
+        .option("-a, --amount <number>", "Amount — sats for lightning destinations, target-currency units for crypto (e.g. 10 = 10 USDC)", Number)
+        .option("--comment <text>", "Comment for lightning address payments")
+        .option("--preimage <hex>", "Preimage for keysend (optional, generated if omitted)")
+        .option("--tlv-records <json>", "TLV records for keysend, as JSON array [{type, value}]")
+        .option("--currency <name>", "Target currency for crypto payments (required for EVM destinations)")
+        .option("--network <name>", "Target network for crypto payments — chain name or id (required for EVM destinations)")
+        .addHelpText("after", "\nExamples:\n" +
+        "  $ npx @getalby/cli pay lnbc1...\n" +
+        "  $ npx @getalby/cli pay alice@getalby.com --amount 100 --comment hi\n" +
+        "  $ npx @getalby/cli pay 02aabb... --amount 100\n" +
+        "  $ npx @getalby/cli pay 0xabc... --amount 10 --currency USDC --network arbitrum\n")
+        .action(async (destination, options, cmd) => {
+        await handleError(async () => {
+            const type = detectDestinationType(destination);
+            if (!type) {
+                throw new Error(`Could not detect destination type for: ${destination}\n` +
+                    "Expected one of:\n" +
+                    "  - BOLT-11 invoice (starts with lnbc, lntb, lnbcrt, or lntbs)\n" +
+                    "  - Lightning address (user@domain)\n" +
+                    "  - Node pubkey for keysend (66-char hex, compressed secp256k1: starts with 02/03)\n" +
+                    "  - EVM address (0x + 40 hex characters)");
+            }
+            // Track which options the user *explicitly* set (vs. defaults from
+            // commander) so we only reject stray flags the user actually typed.
+            const providedKeys = new Set();
+            for (const opt of cmd.options) {
+                const key = opt.attributeName();
+                const src = cmd.getOptionValueSource(key);
+                if (src === "cli" || src === "env") {
+                    providedKeys.add(key);
+                }
+            }
+            rejectUnusedOpts(type, options, providedKeys);
+            switch (type) {
+                case "invoice": {
+                    if (options.amount !== undefined &&
+                        !Number.isInteger(options.amount)) {
+                        throw new Error(`Invalid --amount: must be an integer number of sats`);
+                    }
+                    const client = await getClient(program);
+                    const result = await payInvoice(client, {
+                        invoice: destination,
+                        amount_in_sats: options.amount,
+                        metadata: {},
+                    });
+                    output(result);
+                    return;
+                }
+                case "lightning-address": {
+                    if (options.amount === undefined) {
+                        throw new Error("Lightning address payments require --amount <sats>");
+                    }
+                    if (!Number.isInteger(options.amount) || options.amount <= 0) {
+                        throw new Error(`Invalid --amount: must be a positive integer number of sats`);
+                    }
+                    const invoice = await requestInvoiceFromLightningAddress({
+                        lightning_address: destination,
+                        amount_in_sats: options.amount,
+                        comment: options.comment,
+                    });
+                    const client = await getClient(program);
+                    // Stash identifier + comment on the payment record so the wallet
+                    // can show who was paid even when the LNURL server drops them
+                    // from the invoice memo.
+                    const metadata = {
+                        ...(options.comment && { comment: options.comment }),
+                        recipient_data: { identifier: destination },
+                    };
+                    const result = await payInvoice(client, {
+                        invoice: invoice.paymentRequest,
+                        metadata,
+                    });
+                    output(result);
+                    return;
+                }
+                case "keysend": {
+                    if (options.amount === undefined) {
+                        throw new Error("Keysend payments require --amount <sats>");
+                    }
+                    if (!Number.isInteger(options.amount) || options.amount <= 0) {
+                        throw new Error(`Invalid --amount: must be a positive integer number of sats`);
+                    }
+                    let tlvRecords;
+                    if (options.tlvRecords) {
+                        tlvRecords = JSON.parse(options.tlvRecords);
+                    }
+                    const client = await getClient(program);
+                    const result = await payKeysend(client, {
+                        pubkey: destination,
+                        amount_in_sats: options.amount,
+                        preimage: options.preimage,
+                        tlv_records: tlvRecords,
+                    });
+                    output(result);
+                    return;
+                }
+                case "crypto": {
+                    if (options.amount === undefined) {
+                        throw new Error("Crypto payments require --amount <number>");
+                    }
+                    if (!Number.isFinite(options.amount) || options.amount <= 0) {
+                        throw new Error(`Invalid --amount: ${options.amount}`);
+                    }
+                    if (!options.currency) {
+                        throw new Error("Crypto payments require --currency <name>");
+                    }
+                    if (!options.network) {
+                        throw new Error("Crypto payments require --network <chain-name-or-id>");
+                    }
+                    if (!isPlausibleEvmAddress(destination)) {
+                        throw new Error(`Recipient address does not look valid (expected 0x + 40 hex chars): ${destination}`);
+                    }
+                    const pair = await findSupportedPair(options.currency, options.network);
+                    const nwc = await getClient(program);
+                    const { swapId } = await payCrypto({
+                        pair,
+                        amount: options.amount,
+                        targetAddress: destination,
+                        payInvoice: async (bolt11Invoice) => {
+                            await payInvoice(nwc, { invoice: bolt11Invoice });
+                        },
+                    });
+                    output({
+                        swap_id: swapId,
+                        status: "completed",
+                        target: {
+                            address: destination,
+                            currency: pair.symbol,
+                            network: pair.network,
+                            amount: options.amount,
+                        },
+                    });
+                    return;
+                }
+            }
+        });
+    });
+}

package/build/commands/receive.js

@@ -0,0 +1,40 @@
+import { makeInvoice } from "../tools/nwc/make_invoice.js";
+import { getClient, handleError, output } from "../utils.js";
+export function registerReceiveCommand(program) {
+    program
+        .command("receive")
+        .description("Get paid — returns either the wallet's lightning address or a BOLT-11 invoice.\n\n" +
+        "  - receive                    → returns the wallet's lightning address (if available)\n" +
+        "  - receive --amount <sats>    → returns a BOLT-11 invoice for the given amount")
+        .option("-a, --amount <sats>", "Invoice amount in sats", parseInt)
+        .option("-d, --description <text>", "Invoice description (requires --amount)")
+        .addHelpText("after", "\nExamples:\n" +
+        "  $ npx @getalby/cli receive\n" +
+        '  $ npx @getalby/cli receive --amount 2100 --description "coffee"\n')
+        .action(async (options) => {
+        await handleError(async () => {
+            if (options.amount === undefined) {
+                if (options.description !== undefined) {
+                    throw new Error("--description requires --amount");
+                }
+                const client = await getClient(program);
+                if (!client.lud16) {
+                    throw new Error("This wallet does not expose a lightning address. " +
+                        "Either pass --amount <sats> to generate a BOLT-11 invoice, " +
+                        "or connect a wallet that has a lightning address.");
+                }
+                output({ lightning_address: client.lud16 });
+                return;
+            }
+            if (!Number.isInteger(options.amount) || options.amount <= 0) {
+                throw new Error("Invalid --amount: must be a positive integer number of sats");
+            }
+            const client = await getClient(program);
+            const result = await makeInvoice(client, {
+                amount_in_sats: options.amount,
+                description: options.description,
+            });
+            output(result);
+        });
+    });
+}

package/build/index.js

@@ -8,6 +8,8 @@ import { registerMakeInvoiceCommand } from "./commands/make-invoice.js";
 import { registerMakeHoldInvoiceCommand } from "./commands/make-hold-invoice.js";
 import { registerSettleHoldInvoiceCommand } from "./commands/settle-hold-invoice.js";
 import { registerCancelHoldInvoiceCommand } from "./commands/cancel-hold-invoice.js";
+import { registerPayCommand } from "./commands/pay.js";
+import { registerReceiveCommand } from "./commands/receive.js";
 import { registerPayInvoiceCommand } from "./commands/pay-invoice.js";
 import { registerPayKeysendCommand } from "./commands/pay-keysend.js";
 import { registerLookupInvoiceCommand } from "./commands/lookup-invoice.js";
@@ -20,8 +22,10 @@ import { registerParseInvoiceCommand } from "./commands/parse-invoice.js";
 import { registerVerifyPreimageCommand } from "./commands/verify-preimage.js";
 import { registerRequestInvoiceFromLightningAddressCommand } from "./commands/request-invoice-from-lightning-address.js";
 import { registerFetch402Command } from "./commands/fetch.js";
+import { registerPayCryptoCommand } from "./commands/pay-crypto.js";
 import { registerConnectCommand } from "./commands/connect.js";
 import { registerAuthCommand } from "./commands/auth.js";
+import { registerListWalletsCommand } from "./commands/list-wallets.js";
 import { registerDiscoverCommand } from "./commands/discover.js";
 const program = new Command();
 program
@@ -32,8 +36,11 @@ program
     "    $ npx @getalby/cli auth https://my.albyhub.com --app-name OpenClaw\n" +
     '    $ npx @getalby/cli connect "nostr+walletconnect://..."\n' +
     "    $ npx @getalby/cli get-balance\n" +
-    "    $ npx @getalby/cli pay-invoice --invoice lnbc...")
-    .version("0.6.1")
+    "    $ npx @getalby/cli pay lnbc...\n" +
+    "    $ npx @getalby/cli pay alice@getalby.com --amount 100\n" +
+    '    $ npx @getalby/cli receive --amount 2100 --description "Coffee"')
+    .version("0.7.0")
+    .configureHelp({ showGlobalOptions: true })
     .option("-w, --wallet-name <name>", "Use a named wallet's connection secret (~/.alby-cli/connection-secret-<name>.key)")
     .option("-c, --connection-secret <string>", "NWC connection secret (nostr+walletconnect://...) or path to file containing it (preferred)")
     .option("-v, --verbose", "Print status messages to stderr")
@@ -52,6 +59,8 @@ Security:
     as this can be used to gain access to your wallet or reduce your wallet's privacy.`);
 // Register common wallet commands
 program.commandsGroup("Wallet Commands (requires wallet connection):");
+registerPayCommand(program);
+registerReceiveCommand(program);
 registerGetBalanceCommand(program);
 registerGetBudgetCommand(program);
 registerGetInfoCommand(program);
@@ -78,6 +87,9 @@ registerRequestInvoiceFromLightningAddressCommand(program);
 // Register fetch command for payment-protected resources
 program.commandsGroup("HTTP 402 Payments (requires wallet connection):");
 registerFetch402Command(program);
+// Register cross-currency payments (Lightning → EVM via atomic swap)
+program.commandsGroup("Cross-Currency Payments (requires wallet connection):");
+registerPayCryptoCommand(program);
 // Register service discovery
 program.commandsGroup("Service Discovery:");
 registerDiscoverCommand(program);
@@ -85,4 +97,5 @@ registerDiscoverCommand(program);
 program.commandsGroup("Setup:");
 registerAuthCommand(program);
 registerConnectCommand(program);
+registerListWalletsCommand(program);
 program.parse();

package/build/lendaswap/swap.js

@@ -0,0 +1,177 @@
+import { Asset, Client, InMemorySwapStorage, InMemoryWalletStorage, toChain, toChainName, } from "@lendasat/lendaswap-sdk-pure";
+// Allow tests (or local dev against staging) to override the API endpoint.
+const API_BASE_URL = process.env.LENDASWAP_API_URL || "https://api.satora.io";
+// Terminal statuses where the swap is irrecoverably done. Mirrors the same
+// constants used by the bitcoin-card-topup reference frontend.
+const SUCCESS_STATUSES = ["clientredeemed", "serverredeemed"];
+const FAILURE_STATUSES = [
+    "expired",
+    "clientrefunded",
+    "clientrefundedserverrefunded",
+    "clientrefundedserverfunded",
+    "clientinvalidfunded",
+    "clientfundedtoolate",
+    "serverwontfund",
+];
+let clientPromise = null;
+function getClient() {
+    if (!clientPromise) {
+        // In-memory storage: a single CLI invocation waits synchronously for a
+        // terminal swap status, so there's nothing to recover across runs. If the
+        // process is killed mid-swap, the HTLC refund timer is the safety net.
+        clientPromise = Client.builder()
+            .withBaseUrl(API_BASE_URL)
+            .withSignerStorage(new InMemoryWalletStorage())
+            .withSwapStorage(new InMemorySwapStorage())
+            .build();
+    }
+    return clientPromise;
+}
+let supportedPairsPromise = null;
+/**
+ * Fetch all (currency, network) pairs that can be the target of a
+ * Lightning → EVM swap. The list comes straight from the Lendaswap API:
+ * `getTokens()` for the token universe, intersected with `getSwapPairs()`
+ * filtered to source = Lightning.
+ */
+export function getSupportedPairs() {
+    if (!supportedPairsPromise) {
+        supportedPairsPromise = (async () => {
+            const client = await getClient();
+            const [tokens, swapPairs] = await Promise.all([
+                client.getTokens(),
+                client.getSwapPairs(),
+            ]);
+            const lightningTargetChains = new Set(swapPairs.pairs
+                .filter((p) => p.source === "Lightning")
+                .map((p) => p.target));
+            return tokens.evm_tokens
+                .filter((t) => lightningTargetChains.has(t.chain))
+                .map((t) => ({
+                symbol: t.symbol,
+                network: toChainName(t.chain),
+                decimals: t.decimals,
+                chain: t.chain,
+                tokenId: t.token_id,
+            }));
+        })();
+    }
+    return supportedPairsPromise;
+}
+function formatPairsList(pairs) {
+    return pairs.map((p) => `  - ${p.symbol} on ${p.network}`).join("\n");
+}
+/**
+ * Resolve a (currency, network) pair against the live API list, or throw
+ * with a human-readable error listing every supported pair. Network can be
+ * a chain name ("arbitrum") or chain id ("42161"); matching is case-insensitive.
+ */
+export async function findSupportedPair(currency, network) {
+    const pairs = await getSupportedPairs();
+    const symbol = currency.toUpperCase();
+    // toChain normalizes "arbitrum"/"42161"/"Arbitrum" to the canonical chain id.
+    const chain = toChain(network);
+    const pair = pairs.find((p) => p.symbol.toUpperCase() === symbol && p.chain === chain);
+    if (!pair) {
+        throw new Error(`Unsupported currency/network combination: ${currency} on ${network}.\n` +
+            `Supported:\n${formatPairsList(pairs)}`);
+    }
+    return pair;
+}
+/**
+ * EVM address shape check: every chain reachable from Lightning is EVM, so
+ * the universal `0x` + 40-hex format applies. Lendaswap does the
+ * authoritative validation when it builds the swap; this is just a sanity
+ * pre-check so an obvious typo fails fast before we lock funds.
+ */
+export function isPlausibleEvmAddress(address) {
+    return /^0x[0-9a-fA-F]{40}$/.test(address);
+}
+function toSmallestUnit(amount, decimals) {
+    return Math.round(amount * 10 ** decimals);
+}
+async function createPaymentSwap(params) {
+    const client = await getClient();
+    const targetAmount = toSmallestUnit(params.amount, params.pair.decimals);
+    const targetAsset = {
+        chain: params.pair.chain,
+        tokenId: params.pair.tokenId,
+    };
+    const result = await client.createSwap({
+        source: Asset.BTC_LIGHTNING,
+        target: targetAsset,
+        targetAmount,
+        targetAddress: params.targetAddress,
+        gasless: true,
+        referralCode: "lnds_2c07e38f10a28d47",
+    });
+    // Source is BTC_LIGHTNING and target is an EVM token, so the SDK routes
+    // through its Lightning→EVM path.
+    return result.response;
+}
+async function subscribeToSwap(swapId, onUpdate) {
+    const client = await getClient();
+    return client.subscribeToSwaps([swapId], onUpdate);
+}
+async function claimSwap(swapId) {
+    const client = await getClient();
+    return client.claim(swapId);
+}
+/**
+ * Run a Lightning → on-chain crypto payment swap and block until it reaches a
+ * terminal status. Throws on any failure status. All swap-provider specifics
+ * (Lendaswap SDK calls, status handling, claim-on-serverfunded) live here so
+ * that swapping out the provider is a self-contained change.
+ */
+export async function payCrypto(params) {
+    const swap = await createPaymentSwap({
+        pair: params.pair,
+        amount: params.amount,
+        targetAddress: params.targetAddress,
+    });
+    // Subscribe BEFORE paying so we don't miss the `serverfunded` event
+    // that triggers our claim. Unsubscribe in `finally` no matter what.
+    let unsubscribe;
+    try {
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                fn();
+            };
+            let claimStarted = false;
+            subscribeToSwap(swap.id, (_id, status) => {
+                if (status === "serverfunded" && !claimStarted) {
+                    claimStarted = true;
+                    claimSwap(swap.id).catch((err) => settle(() => reject(err instanceof Error ? err : new Error(String(err)))));
+                }
+                if (SUCCESS_STATUSES.includes(status)) {
+                    settle(resolve);
+                }
+                else if (FAILURE_STATUSES.includes(status)) {
+                    settle(() => reject(new Error(`Swap ${status}`)));
+                }
+            })
+                .then((unsub) => {
+                unsubscribe = unsub;
+                // If the swap already terminated before subscribe resolved,
+                // tear down immediately.
+                if (settled)
+                    unsub();
+            })
+                .catch((err) => settle(() => reject(err instanceof Error ? err : new Error(String(err)))));
+            // Pay the Lightning invoice. Failure here propagates as the
+            // overall swap failure; success doesn't resolve us — only a
+            // terminal swap status does.
+            params
+                .payInvoice(swap.bolt11_invoice)
+                .catch((err) => settle(() => reject(err instanceof Error ? err : new Error(String(err)))));
+        });
+    }
+    finally {
+        unsubscribe?.();
+    }
+    return { swapId: swap.id };
+}

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/lightning-tools.test.js

@@ -1,7 +1,7 @@
 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");

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

@@ -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
@@ -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

@@ -14,7 +14,7 @@ describe("NWC Payment Commands", () => {
         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();
     });
@@ -23,7 +23,7 @@ describe("NWC Payment Commands", () => {
         const invoiceResult = runCli(`-c "${receiver.nwcUrl}" make-invoice -a 50`);
         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}"`);

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

@@ -0,0 +1,84 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { createTestWallet, runCli } from "./helpers.js";
+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 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`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--amount");
+    });
+    test("EVM address without --currency is rejected", () => {
+        const result = runCli(`pay 0x000000000000000000000000000000000000dead --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`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--network");
+    });
+    test("--currency on a BOLT-11 invoice is rejected as not applicable", () => {
+        const result = runCli(`pay lnbc1junk --currency USDT`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("not applicable to invoice payment");
+    });
+    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");
+    });
+    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`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("not applicable to keysend payment");
+    });
+});
+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 -a 100`);
+        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`);
+        expect(paymentResult.success).toBe(true);
+        expect(paymentResult.output.preimage).toBeDefined();
+    });
+    test("pay <pubkey> --amount 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`);
+        expect(paymentResult.success).toBe(true);
+        expect(paymentResult.output.preimage).toBeDefined();
+    });
+});

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

@@ -0,0 +1,168 @@
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import { spawn } from "child_process";
+import { createServer } from "http";
+// Stand up a local HTTP mock for the Lendaswap API endpoints the CLI hits
+// during validation. The CLI spawns a fresh subprocess per test, so the
+// `LENDASWAP_API_URL` env var (consumed in src/lendaswap/swap.ts) points it
+// at this mock instead of api.satora.io. We only need `/tokens` and
+// `/swap-pairs` — pair validation runs before wallet load, so tests never
+// reach the swap-creation endpoints.
+//
+// IMPORTANT: we use async `spawn`, not the shared `execSync`-based runCli
+// helper. `execSync` blocks the event loop, which would prevent this
+// in-process mock from accepting the subprocess's TCP connection — fetch
+// would just time out.
+let server;
+let mockUrl = "";
+const MOCK_TOKENS = {
+    btc_tokens: [],
+    evm_tokens: [
+        {
+            chain: "42161",
+            decimals: 6,
+            name: "USD Coin",
+            symbol: "USDC",
+            token_id: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+        },
+        {
+            chain: "42161",
+            decimals: 6,
+            name: "Tether USD",
+            symbol: "USDT",
+            token_id: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+        },
+    ],
+};
+// Only the Lightning → 42161 (Arbitrum) pair is enabled in the mock. So
+// USDC/USDT on Arbitrum resolve; the same symbols on any other chain are
+// rejected as unsupported.
+const MOCK_SWAP_PAIRS = {
+    pairs: [
+        {
+            fee_percentage: 0.0025,
+            max_sats: 100_000_000,
+            min_sats: 1000,
+            source: "Lightning",
+            target: "42161",
+        },
+    ],
+};
+beforeAll(async () => {
+    server = createServer((req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        if (req.url === "/tokens") {
+            res.end(JSON.stringify(MOCK_TOKENS));
+        }
+        else if (req.url === "/swap-pairs") {
+            res.end(JSON.stringify(MOCK_SWAP_PAIRS));
+        }
+        else {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: "not found" }));
+        }
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    const addr = server.address();
+    mockUrl = `http://127.0.0.1:${addr.port}`;
+});
+afterAll(() => new Promise((resolve) => server.close(() => resolve())));
+function runCliAsync(args) {
+    return new Promise((resolve) => {
+        const child = spawn("node", ["build/index.js", ...args.split(" ")], {
+            env: {
+                ...process.env,
+                // Wallet load always fails — exposes the validation gates as the
+                // only thing that can succeed or fail before that point.
+                HOME: "/tmp/nonexistent-alby-cli-test-home",
+                NWC_URL: "",
+                LENDASWAP_API_URL: mockUrl,
+            },
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("close", (code) => {
+            const raw = code === 0 ? stdout : stderr || stdout || "{}";
+            try {
+                resolve({ success: code === 0, output: JSON.parse(raw) });
+            }
+            catch {
+                resolve({ success: code === 0, output: { error: raw } });
+            }
+        });
+    });
+}
+describe("pay-crypto validation", () => {
+    describe("unsupported currency/network combination", () => {
+        test("unknown currency is rejected and lists supported pairs", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency XYZ --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Unsupported currency/network combination");
+            expect(result.output.error).toContain("USDC on Arbitrum");
+        });
+        test("USDC on ethereum is rejected (chain not in swap-pairs)", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency USDC --network ethereum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Unsupported currency/network combination");
+            expect(result.output.error).toContain("USDC on Arbitrum");
+        });
+    });
+    describe("malformed EVM address", () => {
+        test("completely non-hex string is rejected", async () => {
+            const result = await runCliAsync("pay-crypto notanaddress --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("address does not look valid");
+        });
+        test("too-short hex with 0x prefix is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0xabc --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("address does not look valid");
+        });
+        test("40-char hex without 0x prefix is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 000000000000000000000000000000000000dead --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("address does not look valid");
+        });
+    });
+    describe("invalid amount", () => {
+        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");
+        });
+        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");
+        });
+        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");
+        });
+    });
+    describe("missing required options", () => {
+        test("missing --currency is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("--currency");
+        });
+        test("missing --network is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency USDC");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("--network");
+        });
+    });
+    describe("happy-path validation", () => {
+        test("valid USDC/arbitrum inputs get past validation and fail only at wallet load", async () => {
+            // The mocked supported list includes USDC on 42161 (Arbitrum), so
+            // findSupportedPair succeeds. With the wallet env disabled, the only
+            // error left is "No wallet connection found" from getClient() —
+            // proof that amount, address, and pair gates all accepted the input.
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("No wallet connection found");
+        });
+    });
+});

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

@@ -0,0 +1,42 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { createTestWallet, runCli } from "./helpers.js";
+describe("receive command — validation", () => {
+    test("--description without --amount is rejected", () => {
+        const result = runCli(`receive --description "hi"`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--description requires --amount");
+    });
+    test("--amount 0 is rejected", () => {
+        const result = runCli(`receive --amount 0`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Invalid --amount");
+    });
+    test("--amount abc (NaN) is rejected", () => {
+        const result = runCli(`receive --amount abc`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Invalid --amount");
+    });
+});
+describe("receive command — live integration", () => {
+    let wallet;
+    beforeAll(async () => {
+        wallet = await createTestWallet();
+    }, 60000);
+    test("receive (no amount) returns the wallet's lightning address", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive`);
+        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`);
+        expect(result.success).toBe(true);
+        expect(result.output.invoice).toMatch(/^lnbc/i);
+        expect(result.output.amount_in_sats).toBe(100);
+    });
+    test("receive --amount --description produces an invoice", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 100 --description "test"`);
+        expect(result.success).toBe(true);
+        expect(result.output.invoice).toMatch(/^lnbc/i);
+        expect(result.output.amount_in_sats).toBe(100);
+    });
+});

package/build/utils.js

@@ -1,8 +1,15 @@
 import { NWAClient, NWCClient } from "@getalby/sdk";
 import { getInfo } from "./tools/nwc/get_info.js";
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+export const DEFAULT_RELAY_URLS = [
+    "wss://relay.getalby.com",
+    "wss://relay2.getalby.com",
+];
+export function getAlbyCliDir() {
+    return join(homedir(), ".alby-cli");
+}
 function sanitizeWalletName(name) {
     return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
@@ -10,23 +17,70 @@ export function getConnectionSecretPath(name) {
     const filename = name
         ? `connection-secret-${sanitizeWalletName(name)}.key`
         : "connection-secret.key";
-    return join(homedir(), ".alby-cli", filename);
+    return join(getAlbyCliDir(), filename);
 }
 export function getPendingConnectionSecretPath(name) {
     const filename = name
         ? `pending-connection-secret-${sanitizeWalletName(name)}.key`
         : "pending-connection-secret.key";
-    return join(homedir(), ".alby-cli", filename);
+    return join(getAlbyCliDir(), filename);
 }
 export function getPendingConnectionRelayPath(name) {
     const filename = name
         ? `pending-connection-relay-${sanitizeWalletName(name)}.txt`
         : "pending-connection-relay.txt";
-    return join(homedir(), ".alby-cli", filename);
+    return join(getAlbyCliDir(), filename);
+}
+/**
+ * List configured wallets by scanning ~/.alby-cli for connection secret files.
+ * Never reads or returns secret contents - only wallet names and status.
+ */
+export function listWallets() {
+    const dir = getAlbyCliDir();
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    // Map of wallet name (null for default) -> status. Connected takes precedence
+    // over pending so a re-authed wallet still shows as usable.
+    const wallets = new Map();
+    const patterns = [
+        { regex: /^connection-secret(?:-(.+))?\.key$/, status: "connected" },
+        { regex: /^pending-connection-secret(?:-(.+))?\.key$/, status: "pending" },
+    ];
+    for (const file of files) {
+        for (const { regex, status } of patterns) {
+            const match = file.match(regex);
+            if (!match)
+                continue;
+            const name = match[1] ?? null;
+            if (status === "connected" || !wallets.has(name)) {
+                wallets.set(name, wallets.get(name) === "connected" ? "connected" : status);
+            }
+            break;
+        }
+    }
+    return [...wallets.entries()]
+        .map(([name, status]) => ({
+        name,
+        isDefault: name === null,
+        status,
+    }))
+        .sort((a, b) => {
+        if (a.isDefault !== b.isDefault)
+            return a.isDefault ? -1 : 1;
+        return (a.name ?? "").localeCompare(b.name ?? "");
+    });
 }
 export function saveConnectionSecret(path, secret, verbose) {
     const alreadyExists = existsSync(path);
-    const dir = join(homedir(), ".alby-cli");
+    const dir = getAlbyCliDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
@@ -43,16 +97,20 @@ export async function testAndLogConnection(client) {
     const info = await getInfo(client);
     console.log(`Connected to ${info.alias || "wallet"} (${info.network || "unknown network"})`);
 }
-export async function completePendingConnection(pendingSecretPath, connectionSecretPath, relayUrl, verbose, pendingRelayPath) {
+export async function completePendingConnection(pendingSecretPath, connectionSecretPath, relayUrls, verbose, pendingRelayPath) {
     const secret = readFileSync(pendingSecretPath, "utf-8").trim();
-    const DEFAULT_RELAY = "wss://relay.getalby.com/v1";
-    if (!relayUrl && pendingRelayPath && existsSync(pendingRelayPath)) {
-        relayUrl = readFileSync(pendingRelayPath, "utf-8").trim();
+    if ((!relayUrls || relayUrls.length === 0) &&
+        pendingRelayPath &&
+        existsSync(pendingRelayPath)) {
+        relayUrls = readFileSync(pendingRelayPath, "utf-8")
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
     }
-    const resolvedRelay = relayUrl ?? DEFAULT_RELAY;
+    const resolvedRelays = relayUrls && relayUrls.length > 0 ? relayUrls : DEFAULT_RELAY_URLS;
     const nwaClient = new NWAClient({
         appSecretKey: secret,
-        relayUrls: [resolvedRelay],
+        relayUrls: resolvedRelays,
         requestMethods: [],
     });
     return new Promise((resolve, reject) => {
@@ -117,7 +175,11 @@ export async function getClient(program) {
         }
     }
     if (!connectionSecret) {
-        throw new Error("No connection secret provided. Pass -c <secret or file path>, set NWC_URL, use --wallet-name <name>, or create ~/.alby-cli/connection-secret.key");
+        throw new Error("No wallet connection found. Run 'auth' or 'connect' first to set up a wallet:\n" +
+            "    npx @getalby/cli auth <wallet-url>          # e.g. https://my.albyhub.com\n" +
+            '    npx @getalby/cli connect "nostr+walletconnect://..."\n' +
+            "\n" +
+            "Already have a connection secret? Pass -c <secret or file path>, set NWC_URL, use --wallet-name <name>, or create ~/.alby-cli/connection-secret.key");
     }
     // Auto-detect: if it doesn't start with the protocol, treat as file path
     if (!connectionSecret.startsWith("nostr+walletconnect://")) {

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.6.1",
+  "version": "0.7.0",
   "type": "module",
   "main": "build/index.js",
   "bin": {
@@ -36,8 +36,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@getalby/lightning-tools": "^8.0.0",
-    "@getalby/sdk": "^7.0.0",
+    "@getalby/lightning-tools": "^8.1.1",
+    "@getalby/sdk": "^8.0.1",
+    "@lendasat/lendaswap-sdk-pure": "^0.2.36",
     "@noble/hashes": "^2.0.1",
     "commander": "^14.0.3",
     "nostr-tools": "^2.23.3"