@getalby/lightning-tools 8.1.0 → 8.2.0

package/dist/types/402/l402.d.ts

@@ -3,12 +3,58 @@ interface Wallet {
         invoice: string;
     }): Promise<{
         preimage: string;
+        fees_paid?: number;
     }>;
 }
-
-declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: {
+/**
+ * A reusable payment credential. After a successful paid request the credential
+ * is attached to the response (see {@link PaymentInfo}). Pass it back via
+ * `options.credentials` on a follow-up request (e.g. polling a long-running
+ * job) to authorize the request without paying again.
+ *
+ * `header` is the HTTP header the credential is sent in (`Authorization` for
+ * L402/MPP, `payment-signature` for x402) and `value` is the header value.
+ */
+interface PaymentCredentials {
+    header: string;
+    value: string;
+}
+/**
+ * Payment metadata attached (as `response.payment`) to responses returned by
+ * the 402 fetch helpers.
+ */
+interface PaymentInfo {
+    /** Whether a lightning payment was made to obtain this response. */
+    paid: boolean;
+    /** Amount of the paid invoice, in satoshis (0 when `paid` is false). */
+    amount: number;
+    /** Routing fees paid, in millisatoshis, when reported by the wallet. */
+    feesPaid?: number;
+    /** Payment preimage, present when a payment was made. */
+    preimage?: string;
+    /**
+     * Reusable credential. Pass it back via `options.credentials` on a follow-up
+     * request (e.g. polling) to authorize it without paying again.
+     */
+    credentials: PaymentCredentials;
+}
+/** A `Response` with optional payment metadata attached by the 402 helpers. */
+type PaidResponse = Response & {
+    payment?: PaymentInfo;
+};
+/** Options accepted by the 402 fetch helpers. */
+interface Fetch402Options {
     wallet: Wallet;
-}) => Promise<Response>;
+    /**
+     * A credential returned by a previous paid request. When provided it is
+     * applied to the request and the helper NEVER pays again — even if the server
+     * still responds with a 402 (that response is returned to the caller as-is).
+     * Use it to authorize follow-up requests (e.g. polling) without re-paying.
+     */
+    credentials?: PaymentCredentials;
+}
+
+declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
 interface WwwAuthenticatePayload {
     token: string;

package/dist/types/402/mpp.d.ts

@@ -3,8 +3,56 @@ interface Wallet {
         invoice: string;
     }): Promise<{
         preimage: string;
+        fees_paid?: number;
     }>;
 }
+/**
+ * A reusable payment credential. After a successful paid request the credential
+ * is attached to the response (see {@link PaymentInfo}). Pass it back via
+ * `options.credentials` on a follow-up request (e.g. polling a long-running
+ * job) to authorize the request without paying again.
+ *
+ * `header` is the HTTP header the credential is sent in (`Authorization` for
+ * L402/MPP, `payment-signature` for x402) and `value` is the header value.
+ */
+interface PaymentCredentials {
+    header: string;
+    value: string;
+}
+/**
+ * Payment metadata attached (as `response.payment`) to responses returned by
+ * the 402 fetch helpers.
+ */
+interface PaymentInfo {
+    /** Whether a lightning payment was made to obtain this response. */
+    paid: boolean;
+    /** Amount of the paid invoice, in satoshis (0 when `paid` is false). */
+    amount: number;
+    /** Routing fees paid, in millisatoshis, when reported by the wallet. */
+    feesPaid?: number;
+    /** Payment preimage, present when a payment was made. */
+    preimage?: string;
+    /**
+     * Reusable credential. Pass it back via `options.credentials` on a follow-up
+     * request (e.g. polling) to authorize it without paying again.
+     */
+    credentials: PaymentCredentials;
+}
+/** A `Response` with optional payment metadata attached by the 402 helpers. */
+type PaidResponse = Response & {
+    payment?: PaymentInfo;
+};
+/** Options accepted by the 402 fetch helpers. */
+interface Fetch402Options {
+    wallet: Wallet;
+    /**
+     * A credential returned by a previous paid request. When provided it is
+     * applied to the request and the helper NEVER pays again — even if the server
+     * still responds with a 402 (that response is returned to the caller as-is).
+     * Use it to authorize follow-up requests (e.g. polling) without re-paying.
+     */
+    credentials?: PaymentCredentials;
+}
 
 /**
  * Fetch a resource protected by the draft-lightning-charge-00 payment
@@ -15,12 +63,12 @@ interface Wallet {
  * 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.
  */
-declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
-}) => Promise<Response>;
+declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
 export { fetchWithMpp };

package/dist/types/402/x402.d.ts

@@ -3,11 +3,76 @@ interface Wallet {
         invoice: string;
     }): Promise<{
         preimage: string;
+        fees_paid?: number;
     }>;
 }
-
-declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: {
+/**
+ * A reusable payment credential. After a successful paid request the credential
+ * is attached to the response (see {@link PaymentInfo}). Pass it back via
+ * `options.credentials` on a follow-up request (e.g. polling a long-running
+ * job) to authorize the request without paying again.
+ *
+ * `header` is the HTTP header the credential is sent in (`Authorization` for
+ * L402/MPP, `payment-signature` for x402) and `value` is the header value.
+ */
+interface PaymentCredentials {
+    header: string;
+    value: string;
+}
+/**
+ * Payment metadata attached (as `response.payment`) to responses returned by
+ * the 402 fetch helpers.
+ */
+interface PaymentInfo {
+    /** Whether a lightning payment was made to obtain this response. */
+    paid: boolean;
+    /** Amount of the paid invoice, in satoshis (0 when `paid` is false). */
+    amount: number;
+    /** Routing fees paid, in millisatoshis, when reported by the wallet. */
+    feesPaid?: number;
+    /** Payment preimage, present when a payment was made. */
+    preimage?: string;
+    /**
+     * Reusable credential. Pass it back via `options.credentials` on a follow-up
+     * request (e.g. polling) to authorize it without paying again.
+     */
+    credentials: PaymentCredentials;
+}
+/** A `Response` with optional payment metadata attached by the 402 helpers. */
+type PaidResponse = Response & {
+    payment?: PaymentInfo;
+};
+/** Options accepted by the 402 fetch helpers. */
+interface Fetch402Options {
     wallet: Wallet;
-}) => Promise<Response>;
+    /**
+     * A credential returned by a previous paid request. When provided it is
+     * applied to the request and the helper NEVER pays again — even if the server
+     * still responds with a 402 (that response is returned to the caller as-is).
+     * Use it to authorize follow-up requests (e.g. polling) without re-paying.
+     */
+    credentials?: PaymentCredentials;
+}
+
+interface X402Requirements {
+    scheme: string;
+    network: string;
+    extra: {
+        invoice: string;
+        paymentMethod?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+
+/**
+ * Probe a PAYMENT-REQUIRED header for a lightning-payable offer without
+ * throwing. Returns the matching requirements, or null if the header has no
+ * lightning entry (e.g. USDC-only endpoints) or is malformed. Used by the
+ * top-level fetch402 dispatcher to decide whether to attempt payment or hand
+ * the 402 back to the caller.
+ */
+declare const findX402LightningRequirements: (x402Header: string) => X402Requirements | null;
+declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
-export { fetchWithX402 };
+export { fetchWithX402, findX402LightningRequirements };

package/dist/types/402.d.ts

@@ -3,18 +3,71 @@ interface Wallet {
         invoice: string;
     }): Promise<{
         preimage: string;
+        fees_paid?: number;
     }>;
 }
