@getalby/cli 0.0.0

package/build/commands/sign-message.js

@@ -0,0 +1,17 @@
+import { signMessage } from "../tools/nwc/sign_message.js";
+import { getClient, handleError, output } from "../utils.js";
+export function registerSignMessageCommand(program) {
+    program
+        .command("sign-message")
+        .description("Sign a message with the wallet's key")
+        .requiredOption("-m, --message <text>", "Message to sign")
+        .action(async (options) => {
+        await handleError(async () => {
+            const client = getClient(program);
+            const result = await signMessage(client, {
+                message: options.message,
+            });
+            output(result);
+        });
+    });
+}

package/build/commands/verify-preimage.js

@@ -0,0 +1,18 @@
+import { verifyPreimage } from "../tools/lightning/verify_preimage.js";
+import { handleError, output } from "../utils.js";
+export function registerVerifyPreimageCommand(program) {
+    program
+        .command("verify-preimage")
+        .description("Verify a preimage against an invoice")
+        .requiredOption("-i, --invoice <bolt11>", "BOLT-11 invoice")
+        .requiredOption("--preimage <hex>", "Preimage to verify (32 bytes hex)")
+        .action(async (options) => {
+        await handleError(async () => {
+            const result = verifyPreimage({
+                invoice: options.invoice,
+                preimage: options.preimage,
+            });
+            output(result);
+        });
+    });
+}

package/build/commands/wait-for-payment.js

@@ -0,0 +1,21 @@
+import { waitForPayment } from "../tools/nwc/wait_for_payment.js";
+import { getClient, handleError, output } from "../utils.js";
+export function registerWaitForPaymentCommand(program) {
+    program
+        .command("wait-for-payment")
+        .description("Wait for a payment notification")
+        .requiredOption("--payment-hash <hex>", "Payment hash to wait for")
+        .option("--type <type>", "Notification type filter: payment_received, payment_sent, hold_invoice_accepted")
+        .option("--timeout <seconds>", "Timeout in seconds", parseInt)
+        .action(async (options) => {
+        await handleError(async () => {
+            const client = getClient(program);
+            const result = await waitForPayment(client, {
+                payment_hash: options.paymentHash,
+                type: options.type,
+                timeout: options.timeout,
+            });
+            output(result);
+        });
+    });
+}

package/build/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerGetBalanceCommand } from "./commands/get-balance.js";
+import { registerGetBudgetCommand } from "./commands/get-budget.js";
+import { registerGetInfoCommand } from "./commands/get-info.js";
+import { registerGetWalletServiceInfoCommand } from "./commands/get-wallet-service-info.js";
+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 { registerPayInvoiceCommand } from "./commands/pay-invoice.js";
+import { registerPayKeysendCommand } from "./commands/pay-keysend.js";
+import { registerLookupInvoiceCommand } from "./commands/lookup-invoice.js";
+import { registerListTransactionsCommand } from "./commands/list-transactions.js";
+import { registerWaitForPaymentCommand } from "./commands/wait-for-payment.js";
+import { registerSignMessageCommand } from "./commands/sign-message.js";
+import { registerFiatToSatsCommand } from "./commands/fiat-to-sats.js";
+import { registerSatsToFiatCommand } from "./commands/sats-to-fiat.js";
+import { registerParseInvoiceCommand } from "./commands/parse-invoice.js";
+import { registerVerifyPreimageCommand } from "./commands/verify-preimage.js";
+import { registerRequestInvoiceCommand } from "./commands/request-invoice.js";
+import { registerFetchL402Command } from "./commands/fetch-l402.js";
+const program = new Command();
+program
+    .name("alby-cli")
+    .description("CLI for Nostr Wallet Connect (NIP-47) with lightning tools")
+    .version("0.0.0")
+    .option("-c, --connection-secret <string>", "NWC connection secret (nostr+walletconnect://...)");
+// Register all commands
+registerGetBalanceCommand(program);
+registerGetBudgetCommand(program);
+registerGetInfoCommand(program);
+registerGetWalletServiceInfoCommand(program);
+registerMakeInvoiceCommand(program);
+registerMakeHoldInvoiceCommand(program);
+registerSettleHoldInvoiceCommand(program);
+registerCancelHoldInvoiceCommand(program);
+registerPayInvoiceCommand(program);
+registerPayKeysendCommand(program);
+registerLookupInvoiceCommand(program);
+registerListTransactionsCommand(program);
+registerWaitForPaymentCommand(program);
+registerSignMessageCommand(program);
+registerFiatToSatsCommand(program);
+registerSatsToFiatCommand(program);
+registerParseInvoiceCommand(program);
+registerVerifyPreimageCommand(program);
+registerRequestInvoiceCommand(program);
+registerFetchL402Command(program);
+program.parse();

