thunder-bridge 1.4.2 → 2.1.1

package/dist/index.d.cts

@@ -1,11 +1,16 @@
-import { T as ThunderBridge, W as WalletFailure, a as ThunderBridgeOptions, b as WatchPaymentParams, c as TriggerEvent, d as WaitOptions, P as Payment, C as CreatePaymentParams, S as Settlement } from './rail-CqUfuYXJ.cjs';
-export { B as BankRailConfig, e as CreateOptions, f as CreateQuoteParams, F as FollowOptions, L as Leg, g as LightningRailConfig, O as Order, h as PaymentKind, i as PaymentStatus, Q as Quote, R as Rail, j as SocketTicket, k as SocketTicketParams, l as WalletReason, m as bankRail, n as lightningRail, t as toLnurl } from './rail-CqUfuYXJ.cjs';
+export { R as Resolved } from './qr-CF-YeXU1.cjs';
+import { T as ThunderBridge, g as ThunderBridgeOptions, W as WaitOptions } from './bank-CEIuNhV_.cjs';
+export { A as AttendOptions, h as BankRailConfig, d as BankVerifyConfig, i as BlindLightningRailConfig, j as CreateOptions, F as FollowOptions, H as Handler, L as Leg, k as LightningRailConfig, l as LightningVerifyConfig, M as Minted, O as Order, P as PaymentRequest, m as PaymentRequestInit, n as PaymentRequestOptions, o as Provable, p as Proven, f as Rail, R as RailConfig, q as Rails, r as Range, s as Relayed, t as Send, u as Serve, v as TicketOptions, w as TriggerConfig, x as WatchTicketConfig, y as WebhookCredential, z as WebhookHandlers, D as WebhookOptions, E as WrapAllowance, G as answerVerifyChallenge, I as carriesProof, J as invoiceFrom, K as proveOrigin, N as proveSettlement, Q as proveWrapped, U as relayedVerifyUrl, V as wrapFeeCeiling } from './bank-CEIuNhV_.cjs';
+import { H as Handover, P as Payment, e as Held } from './types-DYZ9EkmJ.cjs';
+export { A as Amount, C as Charge, F as FiatOptions, f as MintedPayment, g as Msat, h as PaymentStatus, i as Priced, Q as Quote, S as Settlement, j as SocketTicket, W as WalletFailure, l as WalletReason, n as WatchedPayment, o as fiat, p as msat, s as sats } from './types-DYZ9EkmJ.cjs';
+export { A as AmountError, a as AmountFault, G as GatewayCheatCode, b as GatewayCheatError, I as IdempotencyConflict, c as IdempotencyConflictError, N as NoWalletAvailableError, P as ProblemError, U as UnverifiedRecipientError, W as WrapRefusalCode, d as WrapRefusedError } from './errors-DriqW-lp.cjs';
 
 /** What a BOLT11 invoice says about itself, every field null when it does not carry one */
 interface Invoice {
     paymentHash: string | null;
     descriptionHash: string | null;
     amountMsat: number | null;
+    issuedAt: number | null;
     expiresAt: number | null;
 }
 /**
@@ -21,283 +26,15 @@ declare function preimageMatchesHash(preimage: string, paymentHash: string): boo
  * stores the result and hands it back untouched, so anything readable you put
  * in `sealed` is something you told it, which is what blind mode exists to avoid
  */
-declare function seal(secret: string, plaintext: string): Promise<string>;
+declare function seal(secret: string, plaintext: string, paymentHash?: string): Promise<string>;
 /**
  * Read a sealed blob back, null when it was sealed with another secret, edited
  * on the way, or is not one of ours. A secret too short to be a key throws,
  * because that is your bug rather than someone else's input
  */