+/**
+ * A reusable payment credential. After a successful paid request the credential
+ * is attached to the response (see {@link PaymentInfo}). Pass it back via
+ * `options.credentials` on a follow-up request (e.g. polling a long-running
+ * job) to authorize the request without paying again.
+ *
+ * `header` is the HTTP header the credential is sent in (`Authorization` for
+ * L402/MPP, `payment-signature` for x402) and `value` is the header value.
+ */
+interface PaymentCredentials {
+    header: string;
+    value: string;
+}
+/**
+ * Payment metadata attached (as `response.payment`) to responses returned by
+ * the 402 fetch helpers.
+ */
+interface PaymentInfo {
+    /** Whether a lightning payment was made to obtain this response. */
+    paid: boolean;
+    /** Amount of the paid invoice, in satoshis (0 when `paid` is false). */
+    amount: number;
+    /** Routing fees paid, in millisatoshis, when reported by the wallet. */
+    feesPaid?: number;
+    /** Payment preimage, present when a payment was made. */
+    preimage?: string;
+    /**
+     * Reusable credential. Pass it back via `options.credentials` on a follow-up
+     * request (e.g. polling) to authorize it without paying again.
+     */
+    credentials: PaymentCredentials;
+}
+/** A `Response` with optional payment metadata attached by the 402 helpers. */
+type PaidResponse = Response & {
+    payment?: PaymentInfo;
+};
+/** Options accepted by the 402 fetch helpers. */
+interface Fetch402Options {
+    wallet: Wallet;
+    /**
+     * A credential returned by a previous paid request. When provided it is
+     * applied to the request and the helper NEVER pays again — even if the server
+     * still responds with a 402 (that response is returned to the caller as-is).
+     * Use it to authorize follow-up requests (e.g. polling) without re-paying.
+     */
+    credentials?: PaymentCredentials;
+}
+/** Apply a previously-obtained credential to the outgoing request headers. */
+declare const applyCredentials: (headers: Headers, credentials: PaymentCredentials) => void;
+/** Attach payment metadata to a response and return it (typed). */
+declare const attachPayment: (response: Response, payment: PaymentInfo | undefined) => PaidResponse;
+/** Payment metadata describing a request authorized with a reused credential. */
+declare const reusedCredentialPayment: (credentials: PaymentCredentials | undefined) => PaymentInfo | undefined;
+/** Satoshi amount of a BOLT11 invoice (0 when it cannot be decoded). */
+declare const getInvoiceAmount: (invoice: string) => number;
 declare function createGuardedWallet(wallet: Wallet, maxAmountSats: number): Wallet;
 
-declare const fetch402: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
+declare const fetch402: (url: string, fetchArgs: RequestInit, options: Fetch402Options & {
     maxAmount?: number;
-}) => Promise<Response>;
+}) => Promise<PaidResponse>;
 
-declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
-}) => Promise<Response>;
+declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
 interface WwwAuthenticatePayload {
     token: string;
@@ -53,9 +106,26 @@ declare function parseL402Authorization(input: string): {
     preimage: string;
 } | null;
 
-declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
-}) => Promise<Response>;
+interface X402Requirements {
+    scheme: string;
+    network: string;
+    extra: {
+        invoice: string;
+        paymentMethod?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+
+/**
+ * Probe a PAYMENT-REQUIRED header for a lightning-payable offer without
+ * throwing. Returns the matching requirements, or null if the header has no
+ * lightning entry (e.g. USDC-only endpoints) or is malformed. Used by the
+ * top-level fetch402 dispatcher to decide whether to attempt payment or hand
+ * the 402 back to the caller.
+ */
+declare const findX402LightningRequirements: (x402Header: string) => X402Requirements | null;
+declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
 /**
  * Fetch a resource protected by the draft-lightning-charge-00 payment
@@ -66,13 +136,13 @@ declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: {
  * 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.
  */
-declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
-}) => Promise<Response>;
+declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
-export { createGuardedWallet, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402, issueL402Macaroon, makeL402AuthenticateHeader, parseL402, parseL402Authorization, verifyL402Macaroon };
-export type { MacaroonPayload, Wallet };
+export { applyCredentials, attachPayment, createGuardedWallet, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402, findX402LightningRequirements, getInvoiceAmount, issueL402Macaroon, makeL402AuthenticateHeader, parseL402, parseL402Authorization, reusedCredentialPayment, verifyL402Macaroon };
+export type { Fetch402Options, MacaroonPayload, PaidResponse, PaymentCredentials, PaymentInfo, Wallet };