package/build/mcp_server.js

@@ -0,0 +1,36 @@
+import { webln } from "@getalby/sdk";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerGetInfoTool } from "./tools/nwc/get_info.js";
+import { registerGetWalletServiceInfoTool } from "./tools/nwc/get_wallet_service_info.js";
+import { registerLookupInvoiceTool } from "./tools/nwc/lookup_invoice.js";
+import { registerMakeInvoiceTool } from "./tools/nwc/make_invoice.js";
+import { registerPayInvoiceTool } from "./tools/nwc/pay_invoice.js";
+import { registerGetBalanceTool } from "./tools/nwc/get_balance.js";
+import { registerListTransactionsTool } from "./tools/nwc/list_transactions.js";
+import { registerFetchL402Tool } from "./tools/lightning/fetch_l402.js";
+import { registerFiatToSatsTool } from "./tools/lightning/fiat_to_sats.js";
+import { registerParseInvoiceTool } from "./tools/lightning/parse_invoice.js";
+import { registerRequestInvoiceFromLightningAddressTool } from "./tools/lightning/request_invoice.js";
+export function createMCPServer(client) {
+    const server = new McpServer({
+        name: "@getalby/mcp",
+        version: "1.1.0",
+        title: "Alby MCP Server",
+    });
+    // NWC
+    registerGetWalletServiceInfoTool(server, client);
+    registerGetInfoTool(server, client);
+    registerMakeInvoiceTool(server, client);
+    registerPayInvoiceTool(server, client);
+    registerGetBalanceTool(server, client);
+    registerLookupInvoiceTool(server, client);
+    registerListTransactionsTool(server, client);
+    // Lightning tools
+    registerFetchL402Tool(server, new webln.NostrWebLNProvider({
+        client,
+    }));
+    registerFiatToSatsTool(server);
+    registerParseInvoiceTool(server);
+    registerRequestInvoiceFromLightningAddressTool(server);
+    return server;
+}

package/build/sse.js

@@ -0,0 +1,50 @@
+import { nwc } from "@getalby/sdk";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { createMCPServer } from "./mcp_server.js";
+import { getConnectionSecret } from "./auth.js";
+export function addSSEEndpoints(app) {
+    // Store transports for each session type
+    // SSE is deprecated so we do not put much effort in here (e.g. cleaning up unused sessions)
+    const sessions = {};
+    app.get("/sse", async (req, res) => {
+        const nostrWalletConnectUrl = getConnectionSecret(req.header("Authorization"), req.query.nwc);
+        if (!nostrWalletConnectUrl) {
+            res
+                .status(400)
+                .send("Bearer auth with NWC connection secret or nwc query parameter not provided");
+            return;
+        }
+        const client = new nwc.NWCClient({
+            nostrWalletConnectUrl,
+        });
+        const transport = new SSEServerTransport("/messages", res);
+        const server = createMCPServer(client);
+        sessions[transport.sessionId] = {
+            server,
+            transport,
+        };
+        console.info("Created new SSE session", transport.sessionId);
+        if (req.query.sessionId) {
+            console.info("Request provided its own session ID: " + req.query.sessionId);
+            sessions[req.query.sessionId] = {
+                server,
+                transport,
+            };
+        }
+        server.connect(transport);
+    });
+    app.post("/messages", (req, res) => {
+        const sessionId = req.query.sessionId;
+        console.info("SSE messages request", sessionId);
+        const session = sessions[sessionId];
+        if (session) {
+            console.info("Found session for messages request", sessionId);
+            session.transport.handlePostMessage(req, res);
+        }
+        else {
+            res
+                .status(400)
+                .send("No transport found for sessionId: " + req.query.sessionId);
+        }
+    });
+}

