@getalby/lightning-tools 8.1.1 → 8.2.0

package/dist/esm/402.js

@@ -1257,6 +1257,28 @@ class Invoice {
     }
 }
 
+/** Apply a previously-obtained credential to the outgoing request headers. */
+const applyCredentials = (headers, credentials) => {
+    headers.set(credentials.header, credentials.value);
+};
+/** Attach payment metadata to a response and return it (typed). */
+const attachPayment = (response, payment) => {
+    if (payment) {
+        response.payment = payment;
+    }
+    return response;
+};
+/** Payment metadata describing a request authorized with a reused credential. */
+const reusedCredentialPayment = (credentials) => credentials ? { paid: false, amount: 0, credentials } : undefined;
+/** Satoshi amount of a BOLT11 invoice (0 when it cannot be decoded). */
+const getInvoiceAmount = (invoice) => {
+    try {
+        return new Invoice({ pr: invoice }).satoshi;
+    }
+    catch (_) {
+        return 0;
+    }
+};
 function createGuardedWallet(wallet, maxAmountSats) {
     return {
         payInvoice: async (args) => {
@@ -1308,6 +1330,9 @@ const handleL402Payment = async (l402Header, url, fetchArgs, headers, wallet) =>
     const details = parseL402(l402Header);
     const token = details.token || details.macaroon;
     const invoice = details.invoice;
+    // Preserve the scheme the server challenged with (L402 or LSAT) so the
+    // retry's Authorization header matches what the server expects.
+    const scheme = /^\s*LSAT\b/i.test(l402Header) ? "LSAT" : "L402";
     if (!token) {
         throw new Error("L402: missing token/macaroon in WWW-Authenticate header");
     }
@@ -1315,8 +1340,16 @@ const handleL402Payment = async (l402Header, url, fetchArgs, headers, wallet) =>
         throw new Error("L402: missing invoice in WWW-Authenticate header");
     }
     const invResp = await wallet.payInvoice({ invoice });
-    headers.set("Authorization", `L402 ${token}:${invResp.preimage}`);
-    return fetch(url, fetchArgs);
+    const value = `${scheme} ${token}:${invResp.preimage}`;
+    headers.set("Authorization", value);
+    const response = await fetch(url, fetchArgs);
+    return attachPayment(response, {
+        paid: true,
+        amount: getInvoiceAmount(invoice),
+        feesPaid: invResp.fees_paid,
+        preimage: invResp.preimage,
+        credentials: { header: "Authorization", value },
+    });
 };
 const fetchWithL402 = async (url, fetchArgs, options) => {
     const wallet = options.wallet;
@@ -1330,6 +1363,15 @@ const fetchWithL402 = async (url, fetchArgs, options) => {
     fetchArgs.mode = "cors";
     const headers = new Headers(fetchArgs.headers ?? undefined);
     fetchArgs.headers = headers;
+    // If the caller supplied a credential, we MUST use it and never pay again —
+    // even if the server still responds with a 402. Re-paying here is the exact
+    // double-charge this API exists to prevent; the caller decides what to do
+    // with a rejected credential (retry after settlement, top up, etc.).
+    if (options.credentials) {
+        applyCredentials(headers, options.credentials);
+        const reusedResp = await fetch(url, fetchArgs);
+        return attachPayment(reusedResp, reusedCredentialPayment(options.credentials));
+    }
     const initResp = await fetch(url, fetchArgs);
     const header = initResp.headers.get("www-authenticate");
     if (!header) {
@@ -1396,9 +1438,17 @@ const handleX402Payment = async (x402Header, url, fetchArgs, headers, wallet) =>
     if (invoice.amountRaw != requirements.amount) {
         throw new Error(`Invalid invoice amount: ${invoice.amountRaw}. expected ${requirements.amount}`);
     }
-    await wallet.payInvoice({ invoice: invoice.paymentRequest });
-    headers.set("payment-signature", buildX402PaymentSignature(requirements.scheme, requirements.network, invoice.paymentRequest, requirements));
-    return fetch(url, fetchArgs);
+    const invResp = await wallet.payInvoice({ invoice: invoice.paymentRequest });
+    const value = buildX402PaymentSignature(requirements.scheme, requirements.network, invoice.paymentRequest, requirements);
+    headers.set("payment-signature", value);
+    const response = await fetch(url, fetchArgs);
+    return attachPayment(response, {
+        paid: true,
+        amount: invoice.satoshi,
+        feesPaid: invResp.fees_paid,
+        preimage: invResp.preimage,
+        credentials: { header: "payment-signature", value },
+    });
 };
 const fetchWithX402 = async (url, fetchArgs, options) => {
     const wallet = options.wallet;
@@ -1409,6 +1459,15 @@ const fetchWithX402 = async (url, fetchArgs, options) => {
     fetchArgs.mode = "cors";
     const headers = new Headers(fetchArgs.headers ?? undefined);
     fetchArgs.headers = headers;
+    // If the caller supplied a credential, we MUST use it and never pay again —
+    // even if the server still responds with a 402. Re-paying here is the exact
+    // double-charge this API exists to prevent; the caller decides what to do
+    // with a rejected credential (retry after settlement, top up, etc.).
+    if (options.credentials) {
+        applyCredentials(headers, options.credentials);
+        const reusedResp = await fetch(url, fetchArgs);
+        return attachPayment(reusedResp, reusedCredentialPayment(options.credentials));
+    }
     const initResp = await fetch(url, fetchArgs);
     const header = initResp.headers.get("PAYMENT-REQUIRED");
     if (!header) {
@@ -1555,8 +1614,16 @@ const handleMppChargePayment = async (wwwAuthHeader, url, fetchArgs, headers, wa
     const invResp = await wallet.payInvoice({ invoice });
     // Per spec: Authorization: Payment <base64url-token>  (single token, no wrapper)
     const credential = buildMppCredential(challenge, invResp.preimage);
-    headers.set("Authorization", `Payment ${credential}`);
-    return fetch(url, fetchArgs);
+    const value = `Payment ${credential}`;
+    headers.set("Authorization", value);
+    const response = await fetch(url, fetchArgs);
+    return attachPayment(response, {
+        paid: true,
+        amount: getInvoiceAmount(invoice),
+        feesPaid: invResp.fees_paid,
+        preimage: invResp.preimage,
+        credentials: { header: "Authorization", value },
+    });
 };
 /**
  * Fetch a resource protected by the draft-lightning-charge-00 payment
@@ -1567,9 +1634,11 @@ const handleMppChargePayment = async (wwwAuthHeader, url, fetchArgs, headers, wa
  * the function pays the embedded BOLT11 invoice and retries with the
  * resulting preimage as the credential.
  *
- * Note: lightning-charge uses consume-once challenge semantics – each
- * challenge embeds a fresh invoice, so paid credentials cannot be reused.
- * The `store` option is accepted for API consistency but is not used.
+ * Pass a previous credential via `options.credentials` to reuse it (e.g. when
+ * polling); the credential is applied and the function NEVER pays again, even
+ * if the server still responds with a 402 (that response is returned as-is).
+ * Note: lightning-charge typically uses consume-once challenge semantics, so a
+ * reused credential is only accepted by servers that explicitly support it.
  */
 const fetchWithMpp = async (url, fetchArgs, options) => {
     const wallet = options.wallet;
@@ -1583,6 +1652,15 @@ const fetchWithMpp = async (url, fetchArgs, options) => {
     fetchArgs.mode = "cors";
     const headers = new Headers(fetchArgs.headers ?? undefined);
     fetchArgs.headers = headers;
+    // If the caller supplied a credential, we MUST use it and never pay again —
+    // even if the server still responds with a 402. Re-paying here is the exact
+    // double-charge this API exists to prevent; the caller decides what to do
+    // with a rejected credential (retry after settlement, top up, etc.).
+    if (options.credentials) {
+        applyCredentials(headers, options.credentials);
+        const reusedResp = await fetch(url, fetchArgs);
+        return attachPayment(reusedResp, reusedCredentialPayment(options.credentials));
+    }
     const initResp = await fetch(url, fetchArgs);
     const wwwAuthHeader = initResp.headers.get("www-authenticate");
     if (!wwwAuthHeader ||
@@ -1603,6 +1681,15 @@ const fetch402 = async (url, fetchArgs, options) => {
     fetchArgs.mode = "cors";
     const headers = new Headers(fetchArgs.headers ?? undefined);
     fetchArgs.headers = headers;
+    // If the caller supplied a credential, we MUST use it and never pay again —
+    // even if the server still responds with a 402. Re-paying here is the exact
+    // double-charge this API exists to prevent; the caller decides what to do
+    // with a rejected credential (retry after settlement, top up, etc.).
+    if (options.credentials) {
+        applyCredentials(headers, options.credentials);
+        const reusedResp = await fetch(url, fetchArgs);
+        return attachPayment(reusedResp, reusedCredentialPayment(options.credentials));
+    }
     const initResp = await fetch(url, fetchArgs);
     // L402 / LSAT: dedicated scheme, dispatch directly.
     const wwwAuthHeader = initResp.headers.get("www-authenticate");
@@ -1710,5 +1797,5 @@ function parseL402Authorization(input) {
     };
 }
 
-export { createGuardedWallet, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402, findX402LightningRequirements, issueL402Macaroon, makeL402AuthenticateHeader, parseL402, parseL402Authorization, verifyL402Macaroon };
+export { applyCredentials, attachPayment, createGuardedWallet, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402, findX402LightningRequirements, getInvoiceAmount, issueL402Macaroon, makeL402AuthenticateHeader, parseL402, parseL402Authorization, reusedCredentialPayment, verifyL402Macaroon };
 //# sourceMappingURL=402.js.map