package/dist/types/bip21.d.ts

@@ -0,0 +1,46 @@
+type Bip21 = {
+    /** Bare on-chain bitcoin address (no scheme, no query string). */
+    address: string;
+    /** Requested amount in BTC, as defined by BIP21 (e.g. 0.01). */
+    amount?: number;
+    /** Requested amount converted to satoshis, for convenience. */
+    amountSats?: number;
+    /** Label for the recipient, decoded. */
+    label?: string;
+    /** Free-form message, decoded. */
+    message?: string;
+    /** BOLT11 invoice or LNURL, from the `lightning=` parameter (unified QR). */
+    lightning?: string;
+    /** BOLT12 offer, from the `lno=` parameter. */
+    lno?: string;
+    /**
+     * `req-*` parameters that the client doesn't know how to handle.
+     * Per BIP21, callers MUST reject the URI if this is non-empty.
+     */
+    unknownRequiredParams: string[];
+    /** All query parameters, decoded, for advanced/custom use. */
+    params: Record<string, string>;
+};
+
+/**
+ * Parse a BIP21 (`bitcoin:`) URI. Returns `null` if the input doesn't have the
+ * `bitcoin:` scheme.
+ *
+ * The address is returned as-is (case preserved) — callers should validate it
+ * separately if they need to ensure it's a well-formed bitcoin address.
+ *
+ * Per BIP21, parameters prefixed with `req-` are required: if the client
+ * doesn't understand any of them, the payment MUST NOT be made. The unknown
+ * required params are surfaced via `unknownRequiredParams` so callers can
+ * decide how to fail.
+ *
+ * @example
+ * parseBip21("bitcoin:bc1q...?amount=0.001&lightning=lnbc...")
+ * // => { address: "bc1q...", amount: 0.001, amountSats: 100000, lightning: "lnbc...", ... }
+ */
+declare const parseBip21: (uri: string) => Bip21 | null;
+/** Returns true if the input starts with the `bitcoin:` URI scheme. */
+declare const isBip21: (uri: string) => boolean;
+
+export { isBip21, parseBip21 };
+export type { Bip21 };

package/dist/types/index.d.ts

@@ -245,18 +245,71 @@ interface Wallet {
         invoice: string;
     }): Promise<{
         preimage: string;
+        fees_paid?: number;
     }>;
 }
+/**
+ * A reusable payment credential. After a successful paid request the credential
+ * is attached to the response (see {@link PaymentInfo}). Pass it back via
+ * `options.credentials` on a follow-up request (e.g. polling a long-running
+ * job) to authorize the request without paying again.
+ *
+ * `header` is the HTTP header the credential is sent in (`Authorization` for
+ * L402/MPP, `payment-signature` for x402) and `value` is the header value.
+ */
+interface PaymentCredentials {
+    header: string;
+    value: string;
+}
+/**
+ * Payment metadata attached (as `response.payment`) to responses returned by
+ * the 402 fetch helpers.
+ */
+interface PaymentInfo {
+    /** Whether a lightning payment was made to obtain this response. */
+    paid: boolean;
+    /** Amount of the paid invoice, in satoshis (0 when `paid` is false). */
+    amount: number;
+    /** Routing fees paid, in millisatoshis, when reported by the wallet. */
+    feesPaid?: number;
+    /** Payment preimage, present when a payment was made. */
+    preimage?: string;
+    /**
+     * Reusable credential. Pass it back via `options.credentials` on a follow-up
+     * request (e.g. polling) to authorize it without paying again.
+     */
+    credentials: PaymentCredentials;
+}
+/** A `Response` with optional payment metadata attached by the 402 helpers. */
+type PaidResponse = Response & {
+    payment?: PaymentInfo;
+};
+/** Options accepted by the 402 fetch helpers. */
+interface Fetch402Options {
+    wallet: Wallet;
+    /**
+     * A credential returned by a previous paid request. When provided it is
+     * applied to the request and the helper NEVER pays again — even if the server
+     * still responds with a 402 (that response is returned to the caller as-is).
+     * Use it to authorize follow-up requests (e.g. polling) without re-paying.
+     */
+    credentials?: PaymentCredentials;
+}
+/** Apply a previously-obtained credential to the outgoing request headers. */
+declare const applyCredentials: (headers: Headers, credentials: PaymentCredentials) => void;
+/** Attach payment metadata to a response and return it (typed). */
+declare const attachPayment: (response: Response, payment: PaymentInfo | undefined) => PaidResponse;
+/** Payment metadata describing a request authorized with a reused credential. */
+declare const reusedCredentialPayment: (credentials: PaymentCredentials | undefined) => PaymentInfo | undefined;
+/** Satoshi amount of a BOLT11 invoice (0 when it cannot be decoded). */
+declare const getInvoiceAmount: (invoice: string) => number;
 declare function createGuardedWallet(wallet: Wallet, maxAmountSats: number): Wallet;
 