package/build/streamable_http.js

@@ -0,0 +1,49 @@
+import { createMCPServer } from "./mcp_server.js";
+import { nwc } from "@getalby/sdk";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { getConnectionSecret } from "./auth.js";
+import { json } from "express";
+export function addStreamableHttpEndpoints(app) {
+    app.post("/mcp", json(), async (req, res) => {
+        // In stateless mode, create a new instance of transport and server for each request
+        // to ensure complete isolation. A single instance would cause request ID collisions
+        // when multiple clients connect concurrently.
+        try {
+            const nostrWalletConnectUrl = getConnectionSecret(req.header("Authorization"), req.query.nwc);
+            if (!nostrWalletConnectUrl) {
+                res
+                    .status(400)
+                    .send("Bearer auth with NWC connection secret or nwc query parameter not provided");
+                return;
+            }
+            const client = new nwc.NWCClient({
+                nostrWalletConnectUrl,
+            });
+            const server = createMCPServer(client);
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            res.on("close", () => {
+                console.log("Request closed");
+                transport.close();
+                server.close();
+                client.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error("Error handling MCP request:", error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+}

package/build/test/fetch-l402.test.js

@@ -0,0 +1,7 @@
+import { describe, test, expect } from "vitest";
+describe("L402 Commands", () => {
+    // NOTE: there is no easy way to test l402 right now
+    test.skip("fetch-l402 fetches L402 protected resource", () => {
+        expect(true).toBe(true);
+    });
+});

package/build/test/helpers.js

@@ -0,0 +1,61 @@
+import { execSync } from "child_process";
+import { createHash, randomBytes } from "crypto";
+export function generateHoldInvoiceParams() {
+    const preimage = randomBytes(32).toString("hex");
+    const paymentHash = createHash("sha256")
+        .update(Buffer.from(preimage, "hex"))
+        .digest("hex");
+    return { preimage, paymentHash };
+}
+export async function createTestWallet(retries = 5) {
+    for (let i = 0; i < retries; i++) {
+        try {
+            const response = await fetch("https://faucet.nwc.dev?balance=10000", {
+                method: "POST",
+            });
+            if (!response.ok) {
+                if (i < retries - 1) {
+                    await new Promise((r) => setTimeout(r, 2000 * (i + 1)));
+                    continue;
+                }
+                throw new Error(`Faucet request failed: ${response.status}`);
+            }
+            const nwcUrl = (await response.text()).trim();
+            const lud16Match = nwcUrl.match(/lud16=([^&\s]+)/);
+            if (!lud16Match) {
+                throw new Error("No lud16 in NWC URL");
+            }
+            return {
+                nwcUrl,
+                lightningAddress: decodeURIComponent(lud16Match[1]),
+            };
+        }
+        catch (error) {
+            if (i < retries - 1) {
+                await new Promise((r) => setTimeout(r, 2000 * (i + 1)));
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("Failed to create test wallet");
+}
+export function runCli(args) {
+    try {
+        const result = execSync(`node build/index.js ${args}`, {
+            encoding: "utf-8",
+            cwd: process.cwd(),
+        });
+        return { success: true, output: JSON.parse(result) };
+    }
+    catch (error) {
+        const err = error;
+        const errorOutput = err.stderr || err.stdout || "{}";
+        try {
+            return { success: false, output: JSON.parse(errorOutput) };
+        }
+        catch {
+            return { success: false, output: { error: errorOutput } };
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+import { describe, test, expect } from "vitest";
+import { runCli } from "./helpers.js";
+const exampleInvoice = "lnbc1u1p5hlrr8dqqnp4qwmtpr4p72ms7gnq3pkfk2876y2msvl33s3840dlp6xsv2w59dpscpp55utq6s8u5407namwt4jvhgsaf9fyszppjfwyxp7qsw6cyc8vxukqsp583usez9yhmkcavvvjz8cq56v3nglh2q37xkf4ufrgwxfrfjkm54s9qyysgqcqzp2xqyz5vqgtyysw64zt9sj6kfpqnekzwc37y2uyg0xdapgxqqth4uahff0x89sjfsvukjlllasg5dn05u2uha6qcvxz2y3ye5k7958qtes4pv4ggqtnjyky";
+const exampleLightningAddress = "nwc1769966844@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");
+        expect(result.success).toBe(true);
+        expect(result.output.amount_in_sats).toBeTypeOf("number");
+        expect(result.output.amount_in_sats).toBeGreaterThan(0);
+    });
+    test("sats-to-fiat converts sats to USD", () => {
+        const result = runCli("sats-to-fiat -a 1000 --currency USD");
+        expect(result.success).toBe(true);
+        expect(result.output.amount).toBeTypeOf("number");
+        expect(result.output.amount).toBeGreaterThan(0);
+    });
+    test("parse-invoice parses a BOLT-11 invoice", () => {
+        const result = runCli(`parse-invoice -i "${exampleInvoice}"`);
+        expect(result.success).toBe(true);
+        expect(result.output.paymentHash).toBeDefined();
+        expect(result.output.amount_in_sats).toBe(100);
+    });
+    test("verify-preimage returns false for invalid preimage", () => {
+        // Use a fake preimage (32 bytes of zeros)
+        const fakePreimage = "0000000000000000000000000000000000000000000000000000000000000000";
+        const result = runCli(`verify-preimage -i "${exampleInvoice}" --preimage "${fakePreimage}"`);
+        expect(result.success).toBe(true);
+        expect(result.output.valid).toBe(false);
+    });
+    test("request-invoice requests invoice from lightning address", async () => {
+        const result = runCli(`request-invoice -a "${exampleLightningAddress}" -s 100`);
+        expect(result.success).toBe(true);
+        expect(result.output.paymentRequest.toLowerCase()).toMatch(/^lnbc/);
+    });
+});

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

@@ -0,0 +1,79 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { spawn } from "child_process";
+import { createTestWallet, runCli, generateHoldInvoiceParams, } from "./helpers.js";
+describe("NWC HOLD Invoice Commands", () => {
+    let sender;
+    let receiver;
+    beforeAll(async () => {
+        // Create wallets sequentially to avoid faucet rate limiting
+        receiver = await createTestWallet();
+        sender = await createTestWallet();
+    }, 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}"`);
+        expect(result.success).toBe(true);
+        expect(result.output.invoice).toBeDefined();
+        expect(result.output.payment_hash).toBe(paymentHash);
+    });
+    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}"`);
+        expect(holdResult.success).toBe(true);
+        // Start wait-for-payment in background
+        const waitProcess = spawn("node", [
+            "build/index.js",
+            "-c",
+            receiver.nwcUrl,
+            "wait-for-payment",
+            "-p",
+            paymentHash,
+            "-t",
+            "30",
+        ], { stdio: ["ignore", "pipe", "pipe"] });
+        // Give it time to start listening
+        await new Promise((r) => setTimeout(r, 1000));
+        // Pay the invoice from sender (this will be held)
+        const payProcess = spawn("node", [
+            "build/index.js",
+            "-c",
+            sender.nwcUrl,
+            "pay-invoice",
+            "-i",
+            holdResult.output.invoice,
+        ], { stdio: ["ignore", "pipe", "pipe"] });
+        // Wait for the hold invoice to be accepted
+        await new Promise((r) => setTimeout(r, 2000));
+        // Settle the hold invoice
+        const settleResult = runCli(`-c "${receiver.nwcUrl}" settle-hold-invoice --preimage "${preimage}"`);
+        expect(settleResult.success).toBe(true);
+        expect(settleResult.output.preimage).toBe(preimage);
+        // Cleanup
+        waitProcess.kill();
+        payProcess.kill();
+    }, 60000);
+    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}"`);
+        expect(holdResult.success).toBe(true);
+        // Pay the invoice from sender (this will put it in held state)
+        const payProcess = spawn("node", [
+            "build/index.js",
+            "-c",
+            sender.nwcUrl,
+            "pay-invoice",
+            "-i",
+            holdResult.output.invoice,
+        ], { stdio: ["ignore", "pipe", "pipe"] });
+        // Wait for the hold invoice to be in held state
+        await new Promise((r) => setTimeout(r, 2000));
+        // Cancel the hold invoice (while it's held)
+        const cancelResult = runCli(`-c "${receiver.nwcUrl}" cancel-hold-invoice --payment-hash "${paymentHash}"`);
+        expect(cancelResult.success).toBe(true);
+        expect(cancelResult.output.payment_hash).toBe(paymentHash);
+        // Cleanup
+        payProcess.kill();
+    }, 60000);
+});

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