-declare function unseal(secret: string, sealed: string): Promise<string | null>;
-
-/** One incoming payment as the bank booked it, in the smallest unit of its currency */
-interface Credit {
-    amountMinor: number;
-    currency: string;
-    /** Whatever the payer wrote, wherever this bank puts it. Matching is a substring, so noise around it is fine */
-    reference: string;
-    /**
-     * Unix seconds. A bank that books a day rather than an instant, as Fio does,
-     * gives the day's midnight in its own zone, so rendering this in UTC can show
-     * the day before. Nothing here matches on it, it is yours to read
-     */
-    bookedAt: number;
-}
-/**
- * Recent credits on one account, oldest or newest first, it makes no difference.
- * This is the whole plugin seam: a bank is a function of this shape, and
- * `fioStatement` is one implementation of it
- */
-type Statement = (sinceUnix: number) => Promise<Credit[]>;
-interface BankTransferParams {
-    /**
-     * The gateway that will watch this transfer. It has to be one of your own,
-     * meaning one you gave a token, unless `allowPublicGateway` says otherwise
-     */
-    gateway: ThunderBridge;
-    /** Long lived and server side. The preimage is derived from it, so losing it loses every proof */
-    secret: string;
-    /** What the payer must leave on the transfer, an order id or a nonce. It is matched, not stored */
-    reference: string;
-    /** The price in the smallest unit, so 48055 is 480.55 CZK */
-    amountMinor: number;
-    /** 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 the offer dies, in unix seconds. Money in a bank moves on banking days, so give it days */
-    expiresAt: number;
-    /** Defaults to CZK */
-    currency?: string;
-    /** Up to ten digits, for accounting systems that still want one */
-    variableSymbol?: string;
-    /**
-     * Groups this transfer with everything else paid to the same secret, so one
-     * `followTrigger` socket hears about it. Give the Lightning leg of the same
-     * order the same secret and both rails arrive on one stream
-     */
-    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, so a watcher learns which order settled
-     * without asking anyone. `seal` it and the gateway cannot read it either
-     */
-    sealed?: string;
-    /**
-     * Where the gateway posts once the money lands, a public https URL. Without one
-     * a transfer is only ever learned by following the trigger or asking
-     */
-    webhookUrl?: string;
-    /**
-     * Register on a gateway you do not own anyway. The verify URL names the amount
-     * and the reference, so its operator ends up reading your order book, and the
-     * URL itself answers whether that order was paid. Say true only when the order
-     * book is not worth hiding
-     */
-    allowPublicGateway?: boolean;
-}
-interface BankTransfer {
-    /** The watched payment's id at the gateway, which is how you read this order back */
-    id: string;
-    /** What the gateway was given, and what the preimage has to hash to */
-    paymentHash: string;
-    /** The same URL you mounted, carrying what to look for and a signature over it */
-    verifyUrl: string;
-    /** The payer scans this, it is a Short Payment Descriptor, the Czech QR platba format */
-    spd: string;
-}
-interface BankVerifyConfig {
-    /** The same secret `bankTransfer` was given */
-    secret: string;
-    /** The account to read */
-    statement: Statement;
-    /** How far back a credit still counts, seven days by default */
-    lookBackSecs?: number;
-    /**
-     * How often you want the gateway to ask, in seconds. It goes out as
-     * `Cache-Control: max-age`, so the pace is yours to set rather than the
-     * gateway's, and a bank that updates once a minute should say so instead of
-     * being polled every few seconds. Thirty by default, clamped to an hour
-     */
-    pollEverySecs?: number;
-}
-/**
- * Ask for a bank transfer and put it under the gateway's watch, so it settles
- * the way a Lightning payment does.
- *
- * A BOLT11 payment proves settlement with a preimage whose sha256 the payer's
- * invoice pins. A bank transfer has no such thing, so this mints one: the
- * preimage is an HMAC of what is being asked for, and its hash is what the
- * gateway is given. The money still moves straight to your account, and the
- * gateway still learns only a hash and a URL to poll.
- *
- * What the preimage proves is therefore what LUD-21 proves and no more: that
- * the server holding the secret saw the money arrive. It is the recipient's
- * own word, made unforgeable by anyone else.
- *
- * The gateway has to be one of your own. Unlike a blind Lightning watch, which
- * hands over a hash and an opaque wallet URL, this hands over a URL naming the
- * amount and the reference, so whoever runs the gateway can read your order book
- * from the watches alone.
- */
-declare function bankTransfer(params: BankTransferParams): Promise<BankTransfer>;
-/**
- * The verify endpoint the gateway polls, as a Fetch handler, so it runs wherever
- * `lnurlPayEndpoint` does.
- *
- * It answers the LUD-21 shape: `settled` false until a matching credit is on the
- * statement, then `settled` true with the preimage. Nothing is stored, because
- * the preimage is derived again from the secret every time it is asked for.
- *
- * The query has to carry the signature `bankTransfer` put there. Without that
- * check this would answer "did anyone send you 480.55 with this note" to whoever
- * asked, which is your bank statement handed out one question at a time.
- */
-declare function bankVerifyEndpoint(config: BankVerifyConfig): (request: Request) => Promise<Response>;
-
-/**
- * How many digits ISO 4217 gives the currency's minor unit, so 2 for a crown and a
- * euro, 0 for a yen and 3 for a dinar.
- *
- * There is no sane default here, which is why an unlisted code throws rather than
- * being treated as two. Assuming two turns 1000 yen into 10 and a dinar into a
- * tenth of itself, and a payment library that guesses at this is a payment library
- * that moves the wrong amount.
- */
-declare function minorUnitsOf(currency: string): number;
-/** The scale that minor unit implies, so 100 for a crown, 1 for a yen, 1000 for a dinar */
-declare function minorScaleOf(currency: string): number;
-
-/**
- * The way a gateway was caught out, every code is a check that held against the
- * recipient's own server and failed against what the gateway returned
- */
-type GatewayCheatCode = "address_not_requested" | "hash_mismatch" | "amount_mismatch" | "description_hash_mismatch" | "verify_url_foreign" | "invoice_not_issued" | "preimage_mismatch" | "id_not_mine";
-/**
- * Thrown when the gateway demonstrably misbehaved, the invoice it returned is
- * not the one the address you asked for issued, or a settlement it reported
- * carries a preimage that does not hash to the payment hash
- */
-declare class GatewayCheatError extends Error {
-    readonly code: GatewayCheatCode;
-    readonly paymentId: string;
-    constructor(code: GatewayCheatCode, paymentId: string);
-}
-/**
- * The way a wrapping operator was caught out. Every code is the wrapped invoice
- * failing to bind to the recipient's own, which is the only thing that makes
- * paying the wrap the same act as paying the recipient
- */
-type WrapRefusalCode = "undecodable" | "hash_mismatch" | "amount_below_recipient" | "fee_above_allowance" | "recipient_expires_first";
-/**
- * Thrown when a wrapped invoice does not bind to the recipient's. Paying it
- * would be paying the operator on its word rather than on the shared payment
- * hash, which is the whole of what makes wrapping safe
- */
-declare class WrapRefusedError extends Error {
-    readonly code: WrapRefusalCode;
-    constructor(code: WrapRefusalCode, detail: string);
-}
-/**
- * Thrown when the recipient's own server could not be reached to check the
- * invoice against, a CORS-blocked browser or a provider that is down, this is
- * not proof the gateway cheated and it is not proof it did not
- */
-declare class UnverifiedRecipientError extends Error {
-    readonly lnAddress: string;
-    readonly paymentId: string;
-    constructor(lnAddress: string, paymentId: string, cause: unknown);
-}
-/** An RFC 9457 problem document the gateway answered with */
-declare class ProblemError extends Error {
-    readonly type: string;
-    readonly title: string;
-    readonly status: number;
-    readonly detail: string | null;
-    constructor(problem: {
-        type?: string;
-        title?: string;
-        status?: number;
-        detail?: string;
-    });
-}
-/** Whether a problem document carries this type */
-declare function isProblemType(problem: {
-    type?: string;
-}, type: string): boolean;
-declare const NO_WALLET_AVAILABLE = "urn:problem-type:thunder-bridge:no-wallet-available";
-declare const REQUEST_IN_FLIGHT = "urn:problem-type:thunder-bridge:request-in-flight";
-declare const IDEMPOTENCY_KEY_REUSED = "urn:problem-type:thunder-bridge:idempotency-key-reused";
-declare const PAYMENT_ALREADY_WATCHED = "urn:problem-type:thunder-bridge:payment-already-watched";
-/**
- * Why an `Idempotency-Key` was refused, `request-in-flight` is the benign one and
- * `key-reused` means the same key was sent for a different request
- */
-type IdempotencyConflict = "request-in-flight" | "key-reused";
-/**
- * Thrown when an `Idempotency-Key` is held by another request. On
- * `request-in-flight` the first attempt is still resolving, so wait and read the
- * payment back rather than retrying. `key-reused` is a bug in the caller: the key
- * is bound to the addresses, amount and webhook that claimed it
- */
-declare class IdempotencyConflictError extends ProblemError {
-    readonly conflict: IdempotencyConflict;
-    constructor(problem: {
-        type?: string;
-        title?: string;
-        status?: number;
-        detail?: string;
-    }, conflict: IdempotencyConflict);
-}
-/** Thrown when no wallet on your list could issue a provable invoice, `wallets` says why each refused */
-declare class NoWalletAvailableError extends ProblemError {
-    readonly wallets: WalletFailure[];
-    constructor(problem: {
-        title?: string;
-        status?: number;
-        detail?: string;
-    }, wallets: WalletFailure[]);
-}
-
-interface FioConfig {
-    /**
-     * A token with "Sledování účtu" rights, which is read only and cannot move
-     * money. One token is one account, which is why this takes no account number.
-     *
-     * Give it several and they are used in turn. Fio's window is per token rather
-     * than per account, so five tokens on one account is a read every six seconds,
-     * and generating another token for the same account is what Fio's own
-     * documentation suggests when one is not enough
-     */
-    token: string | string[];
-    /**
-     * Fio's window for one token, 30 seconds. No token is ever asked twice inside
-     * it, and the gap between reads is this divided by however many tokens were
-     * given, so the answers stay evenly spaced rather than arriving in bursts.
-     * Inside that gap the last answer is handed back. Only helps a process that
-     * stays up
-     */
-    minIntervalSecs?: number;
-    /** Override to point at a mock */
-    baseUrl?: string;
-}
-/**
- * Read one Fio account as a `Statement`, so a bank transfer proves itself the
- * way a Lightning payment does.
- *
- * The token is the read only kind, generated in internetbanking under Nastavení
- * and API, and it is the whole configuration: a token belongs to one account, so
- * there is no account number to get wrong. It cannot pay anyone, and the worst a
- * leaked one costs you is that someone else can read the statement.
- *
- * Every field on a Fio transaction is optional and arrives as `null` when it is
- * absent, the amount carries its direction in its sign rather than in a flag,
- * and the date is a day and a UTC offset, `2026-07-15+0200`. This reads all
- * three the way the bank answers them and treats a missing field as absent
- * rather than guessing.
- */
-declare function fioStatement(config: FioConfig): Statement;
+declare function unseal(secret: string, sealed: string, paymentHash?: string): Promise<string | null>;
 