-declare const fetch402: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
+declare const fetch402: (url: string, fetchArgs: RequestInit, options: Fetch402Options & {
     maxAmount?: number;
-}) => Promise<Response>;
+}) => Promise<PaidResponse>;
 
-declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
-}) => Promise<Response>;
+declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
 interface WwwAuthenticatePayload {
     token: string;
@@ -295,9 +348,26 @@ declare function parseL402Authorization(input: string): {
     preimage: string;
 } | null;
 
-declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
-}) => Promise<Response>;
+interface X402Requirements {
+    scheme: string;
+    network: string;
+    extra: {
+        invoice: string;
+        paymentMethod?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+
+/**
+ * Probe a PAYMENT-REQUIRED header for a lightning-payable offer without
+ * throwing. Returns the matching requirements, or null if the header has no
+ * lightning entry (e.g. USDC-only endpoints) or is malformed. Used by the
+ * top-level fetch402 dispatcher to decide whether to attempt payment or hand
+ * the 402 back to the caller.
+ */
+declare const findX402LightningRequirements: (x402Header: string) => X402Requirements | null;
+declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
 /**
  * Fetch a resource protected by the draft-lightning-charge-00 payment
@@ -308,13 +378,13 @@ declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: {
  * 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.
  */
-declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: {
-    wallet: Wallet;
-}) => Promise<Response>;
+declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: Fetch402Options) => Promise<PaidResponse>;
 
 interface FiatCurrency {
     code: string;
@@ -338,5 +408,49 @@ declare const getFormattedFiatValue: ({ satoshi, currency, locale, }: {
     locale: string;
 }) => Promise<string>;
 
-export { DEFAULT_PROXY, Invoice, LN_ADDRESS_REGEX, LightningAddress, createGuardedWallet, decodeInvoice, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402, fromHexString, generateZapEvent, getEventHash, getFiatBtcRate, getFiatCurrencies, getFiatValue, getFormattedFiatValue, getSatoshiValue, isUrl, isValidAmount, issueL402Macaroon, makeL402AuthenticateHeader, parseKeysendResponse, parseL402, parseL402Authorization, parseLnUrlPayResponse, parseNostrResponse, sendBoostagram, serializeEvent, validateEvent, validatePreimage, verifyL402Macaroon };
-export type { Boost, BoostArguments, BoostOptions, Event, FiatCurrency, InvoiceArgs, KeySendRawData, KeysendResponse, LUD18PayerData, LUD18ServicePayerData, LnUrlPayResponse, LnUrlRawData, MacaroonPayload, NostrProvider, NostrResponse, RequestInvoiceArgs, SuccessAction, Wallet, WeblnBoostParams, ZapArgs, ZapOptions };
+type Bip21 = {
+    /** Bare on-chain bitcoin address (no scheme, no query string). */
+    address: string;
+    /** Requested amount in BTC, as defined by BIP21 (e.g. 0.01). */
+    amount?: number;
+    /** Requested amount converted to satoshis, for convenience. */
+    amountSats?: number;
+    /** Label for the recipient, decoded. */
+    label?: string;
+    /** Free-form message, decoded. */
+    message?: string;
+    /** BOLT11 invoice or LNURL, from the `lightning=` parameter (unified QR). */
+    lightning?: string;
+    /** BOLT12 offer, from the `lno=` parameter. */
+    lno?: string;
+    /**
+     * `req-*` parameters that the client doesn't know how to handle.
+     * Per BIP21, callers MUST reject the URI if this is non-empty.
+     */
+    unknownRequiredParams: string[];
+    /** All query parameters, decoded, for advanced/custom use. */
+    params: Record<string, string>;
+};
+
+/**
+ * Parse a BIP21 (`bitcoin:`) URI. Returns `null` if the input doesn't have the
+ * `bitcoin:` scheme.
+ *
+ * The address is returned as-is (case preserved) — callers should validate it
+ * separately if they need to ensure it's a well-formed bitcoin address.
+ *
+ * Per BIP21, parameters prefixed with `req-` are required: if the client
+ * doesn't understand any of them, the payment MUST NOT be made. The unknown
+ * required params are surfaced via `unknownRequiredParams` so callers can
+ * decide how to fail.
+ *
+ * @example
+ * parseBip21("bitcoin:bc1q...?amount=0.001&lightning=lnbc...")
+ * // => { address: "bc1q...", amount: 0.001, amountSats: 100000, lightning: "lnbc...", ... }
+ */
+declare const parseBip21: (uri: string) => Bip21 | null;
+/** Returns true if the input starts with the `bitcoin:` URI scheme. */
+declare const isBip21: (uri: string) => boolean;
+
+export { DEFAULT_PROXY, Invoice, LN_ADDRESS_REGEX, LightningAddress, applyCredentials, attachPayment, createGuardedWallet, decodeInvoice, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402, findX402LightningRequirements, fromHexString, generateZapEvent, getEventHash, getFiatBtcRate, getFiatCurrencies, getFiatValue, getFormattedFiatValue, getInvoiceAmount, getSatoshiValue, isBip21, isUrl, isValidAmount, issueL402Macaroon, makeL402AuthenticateHeader, parseBip21, parseKeysendResponse, parseL402, parseL402Authorization, parseLnUrlPayResponse, parseNostrResponse, reusedCredentialPayment, sendBoostagram, serializeEvent, validateEvent, validatePreimage, verifyL402Macaroon };
+export type { Bip21, Boost, BoostArguments, BoostOptions, Event, Fetch402Options, FiatCurrency, InvoiceArgs, KeySendRawData, KeysendResponse, LUD18PayerData, LUD18ServicePayerData, LnUrlPayResponse, LnUrlRawData, MacaroonPayload, NostrProvider, NostrResponse, PaidResponse, PaymentCredentials, PaymentInfo, RequestInvoiceArgs, SuccessAction, Wallet, WeblnBoostParams, ZapArgs, ZapOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getalby/lightning-tools",
-  "version": "8.1.0",
+  "version": "8.2.0",
   "description": "Collection of helpful building blocks and tools to develop Bitcoin Lightning web apps",
   "type": "module",
   "repository": "https://github.com/getAlby/js-lightning-tools.git",
@@ -68,6 +68,11 @@
       "import": "./dist/esm/podcasting2.js",
       "require": "./dist/cjs/podcasting2.cjs",
       "types": "./dist/types/podcasting2.d.ts"
+    },
+    "./bip21": {
+      "import": "./dist/esm/bip21.js",
+      "require": "./dist/cjs/bip21.cjs",
+      "types": "./dist/types/bip21.d.ts"
     }
   },
   "scripts": {