@@ -0,0 +1,42 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { createTestWallet, runCli } from "./helpers.js";
+describe("NWC Payment Commands", () => {
+    let sender;
+    let receiver;
+    beforeAll(async () => {
+        // Create wallets sequentially to avoid faucet rate limiting
+        sender = await createTestWallet();
+        receiver = await createTestWallet();
+    }, 60000);
+    test("make-invoice and pay-invoice", () => {
+        // Create invoice with receiver wallet
+        const invoiceResult = runCli(`-c "${receiver.nwcUrl}" make-invoice -a 100`);
+        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}"`);
+        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`);
+        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}"`);
+        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}"`);
+        expect(lookupResult.success).toBe(true);
+        expect(lookupResult.output.payment_hash).toBeDefined();
+    });
+    test("pay-keysend sends keysend payment", () => {
+        // Get receiver's pubkey
+        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`);
+        expect(keysendResult.success).toBe(true);
+        expect(keysendResult.output.preimage).toBeDefined();
+    });
+});

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

@@ -0,0 +1,41 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { createTestWallet, runCli } from "./helpers.js";
+describe("NWC Read-only Commands", () => {
+    let wallet;
+    beforeAll(async () => {
+        wallet = await createTestWallet();
+    }, 60000);
+    test("get-balance returns wallet balance", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" get-balance`);
+        expect(result.success).toBe(true);
+        expect(result.output.amount_in_sats).toBeTypeOf("number");
+    });
+    test("get-budget returns budget info", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" get-budget`);
+        expect(result.success).toBe(true);
+        expect(result.output).toBeDefined();
+    });
+    test("get-info returns wallet info", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" get-info`);
+        expect(result.success).toBe(true);
+        expect(result.output.alias).toBeDefined();
+        expect(result.output.pubkey).toBeDefined();
+    });
+    test("get-wallet-service-info returns service capabilities", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" get-wallet-service-info`);
+        expect(result.success).toBe(true);
+        expect(Array.isArray(result.output.capabilities)).toBe(true);
+    });
+    test("list-transactions returns transaction list", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" list-transactions`);
+        expect(result.success).toBe(true);
+        expect(Array.isArray(result.output.transactions)).toBe(true);
+    });
+    // NOTE: Faucet wallets don't have sign_message scope
+    test.skip("sign-message signs a message", () => {
+        const testMessage = "Hello, World!";
+        const result = runCli(`-c "${wallet.nwcUrl}" sign-message -m "${testMessage}"`);
+        expect(result.success).toBe(true);
+        expect(result.output.signature).toBeTypeOf("string");
+    });
+});

