thunder-bridge 1.4.1 → 1.5.0

package/dist/rail-CqUfuYXJ.d.cts

@@ -1,615 +0,0 @@
-type Resolved = {
-    address: string;
-    bolt11: string;
-    verifyUrl: string;
-    paymentHash: string;
-    expiresAt: number;
-};
-/**
- * Bech32-encode a pay endpoint as the `LNURL1` string LUD-01 defines, uppercase
- * because that is the form it asks a QR to carry. An onion endpoint is http
- * rather than https, which LUD-17 spells out, so both are taken here
- */
-declare function toLnurl(endpoint: string): string;
-
-/** Where a payment stands, `paid` is the only status that carries a preimage */
-type PaymentStatus = "pending" | "paid" | "expired";
-/** Whether the gateway resolved the address and got the invoice, or was handed one to watch */
-type PaymentKind = "minted" | "watched";
-/** A payment as the gateway reports it, every field is checkable against the recipient */
-interface Payment {
-    id: string;
-    lnAddress: string;
-    amountMsat: number;
-    status: PaymentStatus;
-    paymentHash: string;
-    bolt11: string;
-    preimage: string | null;
-    expiresAt: number;
-    createdAt: number;
-    verifyUrl: string;
-}
-/**
- * `lnAddresses` is a priority list, the gateway takes the first one that can
- * issue a provable invoice for `amountMsat` and the rest are the fallback
- */
-interface CreatePaymentParams {
-    lnAddresses: string[];
-    amountMsat: number;
-    webhookUrl?: string;
-}
-/**
- * `lnAddresses` is the same priority list `createPayment` takes, and quoting it
- * mints nothing and charges the recipient's wallet nothing
- */
-interface CreateQuoteParams {
-    lnAddresses: string[];
-    amountMsat: number;
-}
-/**
- * Which address would serve an amount, and what the ones ahead of it refused.
- * `feeMsat` is always zero, the payer pays the recipient's own invoice and the
- * gateway is never in the money's path
- */
-interface Quote {
-    lnAddress: string;
-    amountMsat: number;
-    feeMsat: number;
-    minMsat: number;
-    maxMsat: number;
-    metadata: string;
-    refusals: WalletFailure[];
-}
-/**
- * What the gateway reports about a payment it is watching, for a trigger stream
- * or for one you minted yourself. `lnAddress` and `amountMsat` are null when the
- * gateway was never told them, which is the point of `watchPayment`: what the
- * watcher needs but the gateway should not know travels in `sealed` instead
- */
-interface TriggerEvent {
-    id: string;
-    kind: PaymentKind;
-    paymentHash: string;
-    verifyUrl: string;
-    status: PaymentStatus;
-    preimage: string | null;
-    expiresAt: number;
-    createdAt: number;
-    sealed: string | null;
-    lnAddress: string | null;
-    amountMsat: number | null;
-}
-/**
- * An invoice you obtained yourself, handed over to be watched. The gateway is
- * given no address and no amount, so it cannot refuse one recipient rather than
- * all of them
- */
-interface WatchPaymentParams {
-    paymentHash: string;
-    verifyUrl: string;
-    expiresAt: number;
-    trigger?: string;
-    /**
-     * How many of this trigger's settlements the gateway keeps replayable past the
-     * hour it would otherwise forget them in, up to the ceiling its operator set.
-     * Needs `trigger`, defaults to none
-     */
-    replay?: number;
-    sealed?: string;
-    webhookUrl?: string;
-}
-/**
- * A one minute pass onto one trigger's stream. It opens that trigger and nothing
- * else, which is what makes it the thing to hand a browser when the trigger
- * secret is not. `expiresAt` is unix seconds, like every other time here
- */
-interface SocketTicket {
-    ticket: string;
-    expiresAt: number;
-}
-/**
- * Which trigger the ticket opens, and how many of its settlements the socket
- * replays on connect, up to the ceiling the gateway's operator set
- */
-interface SocketTicketParams {
-    trigger: string;
-    replay?: number;
-}
-/** Why one wallet in the list could not be used */
-type WalletReason = "address-unusable" | "unreachable" | "amount-not-accepted" | "cannot-prove-delivery" | "invoice-refused";
-interface WalletFailure {
-    address: string;
-    reason: WalletReason;
-}
-/**
- * What a delivery carries. Everything needed to act on a settlement and to check
- * it, and nothing else, so a retry is the same size every time
- */
-interface Settlement {
-    id: string;
-    status: PaymentStatus;
-    paymentHash: string;
-    preimage: string | null;
-    settledAt: number;
-}
-
-interface ThunderBridgeOptions {
-    /**
-     * Prove every payment against the recipient's own server before handing it
-     * back, and refuse a reported settlement whose preimage does not hash to the
-     * payment hash, defaults to true
-     */
-    verify?: boolean;
-    /**
-     * Sent as `Authorization: Bearer`, which a gateway started with
-     * `GATEWAY_TOKEN` requires on every call, the socket handshake included. No
-     * browser WebSocket can carry a header, so setting this also puts every socket
-     * through a ticket
-     */
-    token?: string;
-    /**
-     * The same long lived server side secret your rail derives its preimages from.
-     * Given here, every call carries a signature the gateway reads as your identity,
-     * so a payment you create is handed back to you and to nobody else. Withheld,
-     * you are anonymous and any holder of an id can read what it names
-     */
-    secret?: string;
-}
-interface WaitOptions {
-    /** Give up when this aborts, `AbortSignal.timeout(ms)` covers the usual case */
-    signal?: AbortSignal;
-    /**
-     * Mint a short-lived ticket and put that in the socket URL instead of the
-     * payment id. Implied by `token`. The id stays readable inside the ticket,
-     * what changes is that a URL out of a log stops opening anything after a
-     * minute
-     */
-    tickets?: boolean;
-}
-interface CreateOptions {
-    /**
-     * Makes the POST safe to retry. A repeat of a finished request replays its
-     * payment instead of asking a wallet for a second invoice, a repeat that
-     * arrives while the first is still resolving throws
-     * `IdempotencyConflictError`, and the key is held for 24 hours
-     */
-    idempotencyKey?: string;
-    /**
-     * Groups this payment with every other one carrying the same secret, so
-     * `followTrigger` can watch the place rather than the payment. Registering
-     * sends only its sha256, which is also all the gateway stores, so a stolen
-     * ledger cannot subscribe. Following sends the secret itself, because the
-     * gateway hashes what it is given to find the stream, so the operator of a
-     * gateway you do not own learns it the first time you connect. Keep it apart
-     * from any URL a payer sees
-     */
-    trigger?: string;
-    /**
-     * How many of the trigger's settlements the gateway keeps replayable past the
-     * hour it would otherwise forget them in, up to the ceiling its operator set.
-     * Needs `trigger`, defaults to none
-     */
-    replay?: number;
-}
-interface FollowOptions {
-    /** Called for the recent settlements replayed on connect, then for each new one */
-    onPayment: (settled: TriggerEvent) => void;
-    /**
-     * How many settlements to ask for on connect, defaults to the gateway's ten.
-     * It hands back what it still holds, which is the last hour unless the
-     * payments were minted with `replay`
-     */
-    replay?: number;
-    /** Called when a connection drops or a frame is refused, the follow keeps going */
-    onError?: (error: unknown) => void;
-    /** Reconnect after a drop, defaults to true */
-    reconnect?: boolean;
-    /**
-     * The first wait after a drop, doubling up to 30 seconds and jittered so a
-     * fleet does not come back in lockstep, defaults to 3000. A connection that
-     * opens puts it back to the first wait
-     */
-    reconnectDelayMs?: number;
-    /**
-     * Mint a short-lived ticket and put that in the socket URL instead of the
-     * secret, one per connection. Keeps the secret out of access logs, at the cost
-     * of a POST before each connect. Implied by `token`. Leave it off for a
-     * microcontroller, where one hardcoded URL and a dumb reconnect loop is the
-     * whole point
-     */
-    tickets?: boolean;
-}
-/** Talks to a Thunder Bridge gateway and trusts it for nothing it can check itself */
-declare class ThunderBridge {
-    private readonly baseUrl;
-    private readonly verify;
-    private readonly token;
-    private readonly secret;
-    private strangers;
-    private speaks;
-    constructor(baseUrl: string, options?: ThunderBridgeOptions);
-    /**
-     * Whether a token was given, which is what makes an instance yours: a gateway
-     * started with `GATEWAY_TOKEN` answers nobody else, so anything you hand it
-     * stays between you and it
-     */
-    get isPrivate(): boolean;
-    /**
-     * Whether the gateway turns away a caller carrying no token, asked by making
-     * one unauthenticated read it would have to refuse. `isPrivate` answers only
-     * whether you configured a token, which is your side of the arrangement and
-     * says nothing about the gateway's, so a made-up token against a public
-     * instance reads as private and is not. Asked once and remembered, because an
-     * instance does not change its mind. Anything other than a refusal counts as
-     * open, so an unreachable gateway fails closed
-     */
-    refusesStrangers(): Promise<boolean>;
-    /**
-     * Ask the gateway for an invoice payable to the first address on your list
-     * that can issue a provable one, throws `NoWalletAvailableError` when none can
-     * and `GatewayCheatError` when what comes back is not what you asked for
-     */
-    createPayment(params: CreatePaymentParams, options?: CreateOptions): Promise<Payment>;
-    /**
-     * Ask which address would serve an amount without minting anything, throws
-     * `NoWalletAvailableError` when none would. A quote is a probe and not a
-     * promise: the address it names can still be refused at create time, because
-     * whether a wallet returns a provable invoice cannot be known without asking
-     * it for one, and asking mints it
-     */
-    createQuote(params: CreateQuoteParams): Promise<Quote>;
-    /** Read a payment back, null when the gateway has never heard of it */
-    /**
-     * The key this gateway signs webhooks with when you registered none of your own,
-     * ready to hand to `parseWebhookRequest` as `{ publicKey }`. Fetch it once and
-     * keep it: it is the same for every instance in the cluster
-     */
-    webhookKey(): Promise<string>;
-    getPayment(id: string): Promise<Payment | null>;
-    /**
-     * Read back a payment the gateway is only watching, null when it has never
-     * heard of it. A watched payment carries no address, amount or invoice, so
-     * `getPayment` refuses it and this reads the shape both rails share
-     */
-    getWatched(id: string): Promise<TriggerEvent | null>;
-    /**
-     * List what this gateway is watching, newest first. Only a gateway started
-     * with `GATEWAY_TOKEN` serves this, because on a shared one it would hand
-     * every caller everyone else's payments, so a public gateway answers 404.
-     *
-     * `scanned` says how many settled records were looked at to build the page.
-     * Anything older than that window is not in the answer, and the list does not
-     * pretend otherwise
-     */
-    listPayments(limit?: number): Promise<{
-        payments: TriggerEvent[];
-        scanned: number;
-    }>;
-    /**
-     * Follow a payment over WebSocket until it is paid or expired, reconnecting
-     * through a drop. A payment that never answers gives up after a few tries, and
-     * one that has answered is followed until its own expiry, so the wait always
-     * ends by itself
-     */
-    waitForPayment(id: string, options?: WaitOptions): Promise<Payment>;
-    /**
-     * Follow a payment the gateway is only watching, one it did not mint, until it
-     * is paid or expired.
-     *
-     * A watched payment carries no address, no amount and no invoice, because the
-     * gateway was told none of them, so it reads back as the shape a trigger
-     * streams rather than as a `Payment`. That is every bank transfer, and every
-     * Lightning invoice registered with `watchPayment` instead of `createPayment`.
-     */
-    waitForWatched(id: string, options?: WaitOptions): Promise<TriggerEvent>;
-    private followed;
-    /**
-     * Wait on several payments and keep the first one that is really paid, then stop
-     * waiting on the losers, which closes their sockets.
-     *
-     * This is how one order offers two rails. A Lightning invoice and a bank
-     * transfer for the same thing are two payments here, and the payer picks one, so
-     * what you want is the one that arrives and nothing further from the other.
-     *
-     * A leg that expires is a loser, not a winner, which is the whole reason this is
-     * not a race: `waitForPayment` ends on `paid` and on `expired` alike, and a
-     * Lightning invoice expires in an hour while a bank transfer takes days. `null`
-     * means every leg ended without being paid.
-     *
-     * Stopping the wait is not revoking the invoice. Nobody can revoke one, because
-     * the recipient's own wallet minted it, so a payer who pays the loser afterwards
-     * really does pay twice and that shows up on `followTrigger` as a second
-     * settlement to refund.
-     */
-    firstToSettle(ids: string[], options?: WaitOptions): Promise<TriggerEvent | null>;
-    /**
-     * Hand over an invoice you obtained yourself so the gateway watches it without
-     * being told the address or the amount. It can then only refuse everyone
-     * rather than one recipient, which is what makes leaving it cheap. Anything
-     * the watcher needs goes in `sealed`, which the gateway cannot read
-     */
-    watchPayment(params: WatchPaymentParams): Promise<TriggerEvent>;
-    /**
-     * What this payment is called, which you can work out before any gateway has
-     * heard of it. Every gateway you hand the same invoice to answers with the same
-     * name, so watching at several of them adds up to one payment rather than
-     * several, and no gateway's key is in the answer. Null when no secret was given,
-     * because then the gateway names the payment and only it can
-     */
-    nameFor(paymentHash: string): Promise<string | null>;
-    /**
-     * Follow every payment made to one trigger, replayed from the recent ones on
-     * connect and then live, reconnecting on its own until the returned function
-     * is called. A trigger has no terminal state, so this never resolves
-     */
-    followTrigger(secret: string, options: FollowOptions): () => void;
-    /**
-     * A one minute pass onto one trigger's stream, for something that must hold
-     * neither the token nor the trigger secret. Mint it in a handler and answer
-     * with the ticket alone, because that is all a browser needs to connect and
-     * all it can do anything with. `watchTicketEndpoint` is this method already
-     * wrapped in a route
-     */
-    createSocketTicket(params: SocketTicketParams): Promise<SocketTicket>;
-    private needsTicket;
-    private wsTicket;
-    private mintedTicket;
-    private sending;
-    private reading;
-    private speaking;
-    private proven;
-    private checked;
-}
-
-/** A wallet reachable over NIP-47, as its `nostr+walletconnect://` URI describes it */
-interface NwcConnection {
-    /** The wallet service's public key, which is what its answers have to be signed by */
-    walletPubkey: string;
-    /** Where to reach it, tried in order until one answers */
-    relays: string[];
-    /** Our own private key on this connection, and the only thing that authorises it */
-    secret: string;
-}
-/** A minted invoice and everything needed to watch it */
-interface NwcInvoice {
-    bolt11: string;
-    paymentHash: string;
-    expiresAt: number;
-}
-interface NwcVerifyConfig {
-    /** The wallet this endpoint speaks for. It never leaves this process */
-    connection: NwcConnection;
-    /** The secret the payment hash was sealed with, and nothing else uses it */
-    secret: string;
-    /** How often the gateway should ask, in seconds, sent as `Cache-Control: max-age`, `5` by default */
-    pollEverySecs?: number;
-    /** How long one `lookup_invoice` may take before the wallet counts as unreachable, `10_000` by default */
-    askTimeoutMs?: number;
-}
-/**
- * Read a `nostr+walletconnect://` URI. Refuses a relay that is not `wss`, for the
- * reason the gateway refuses a verify URL that is not https
- */
-declare function nwcConnection(uri: string): NwcConnection;
-/** Mint an invoice on the connected wallet, decoded so the caller need not trust its word */
-declare function nwcInvoice(connection: NwcConnection, amountMsat: number, description: string, timeoutMs?: number): Promise<NwcInvoice>;
-/**
- * Mint a hold invoice on a hash the wallet does not hold the preimage for, which
- * is what lets an operator be paid only by paying somebody else first. The hash
- * has to come from the recipient's own invoice, and the invoice that comes back
- * is decoded rather than believed
- */
-declare function nwcHoldInvoice(connection: NwcConnection, held: {
-    paymentHash: string;
-    amountMsat: number;
-    description: string;
-    expirySecs: number;
-    minCltvExpiryDelta?: number;
-}, timeoutMs?: number): Promise<NwcInvoice>;
-/**
- * The preimage the wallet released for this hash, null while it has released
- * none. A preimage that does not hash to what was asked for is a lie rather than
- * an answer, so it throws instead of being passed on
- */
-declare function nwcSettlement(connection: NwcConnection, paymentHash: string, timeoutMs?: number): Promise<string | null>;
-/**
- * Pay an invoice and keep the preimage the network handed back. Whoever pays
- * learns it, which is what makes delivery provable to a recipient publishing no
- * LUD-21 of their own. A preimage that does not hash to the invoice's own hash is
- * a lie rather than a receipt, so it throws instead of being passed on
- */
-declare function nwcPay(connection: NwcConnection, bolt11: string, timeoutMs?: number): Promise<string>;
-/**
- * A verify endpoint of your own that asks your wallet over NIP-47, so the gateway
- * polls you and never learns the connection, the relay, or which wallet it is.
- *
- * `nwcVerifyUrl` seals the payment hash into the query with your secret, which is
- * what stops a stranger driving your wallet through this handler. It answers the
- * LUD-21 shape the gateway already speaks, so nothing on that side changes.
- *
- * A wallet it cannot reach answers `502` rather than "not settled", because those
- * are different claims and only one of them is true.
- */
-declare function nwcVerifyEndpoint(config: NwcVerifyConfig): (request: Request) => Promise<Response>;
-/**
- * The URL to hand the gateway, with the payment hash sealed inside it. Point it at
- * wherever `nwcVerifyEndpoint` is mounted
- */
-declare function nwcVerifyUrl(endpoint: string, paymentHash: string, secret: string): Promise<string>;
-/**
- * One NIP-47 call, for a method this SDK does not wrap. The wallet's own info
- * event lists what it will answer, and anything it refuses comes back as a
- * `WalletRefused` carrying the code it named
- */
-declare function askWallet(connection: NwcConnection, method: string, params: Record<string, unknown>, timeoutMs?: number): Promise<Record<string, unknown>>;
-
-/** What a shop knows about a sale before any rail exists */
-interface Order {
-    /** The bank matches it on the statement, and Lightning keys idempotency on it */
-    reference: string;
-    /** The price in the smallest unit of `currency`, so 48055 is 480.55 CZK */
-    amountMinor: number;
-    /** ISO 4217. The bank rail moves this, Lightning reads it only through your own `amountMsat` */
-    currency: string;
-}
-/** One way to pay one order, already registered with the gateway */
-interface Leg {
-    /** The watched payment's id, which is what `firstToSettle`, `getWatched` and `waitForWatched` take */
-    id: string;
-    /** Which rail made it, so a shop can label a leg without knowing how it was built */
-    rail: string;
-    /** What the payer reads, a BOLT11 invoice or a Short Payment Descriptor */
-    scan: string;
-    /** The same thing as a QR has to encode it, which is not always `scan` itself */
-    qr: string;
-    expiresAt: number;
-}
-/**
- * A payment method. Everything that differs between rails is bound once when the
- * rail is built, so the only thing passed per sale is which sale it is
- */
-type Rail = (order: Order) => Promise<Leg>;
-interface BankRailConfig {
-    /** The gateway that will watch these transfers. It has to be one of your own */
-    gateway: ThunderBridge;
-    /** Long lived and server side. Every preimage is derived from it, so losing it loses every proof */
-    secret: string;
-    /** The account the money goes to, as an IBAN */
-    iban: string;
-    /** Where `bankVerifyEndpoint` is mounted, a public https URL with no query of its own */
-    verifyUrl: string;
-    /**
-     * When this order stops being payable, in unix seconds. Re-offering one order
-     * has to return the same second every time, because the gateway compares the
-     * expiry to decide whether a repeated watch is the same watch
-     */
-    expiresAt: (order: Order) => number;
-    /** Groups every leg on the same secret, so one `followTrigger` socket hears them all */
-    trigger?: string;
-    /** How many settlements of that trigger the gateway keeps replayable past the hour, needs `trigger` */
-    replay?: number;
-    /** Handed back untouched on that stream. Stable across re-offers, for the reason `expiresAt` is */
-    sealed?: (order: Order) => string | Promise<string>;
-    /** Up to ten digits, for accounting systems that still want one */
-    variableSymbol?: (order: Order) => string | undefined;
-    webhookUrl?: string;
-    /** Register on a gateway you do not own anyway, on the terms `bankTransfer` sets out */
-    allowPublicGateway?: boolean;
-    /** What `Leg.rail` reads, for a shop running more than one account */
-    name?: string;
-}
-interface LightningRailConfig {
-    /** The gateway that mints the invoice */
-    gateway: ThunderBridge;
-    /** Priority list, the gateway takes the first that can issue a provable invoice */
-    lnAddresses: string[];
-    /** What this order costs in millisatoshi. A shop pricing in fiat writes `msatFor` and its own ticker */
-    amountMsat: (order: Order) => number | Promise<number>;
-    /** Groups every leg on the same secret, so one `followTrigger` socket hears them all */
-    trigger?: string;
-    /** How many settlements of that trigger the gateway keeps replayable past the hour, needs `trigger` */
-    replay?: number;
-    /**
-     * Makes the mint safe to retry. Unset nothing is sent, because a key stable
-     * across re-offers is one the gateway can join against the bank leg's reference
-     */
-    idempotencyKey?: (order: Order) => string | undefined;
-    webhookUrl?: string;
-    /** What `Leg.rail` reads, for a shop running more than one wallet */
-    name?: string;
-}
-interface BlindLightningRailConfig {
-    /** The gateway that watches an invoice it was never allowed to mint */
-    gateway: ThunderBridge;
-    /** Priority list, resolved here rather than by the gateway */
-    lnAddresses: string[];
-    /** What this order costs in millisatoshi */
-    amountMsat: (order: Order) => number | Promise<number>;
-    /** Groups every leg on the same secret, so one `followTrigger` socket hears them all */
-    trigger?: string;
-    /** How many settlements of that trigger the gateway keeps replayable past the hour, needs `trigger` */
-    replay?: number;
-    /** Only a watched leg has anywhere to carry this */
-    sealed?: (order: Order) => string | Promise<string>;
-    webhookUrl?: string;
-    /**
-     * Where your own `lightningVerifyEndpoint` is mounted, and the secret it
-     * unseals with. Set both and the gateway is handed your URL rather than the
-     * wallet's, so it polls you, never a third party, and learns nothing about
-     * which provider the recipient uses. Leave them out and it polls the wallet
-     */
-    relayVerifyThrough?: {
-        endpoint: string;
-        secret: string;
-    };
-    /** What `Leg.rail` reads, for a shop running more than one wallet */
-    name?: string;
-}
-interface NwcRailConfig {
-    /** The gateway that watches an invoice your own wallet minted */
-    gateway: ThunderBridge;
-    /** Your wallet over NIP-47, from `nwcConnection`. It never reaches the gateway */
-    connection: NwcConnection;
-    /** What this order costs in millisatoshi */
-    amountMsat: (order: Order) => number | Promise<number>;
-    /**
-     * Where your own `nwcVerifyEndpoint` is mounted, and the secret it unseals
-     * with. The gateway is handed this URL rather than a wallet's, so it polls you
-     * and learns neither the connection nor which wallet is behind it
-     */
-    verifyThrough: {
-        endpoint: string;
-        secret: string;
-    };
-    /** What the payer reads on the invoice, and what your wallet files it under */
-    description?: (order: Order) => string;
-    /** Groups every leg on the same secret, so one `followTrigger` socket hears them all */
-    trigger?: string;
-    /** How many settlements of that trigger the gateway keeps replayable past the hour, needs `trigger` */
-    replay?: number;
-    /** Only a watched leg has anywhere to carry this */
-    sealed?: (order: Order) => string | Promise<string>;
-    webhookUrl?: string;
-    /** What `Leg.rail` reads, for a shop running more than one wallet */
-    name?: string;
-}
-/**
- * Sell for a bank transfer. The money moves straight to your account and the
- * gateway is told a hash, a URL and an expiry, never the amount or the reference.
- *
- * Which bank is read back is `bankVerifyEndpoint`'s business, not this one's, so
- * a rail built here serves Fio and anything else behind a `Statement`.
- */
-declare function bankRail(config: BankRailConfig): Rail;
-/**
- * Sell for Lightning, with the gateway minting the invoice. It is told the
- * address list and the amount, which is the round trip `blindLightningRail`
- * spends to avoid.
- */
-declare function lightningRail(config: LightningRailConfig): Rail;
-/**
- * Sell for Lightning, resolving the address here and handing the gateway only a
- * hash and a URL to poll. It costs one more round trip and the gateway learns
- * neither who is being paid nor how much, so the only refusal left to it is
- * refusing everyone.
- */
-declare function blindLightningRail(config: BlindLightningRailConfig): Rail;
-/**
- * Sell for Lightning against a wallet of your own over NIP-47, for a wallet that
- * has no LUD-21 address to be watched at. Your node mints the invoice and releases
- * the preimage, so the proof comes from one hop nearer than any hosted address can
- * manage, and the gateway sees a hash and a URL of yours.
- */
-declare function nwcRail(config: NwcRailConfig): Rail;
-/**
- * A provable invoice from the first address on the list that will issue one, which
- * is what a client mints for itself rather than asking a gateway to. Everything the
- * gateway needs to watch it comes back with everything you need to prove it came
- * from the address you asked for, so you can hand over the first and keep the second.
- *
- * Server side: it resolves hostnames and refuses a private one, which no browser can
- * do. Throws `NoWalletAvailableError` when no address on the list would serve
- */
-declare function invoiceFrom(lnAddresses: string[], amountMsat: number): Promise<Resolved>;
-
-export { nwcPay as A, type BankRailConfig as B, type CreatePaymentParams as C, nwcRail as D, nwcSettlement as E, type FollowOptions as F, nwcVerifyEndpoint as G, nwcVerifyUrl as H, type Leg as L, type NwcConnection as N, type Order as O, type Payment as P, type Quote as Q, type Rail as R, type Settlement as S, ThunderBridge as T, type WalletFailure as W, type ThunderBridgeOptions as a, type WatchPaymentParams as b, type TriggerEvent as c, type WaitOptions as d, type CreateOptions as e, type CreateQuoteParams as f, type LightningRailConfig as g, type PaymentKind as h, type PaymentStatus as i, type SocketTicket as j, type SocketTicketParams as k, type WalletReason as l, bankRail as m, lightningRail as n, type BlindLightningRailConfig as o, type NwcInvoice as p, type NwcRailConfig as q, type NwcVerifyConfig as r, type Resolved as s, toLnurl as t, askWallet as u, blindLightningRail as v, invoiceFrom as w, nwcConnection as x, nwcHoldInvoice as y, nwcInvoice as z };