+/** The client's own options, plus what to do about a gateway that will not take the watch */
 interface GatewaysOptions extends ThunderBridgeOptions {
     /**
      * Called for each gateway that would not take the watch, with the url and what
@@ -328,243 +65,14 @@ declare class Gateways {
      * carrying the first refusal, because one gateway that agreed is enough to be
      * watched
      */
-    watchPayment(params: WatchPaymentParams): Promise<TriggerEvent>;
+    watch(handover: Handover): Promise<Payment>;
     /**
      * Wait for whichever gateway speaks first. A settlement from any of them is the
      * settlement, and each has already proved the preimage against the hash before
      * saying so. When they all end without a payment, the first ending is the answer,
      * and when they all fail, the first failure is thrown
      */
-    waitForWatched(id: string, options?: WaitOptions): Promise<TriggerEvent>;
+    settled(held: Held, options?: WaitOptions): Promise<Payment>;
 }
 
-/**
- * How many minor units of `currency` one bitcoin costs at one venue, so 134883815
- * is 1,348,838.15 CZK. Throws when that venue does not quote that currency, which
- * is a normal answer rather than a fault: Kraken and Bitstamp have no CZK pair
- *
- * This is the plugin seam for prices. Another venue is another function of this
- * shape
- */
-type Ticker = (currency: string) => Promise<number>;
-interface MedianOptions {
-    /**
-     * How many venues have to answer before a price is usable. Two is the floor
-     * worth having, because one venue is a number nobody checked
-     */
-    minVenues?: number;
-    /**
-     * Refuse the lot when the cheapest and dearest answers are further apart than
-     * this many basis points. Venues normally sit inside 50, so a wider spread means
-     * one of them is broken or stale rather than that the market moved
-     */
-    maxSpreadBps?: number;
-    /** Hold the last answer this long per currency, so an order page is not four requests */
-    holdForSecs?: number;
-}
-/** Coinbase, CASP authorised in Luxembourg. Quotes CZK, EUR and most fiat */
-declare function coinbase(baseUrl?: string): Ticker;
-/** Kraken, CASP authorised by the Central Bank of Ireland. Quotes EUR and USD, no CZK */
-declare function kraken(baseUrl?: string): Ticker;
-/**
- * Bitstamp, CASP authorised by the CSSF in Luxembourg. Quotes EUR and USD, no CZK.
- *
- * An unknown pair is answered with a `200` and the whole ticker list, whose first
- * entry is BTC/USD, so asking it for CZK and reading the number would quote a
- * bitcoin at 64,000 crowns. Anything but a single object is therefore refused
- */
-declare function bitstamp(baseUrl?: string): Ticker;
-/** Coinmate, on the ESMA CASP register, Czech and the one with a real BTC/CZK book */
-declare function coinmate(baseUrl?: string): Ticker;
-/**
- * Ask several venues and take the middle answer, refusing the lot when they
- * disagree too much.
- *
- * The default is the four MiCA authorised venues below, and every one of them is
- * replaceable: pass your own list, or one venue, or a function that reads a price
- * you already have. A venue that does not quote the currency is skipped rather
- * than fatal, which for CZK leaves Coinbase and Coinmate.
- *
- * The middle is taken rather than the mean so one stuck venue moves the answer by
- * nothing instead of by half its error, and the spread check is what catches the
- * stuck venue that stays inside the pack.
- */
-declare function medianOf(tickers?: Ticker[], options?: MedianOptions): Ticker;
-/**
- * What to ask for over Lightning for a price named in fiat, in millisatoshi.
- *
- * `priceMinorPerBtc` is what a `Ticker` returns. The arithmetic is exact, in
- * BigInt, because a million crown order times a hundred billion millisatoshi
- * leaves what a double can count, and it rounds up, because the extra
- * millisatoshi is worth nothing and belongs to the recipient rather than to a
- * rounding rule.
- *
- * `spreadBps` is yours to set, in basis points, and defaults to none. A Lightning
- * invoice lives an hour and a bank transfer takes days, so a shop pricing in fiat is
- * carrying that volatility whether or not it charges for it
- */
-declare function msatFor(amountMinor: number, priceMinorPerBtc: number, options?: {
-    spreadBps?: number;
-}): number;
-
-interface QrOptions {
-    /** SVG width and height in pixels, defaults to 256 */
-    size?: number;
-    /** Dark module color, defaults to `#000` */
-    color?: string;
-}
-/** Render a BOLT11 invoice or a lightning address as an SVG QR code */
-declare function invoiceToSvg(destination: string, options?: QrOptions): string;
-/** SVG data URL for an `<img>` `src` */
-declare function invoiceToDataUrl(destination: string, options?: QrOptions): string;
-/**
- * Render your own LNURL-pay endpoint, the URL `lnurlPayEndpoint` is mounted on,
- * as the QR a payer scans. Nothing is minted and nothing expires, so this is the
- * code a tip jar prints once and an overlay shows all stream
- */
-declare function lnurlToSvg(endpoint: string, options?: QrOptions): string;
-/** SVG data URL of the endpoint's QR, for an `<img>` `src` */
-declare function lnurlToDataUrl(endpoint: string, options?: QrOptions): string;
-/**
- * Render the `spd` from `bankTransfer` as the QR a Czech banking app scans. The
- * payload is a Short Payment Descriptor, so it carries the account, the amount
- * and the reference the payer must leave on the transfer
- */
-declare function spdToSvg(spd: string, options?: QrOptions): string;
-/** SVG data URL of the bank transfer's QR, for an `<img>` `src` */
-declare function spdToDataUrl(spd: string, options?: QrOptions): string;
-/**
- * Render any rail's `Leg.qr` as an SVG QR code. Each rail states its own payload,
- * a BOLT11 invoice under the `LIGHTNING` scheme or a Short Payment Descriptor as
- * it stands, so this draws a leg without being told which rail made it
- */
-declare function qrToSvg(payload: string, options?: QrOptions): string;
-/** SVG data URL of a leg's QR, for an `<img>` `src` */
-declare function qrToDataUrl(payload: string, options?: QrOptions): string;
-
-/**
- * What a wrapping operator may charge over the recipient's own amount. This is a
- * ceiling the client sets rather than a price the operator names, so it sits
- * above what any operator lists and refuses only the ones reaching past it
- */
-interface WrapAllowance {
-    /** As a fraction of the recipient's amount, `0.01` by default */
-    proportion?: number;
-    /** The floor in millisatoshi whatever the fraction works out to, `1000` by default */
-    baseMsat?: number;
-}
-/**
- * Prove the invoice really is the one the recipient issued for what you asked,
- * before the payer ever sees it, both fetches go straight to the recipient's own
- * server and none of them goes back to the gateway
- *
- * Throws `GatewayCheatError` when a check fails and `UnverifiedRecipientError`
- * when the recipient could not be reached to run one
- */
-declare function proveOrigin(payment: Payment, request: CreatePaymentParams): Promise<void>;
-/**
- * Prove the money arrived by asking the recipient's own server, not the gateway,
- * returns the preimage when the recipient says it settled and null when it says
- * it has not, and runs the full origin proof first because a verify url the
- * gateway made up would otherwise answer for itself
- */
-declare function proveSettlement(payment: Payment, request: CreatePaymentParams): Promise<string | null>;
-/**
- * True when the gateway's own report of a settlement is at least self-consistent,
- * the preimage hashes to the payment hash the invoice itself carries, this is a
- * sanity check and not a proof, only `proveSettlement` asks the recipient
- */
-declare function isProvablyPaid(payment: Payment): boolean;
-/**
- * The most an operator may add over the recipient's own amount, in millisatoshi.
- * The proportion is what routing and the liquidity behind it costs, and the base
- * is the floor it never drops below, because a fraction of a small payment
- * rounds to nothing the operator can work for
- */
-declare function wrapFeeCeiling(amountMsat: number, allowance?: WrapAllowance): number;
-/**
- * Prove a wrapping operator's invoice is the recipient's own payment in
- * disguise, so paying it can only settle by the operator paying the recipient.
- *
- * It compares two invoices and asks nobody anything, so it runs in a browser and
- * costs no round trip. Prove the recipient's own invoice with `proveOrigin`
- * first, because this says nothing about where that one came from.
- *
- * There is no settlement check here and there does not need to be. Both invoices
- * carry one payment hash, so the preimage that settles the wrap is the preimage
- * the recipient released, and `proveSettlement` already reads it from the
- * recipient's own server.
- *
- * Throws `WrapRefusedError` naming which binding failed
- */
-declare function proveWrapped(wrapped: string, recipient: string, allowance?: WrapAllowance): void;
-
-/** How far the gateway's clock may drift from yours before a webhook is refused */
-type WebhookOptions = {
-    toleranceSecs?: number;
-};
-/**
- * What checks a delivery: the hex the gateway publishes at `/webhook-key`. There
- * is no shared secret to register, so a gateway holds nothing of yours. Rotating
- * its cluster key rotates this too, so a signature that stops verifying is a
- * reason to read the key again before it is a reason to distrust the gateway
- */
-type WebhookCredential = {
-    publicKey: string;
-};
-/** Verify the `X-Signature` header against the raw body and the `X-Timestamp` that came with it */
-declare function verifyWebhookSignature(body: string | Uint8Array, signature: string, credential: WebhookCredential, timestamp: string, options?: WebhookOptions): Promise<boolean>;
-/** Verify and parse in one step, returns null on a bad signature or a body that is not a payment */
-declare function parseWebhook(body: string | Uint8Array, signature: string, credential: WebhookCredential, timestamp: string, options?: WebhookOptions): Promise<Payment | null>;
-/**
- * Verify and parse from a Fetch API `Request` as used by Hono, Next, SvelteKit,
- * Cloudflare Workers and Deno, WebCrypto only so it runs anywhere fetch does
- */
-declare function parseWebhookRequest(request: Request, credential: WebhookCredential, options?: WebhookOptions): Promise<Payment | null>;
-/**
- * The same, for a payment the gateway only watched. A bank transfer and a blind
- * Lightning leg carry no address, amount or invoice, so they arrive in the shape
- * `followTrigger` and `getWatched` hand back rather than the minted one
- */
-declare function parseWatchedWebhook(body: string | Uint8Array, signature: string, credential: WebhookCredential, timestamp: string, options?: WebhookOptions): Promise<TriggerEvent | null>;
-/** `parseWatchedWebhook` from a Fetch API `Request`, the way `parseWebhookRequest` is */
-declare function parseWatchedWebhookRequest(request: Request, credential: WebhookCredential, options?: WebhookOptions): Promise<TriggerEvent | null>;
-/**
- * Verify a delivery and read the settlement out of it. Null on a bad signature or
- * on a body that is not a settlement, so a handler that gets null did not just
- * miss a payment, it was handed something it had no reason to believe
- */
-declare function parseSettlement(body: string | Uint8Array, signature: string, credential: WebhookCredential, timestamp: string, options?: WebhookOptions): Promise<Settlement | null>;
-/** {@link parseSettlement} from a Fetch API `Request` */
-declare function parseSettlementRequest(request: Request, credential: WebhookCredential, options?: WebhookOptions): Promise<Settlement | null>;
-/**
- * Whether a delivery proves what it claims, which is the only question that
- * matters about one: it says paid and it carries a preimage that hashes to the
- * payment hash the delivery itself names
- */
-declare function isProvablySettled(settled: Settlement): boolean;
-/**
- * Answer the one challenge the gateway sends before it will watch a payment your
- * webhook is registered on. Returns the body to send back with a 200, or null when
- * this delivery is not a challenge, so a handler tries this first and then parses
- */
-declare function answerWebhookChallenge(body: string | Uint8Array, signature: string, credential: WebhookCredential, timestamp: string, options?: WebhookOptions): Promise<string | null>;
-/**
- * `answerWebhookChallenge` from a Fetch API `Request`, leaving the body unread so
- * the same handler can go on to `parseWebhookRequest` when this was no challenge
- */
-declare function answerWebhookChallengeRequest(request: Request, credential: WebhookCredential, options?: WebhookOptions): Promise<Response | null>;
-/**
- * Answer the challenge the gateway sends a verify URL before it will poll it,
- * which is how a caller shows the endpoint agreed to the traffic rather than
- * merely being named. Returns null for anything that is not a challenge, so a
- * verify endpoint hands the request on to its own reading of a payment.
- *
- * The nonce is echoed to whoever asked, which grants them nothing, so there is
- * no signature to check here and no secret to hold
- */
-declare function answerVerifyChallenge(body: string): string | null;
-/** {@link answerVerifyChallenge} against a `Request`, leaving its body unread */
-declare function answerVerifyChallengeRequest(request: Request): Promise<Response | null>;
-
-export { type BankTransfer, type BankTransferParams, type BankVerifyConfig, CreatePaymentParams, type Credit, type FioConfig, type GatewayCheatCode, GatewayCheatError, Gateways, type GatewaysOptions, IDEMPOTENCY_KEY_REUSED, type IdempotencyConflict, IdempotencyConflictError, type Invoice, type MedianOptions, NO_WALLET_AVAILABLE, NoWalletAvailableError, PAYMENT_ALREADY_WATCHED, Payment, ProblemError, type QrOptions, REQUEST_IN_FLIGHT, Settlement, type Statement, ThunderBridge, ThunderBridgeOptions, type Ticker, TriggerEvent, UnverifiedRecipientError, WaitOptions, WalletFailure, WatchPaymentParams, type WebhookCredential, type WebhookOptions, type WrapAllowance, type WrapRefusalCode, WrapRefusedError, answerVerifyChallenge, answerVerifyChallengeRequest, answerWebhookChallenge, answerWebhookChallengeRequest, bankTransfer, bankVerifyEndpoint, bitstamp, coinbase, coinmate, decodeInvoice, fioStatement, invoiceToDataUrl, invoiceToSvg, isProblemType, isProvablyPaid, isProvablySettled, kraken, lnurlToDataUrl, lnurlToSvg, medianOf, minorScaleOf, minorUnitsOf, msatFor, parseSettlement, parseSettlementRequest, parseWatchedWebhook, parseWatchedWebhookRequest, parseWebhook, parseWebhookRequest, preimageMatchesHash, proveOrigin, proveSettlement, proveWrapped, qrToDataUrl, qrToSvg, seal, spdToDataUrl, spdToSvg, unseal, verifyWebhookSignature, wrapFeeCeiling };
+export { Gateways, type GatewaysOptions, Handover, Held, type Invoice, Payment, ThunderBridge, ThunderBridgeOptions, WaitOptions, decodeInvoice, preimageMatchesHash, seal, unseal };