package/build/tools/lightning/fetch_l402.js

@@ -0,0 +1,32 @@
+import { fetchWithL402 } from "@getalby/lightning-tools";
+export async function fetchL402(client, params) {
+    const requestOptions = {
+        method: params.method,
+    };
+    if (params.method && params.method !== "GET" && params.method !== "HEAD") {
+        requestOptions.body = params.body;
+        requestOptions.headers = {
+            "Content-Type": "application/json",
+            ...params.headers,
+        };
+    }
+    else if (params.headers) {
+        requestOptions.headers = params.headers;
+    }
+    const webln = {
+        sendPayment: async (invoice) => {
+            const result = await client.payInvoice({ invoice });
+            return { preimage: result.preimage };
+        },
+    };
+    const result = await fetchWithL402(params.url, requestOptions, {
+        webln: webln,
+    });
+    const responseContent = await result.text();
+    if (!result.ok) {
+        throw new Error(`fetch returned non-OK status: ${result.status} ${responseContent}`);
+    }
+    return {
+        content: responseContent,
+    };
+}

package/build/tools/lightning/fiat_to_sats.js

@@ -0,0 +1,10 @@
+import { getSatoshiValue } from "@getalby/lightning-tools";
+export async function fiatToSats(params) {
+    const satoshi = await getSatoshiValue({
+        amount: params.amount,
+        currency: params.currency,
+    });
+    return {
+        amount_in_sats: satoshi,
+    };
+}

package/build/tools/lightning/parse_invoice.js

@@ -0,0 +1,8 @@
+import { Invoice } from "@getalby/lightning-tools";
+export function parseInvoice(params) {
+    const { satoshi, ...invoice } = new Invoice({ pr: params.invoice });
+    return {
+        ...invoice,
+        amount_in_sats: satoshi,
+    };
+}

package/build/tools/lightning/request_invoice.js

@@ -0,0 +1,14 @@
+import { LightningAddress } from "@getalby/lightning-tools";
+export async function requestInvoice(params) {
+    const ln = new LightningAddress(params.lightning_address);
+    await ln.fetch();
+    const { satoshi, ...invoice } = await ln.requestInvoice({
+        satoshi: params.amount_in_sats,
+        comment: params.comment,
+        payerdata: params.payer_data,
+    });
+    return {
+        ...invoice,
+        amount_in_sats: satoshi,
+    };
+}

package/build/tools/lightning/sats_to_fiat.js

@@ -0,0 +1,11 @@
+import { getFiatValue } from "@getalby/lightning-tools";
+export async function satsToFiat(params) {
+    const fiat = await getFiatValue({
+        satoshi: params.amount_in_sats,
+        currency: params.currency,
+    });
+    return {
+        amount: fiat,
+        currency: params.currency,
+    };
+}

package/build/tools/lightning/schemas/invoice.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export const invoiceSchema = {
+    paymentRequest: z.string().describe("The BOLT-11 payment request"),
+    paymentHash: z.string().describe("Payment hash"),
+    preimage: z.string().nullable().describe("Payment preimage if available"),
+    verify: z
+        .string()
+        .nullable()
+        .describe("URL to verify if the email was paid (LNURL-verify)"),
+    amount_in_sats: z.number().describe("Amount in sats"),
+    expiry: z.number().nullish().describe("Expiry time in seconds"),
+    timestamp: z.number().describe("Creation unix timestamp"),
+    createdDate: z.string().describe("Creation date string"),
+    expiryDate: z.string().nullish().describe("Expiry date string"),
+    description: z.string().nullable().describe("Invoice description"),
+    successAction: z
+        .unknown()
+        .nullable()
+        .describe("Success action to initiate after the invoice has been paid"),
+};

package/build/tools/lightning/verify_preimage.js

@@ -0,0 +1,9 @@
+import { Invoice } from "@getalby/lightning-tools";
+export function verifyPreimage(params) {
+    const invoice = new Invoice({ pr: params.invoice });
+    const valid = invoice.validatePreimage(params.preimage);
+    return {
+        valid,
+        payment_hash: invoice.paymentHash,
+    };
+}

package/build/tools/nwc/cancel_hold_invoice.js

@@ -0,0 +1,8 @@
+export async function cancelHoldInvoice(client, params) {
+    await client.cancelHoldInvoice({
+        payment_hash: params.payment_hash,
+    });
+    return {
+        payment_hash: params.payment_hash,
+    };
+}

package/build/tools/nwc/get_balance.js

@@ -0,0 +1,6 @@
+export async function getBalance(client) {
+    const balance = await client.getBalance();
+    return {
+        amount_in_sats: Math.floor(balance.balance / 1000),
+    };
+}