thunder-bridge 1.5.0 → 2.1.1

package/dist/{client-Cc5gtjGV.d.ts → bank-M8flcMks.d.ts}

@@ -1,12 +1,12 @@
 import { R as Resolved, Q as QrOptions } from './qr-CF-YeXU1.js';
-import { A as Amount, T as Ticker, C as Charge, e as MintedPayment, g as PaymentStatus, h as Priced, f as Msat, S as Settlement, P as Payment, Q as Quote, H as Handover, i as SocketTicket } from './types-BNPmVnA7.js';
-import { a as BankTransferParams, B as BankTransfer, b as BankVerifyConfig } from './bank-B3mHISn1.js';
+import { A as Amount, T as Ticker, C as Charge, f as MintedPayment, h as PaymentStatus, i as Priced, g as Msat, S as Settlement, P as Payment, Q as Quote, e as Held, H as Handover, j as SocketTicket } from './types-DYZ9EkmJ.js';
 
 type Sent = {
     method?: string;
     headers?: Record<string, string>;
     body?: string;
     deadline?: AbortSignal;
+    staysOnOrigin?: boolean;
 };
 type Verified = {
     address: string;
@@ -26,8 +26,9 @@ interface Order {
 }
 /** One way to pay one order, already registered with the gateway */
 interface Leg {
-    /** The watched payment's id, which is what `firstSettled`, `payment` and `settled` take */
+    /** The watched payment's id, which with `paymentHash` is what `firstSettled`, `payment` and `settled` take */
     id: string;
+    paymentHash: 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 */
@@ -69,10 +70,13 @@ interface LightningRailConfig extends RailConfig {
 /** The same rail with the invoice resolved here, so the gateway is told neither address nor amount */
 interface BlindLightningRailConfig extends LightningRailConfig {
     /**
-     * What the watcher needs and the gateway must not read, sealed with `seal`
-     * before it goes anywhere near the gateway
+     * What the watcher needs and the gateway must not read, sealed under `secret`
+     * for the invoice's payment hash before it goes anywhere near the gateway
      */
-    sealed?: (order: Order) => string | Promise<string>;
+    sealed?: {
+        secret: string;
+        data: (order: Order) => unknown;
+    };
     /**
      * Where your own `serve.verify` endpoint is mounted, and its secret. Without
      * it the gateway is handed the wallet's own URL, which a gateway enforcing its
@@ -96,12 +100,15 @@ interface BankRailConfig extends RailConfig {
     /** When this leg stops being payable, in unix seconds */
     expiresAt: (order: Order) => number;
     /** Sealed before the gateway sees it, the way the blind Lightning rail does */
-    sealed?: (order: Order) => string | Promise<string>;
+    sealed?: {
+        secret: string;
+        data: (order: Order) => unknown;
+    };
     /** The Czech variable symbol, taken off the reference's digits by default */
     variableSymbol?: (order: Order) => string | undefined;
     /**
-     * Register on a gateway you do not own anyway. The verify URL names the amount
-     * and the reference, so its operator could read your order book off the watches
+     * Register on a gateway you do not own anyway. The sealed verify URL names
+     * nothing about the order, but its operator still learns every watch you place
      */
     allowPublicGateway?: boolean;
 }
@@ -180,7 +187,7 @@ interface PaymentRequest {
      * unpaid or the wait is aborted. It follows a WebSocket and reconnects through
      * a drop, so this is one await rather than a poll.
      *
-     * `gateway.settled(id)` is the wider question and ends on an expiry too. This
+     * `gateway.settled(payment)` is the wider question and ends on an expiry too. This
      * one is about the payment that was asked for, and one that expired was never paid
      */
     paid(options?: WaitOptions): Promise<MintedPayment>;
@@ -335,7 +342,7 @@ interface WrapAllowance {
  * Throws `GatewayCheatError` when a check fails and `UnverifiedRecipientError`
  * when the recipient could not be reached to run one
  */
-declare function proveOrigin(payment: MintedPayment, asked: Priced): Promise<void>;
+declare function proveOrigin(payment: MintedPayment, asked: Priced, askedAt?: number): 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
@@ -429,9 +436,9 @@ interface WebhookHandlers {
      */
     onSettled?: (settlement: Proven<Settlement>) => void | Promise<void>;
     /**
-     * A delivery that carries no proof, so an expiry or a paid claim with no
-     * preimage behind it. Left unset, the handler answers `202` and does nothing,
-     * because acting on an unproven claim is the one thing this refuses to do
+     * A delivery that carries no proof, so an expiry. Left unset, the handler
+     * answers `202` and does nothing, because acting on an unproven claim is the
+     * one thing this refuses to do
      */
     onUnproven?: (settlement: Settlement) => void | Promise<void>;
     /** A whole payment rather than a settlement, which is what an older gateway posts */
@@ -492,14 +499,8 @@ declare class Serve {
     private credential;
 }
 
-/** How this instance talks to one gateway, and how much of what it says to check */
+/** How this instance talks to one gateway */
 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
@@ -521,7 +522,7 @@ interface WaitOptions {
     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,
+     * payment id. Implied by `token` and by `secret`. The id stays readable inside the ticket,
      * what changes is that a URL out of a log stops opening anything after a
      * minute
      */
@@ -584,17 +585,32 @@ interface FollowOptions {
     /**
      * 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
+     * of a POST before each connect. Implied by `token` and by `secret`. Leave it off for a
      * microcontroller, where one hardcoded URL and a dumb reconnect loop is the
      * whole point
      */
     tickets?: boolean;
 }
+/** How this caller holds a socket open and what it answers on it */
+interface AttendOptions {
+    /**
+     * What this caller answers when the gateway asks about one of its payments.
+     * The preimage when the money is there, null while it is not, and the gateway
+     * checks the preimage against the hash either way
+     */
+    answer: (paymentHash: string) => Promise<string | null> | string | null;
+    /** Called when a connection drops or a frame is refused, the socket keeps going */
+    onError?: (error: unknown) => void;
+    /** Reconnect after a drop, defaults to true */
+    reconnect?: boolean;
+    /** The first wait after a drop, doubling and jittered, defaults to 3000 */
+    reconnectDelayMs?: number;
+}
 /** 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 handedOut;
     private readonly secret;
     private strangers;
     private speaks;
@@ -651,7 +667,7 @@ declare class ThunderBridge {
      * for both sorts: `kind` says whether the gateway minted it or was handed it,
      * and the address, amount and invoice are null on one it was never told
      */
-    payment(id: string): Promise<Payment | null>;
+    payment(held: Held): Promise<Payment | 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
@@ -671,7 +687,7 @@ declare class ThunderBridge {
      * one that has answered is followed until its own expiry, so the wait always
      * ends by itself
      */
-    settled(id: string, options?: WaitOptions): Promise<Payment>;
+    settled(held: Held, options?: WaitOptions): Promise<Payment>;
     private followed;
     /**
      * Wait on several payments and keep the first one that is really paid, then stop
@@ -691,7 +707,7 @@ declare class ThunderBridge {
      * really does pay twice and that shows up on `follow` as a second settlement to
      * refund.
      */
-    firstSettled(ids: string[], options?: WaitOptions): Promise<Payment | null>;
+    firstSettled(held: Held[], options?: WaitOptions): Promise<Payment | 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
@@ -707,6 +723,12 @@ declare class ThunderBridge {
      * because then the gateway names the payment and only it can
      */
     nameFor(paymentHash: string): Promise<string | null>;
+    /**
+     * Hold a socket open and answer what the gateway asks about this caller's own
+     * payments, so a watch addressed to this caller settles without anybody
+     * hosting a URL. Reconnects on its own until the returned function is called
+     */
+    attend(options: AttendOptions): () => void;
     /**
      * 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
@@ -727,7 +749,148 @@ declare class ThunderBridge {
     private sending;
     private reading;
     private speaking;
+    private handOut;
     private proven;
 }
 
-export { relayedVerifyUrl as A, type BankRailConfig as B, type CreateOptions as C, wrapFeeCeiling as D, type FollowOptions as F, type Handler as H, type Leg as L, type Minted as M, type Order as O, type PaymentRequest as P, type RailConfig as R, type Send as S, ThunderBridge as T, type WaitOptions as W, type Rail as a, type ThunderBridgeOptions as b, type BlindLightningRailConfig as c, type LightningRailConfig as d, type LightningVerifyConfig as e, type PaymentRequestInit as f, type PaymentRequestOptions as g, type Provable as h, type Proven as i, Rails as j, type Range as k, type Relayed as l, Serve as m, type TicketOptions as n, type TriggerConfig as o, type WatchTicketConfig as p, type WebhookCredential as q, type WebhookHandlers as r, type WebhookOptions as s, type WrapAllowance as t, answerVerifyChallenge as u, carriesProof as v, invoiceFrom as w, proveOrigin as x, proveSettlement as y, proveWrapped as z };
+/** 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 whole word, 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[]>;
+/** One transfer to ask for: what is owed, where it lands, and where its arrival is read back from */
+interface BankTransferParams {
+    /**
+     * Long lived and server side, at least 32 characters. The preimage is derived
+     * from it and the verify query is sealed with 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. Not needed when `answerBy` is "agent", because then nothing is polled
+     */
+    verifyUrl?: string;
+    /**
+     * How the gateway gets its answer. "poll" hands it a URL it fetches, which
+     * needs a public host. "agent" hands it this caller's name instead, and the
+     * socket `bankAgent` holds open answers for it, which needs no host at all
+     */
+    answerBy?: "poll" | "agent";
+    /** 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 on that stream, so a watcher learns which order settled without
+     * asking anyone. It is sealed under `secret` for this transfer's payment hash,
+     * so the gateway can neither read it nor move it onto another payment
+     */
+    sealed?: {
+        secret: string;
+        data: unknown;
+    };
+    /**
+     * 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 sealed verify URL tells its
+     * operator nothing about the order, but the URL itself still answers whether
+     * that order was paid. Say true only when that much is not worth hiding
+     */
+    allowPublicGateway?: boolean;
+}
+/** A transfer the gateway is now watching, and the descriptor the payer scans */
+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;
+}
+/** The endpoint the gateway polls for a bank transfer, answering off your own statement */
+interface BankVerifyConfig {
+    /** The same secret `bankTransfer` was given */
+    secret: string;
+    /** The IBAN this endpoint answers for, refusing a question sealed for another account */
+    iban: 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;
+}
+/** One order this caller is waiting on, and the account it is waiting on it in */
+interface BankOrder {
+    iban: string;
+    reference: string;
+    amountMinor: number;
+    currency?: string;
+    expiresAt: number;
+    statement: Statement;
+}
+/** What a caller needs to answer for its own transfers over a socket */
+interface BankAgentConfig {
+    /** The gateway holding the watches this caller raised */
+    gateway: ThunderBridge;
+    /** The same secret `bankTransfer` was given, never leaving this device */
+    secret: string;
+    /** What the payment the gateway is asking about was asking for, or null when it is none of ours */
+    orders: (paymentHash: string) => Promise<BankOrder | null> | BankOrder | null;
+    /** How far back a credit still counts, seven days by default */
+    lookBackSecs?: number;
+    /** Called when a connection drops or a frame is refused, the socket keeps going */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Answer the gateway over a socket this device opens, so a transfer addressed to
+ * this caller settles from a till behind NAT, a browser tab or a phone. The
+ * preimage is derived here from the secret, so the gateway is told only that one
+ * exists and can check it against the hash it already holds.
+ *
+ * Call the returned function to stop attending. Whatever is still open is asked
+ * again on the gateway's own schedule, so leaving and coming back loses nothing
+ */
+declare function bankAgent(config: BankAgentConfig): () => void;
+
+export { type AttendOptions as A, type BankAgentConfig as B, type Credit as C, type WebhookOptions as D, type WrapAllowance as E, type FollowOptions as F, answerVerifyChallenge as G, type Handler as H, carriesProof as I, invoiceFrom as J, proveOrigin as K, type Leg as L, type Minted as M, proveSettlement as N, type Order as O, type PaymentRequest as P, proveWrapped as Q, type RailConfig as R, type Statement as S, ThunderBridge as T, relayedVerifyUrl as U, wrapFeeCeiling as V, type WaitOptions as W, type BankOrder as a, type BankTransfer as b, type BankTransferParams as c, type BankVerifyConfig as d, bankAgent as e, type Rail as f, type ThunderBridgeOptions as g, type BankRailConfig as h, type BlindLightningRailConfig as i, type CreateOptions as j, type LightningRailConfig as k, type LightningVerifyConfig as l, type PaymentRequestInit as m, type PaymentRequestOptions as n, type Provable as o, type Proven as p, Rails as q, type Range as r, type Relayed as s, type Send as t, Serve as u, type TicketOptions as v, type TriggerConfig as w, type WatchTicketConfig as x, type WebhookCredential as y, type WebhookHandlers as z };

package/dist/bank.cjs

@@ -20,10 +20,206 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/entry/bank.ts
 var bank_exports = {};
 __export(bank_exports, {
+  bankAgent: () => bankAgent,
   fioStatement: () => fioStatement
 });
 module.exports = __toCommonJS(bank_exports);
 
+// ../core/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length >> 1);
+  for (let at = 0; at < bytes.length; at++) {
+    bytes[at] = parseInt(hex.slice(at * 2, at * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+// ../core/ed25519.ts
+var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
+var SMALL_ORDER = [
+  "00".repeat(32),
+  `01${"00".repeat(31)}`,
+  "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05",
+  "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a",
+  `ec${"ff".repeat(30)}7f`,
+  `ed${"ff".repeat(30)}7f`,
+  `ee${"ff".repeat(30)}7f`
+];
+
+// ../core/hmac.ts
+async function hmacHex(secret, payload) {
+  const raw = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    asBuffer(raw),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const message = typeof payload === "string" ? new TextEncoder().encode(payload) : payload;
+  return bytesToHex(new Uint8Array(await crypto.subtle.sign("HMAC", key, asBuffer(message))));
+}
+function asBuffer(bytes) {
+  return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+}
+
+// ../core/sha256.ts
+var ROUND_CONSTANTS = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../core/sealed.ts
+var MIN_SECRET_CHARS = 32;
+var INFO = new TextEncoder().encode("thunder-bridge/sealed");
+function refuseAWeakSecret(secret) {
+  if (secret.length < MIN_SECRET_CHARS) {
+    throw new Error(`the sealing secret needs ${MIN_SECRET_CHARS} characters of randomness`);
+  }
+}
+
+// src/bank.ts
+var DEFAULT_CURRENCY = "CZK";
+var DEFAULT_LOOK_BACK_SECS = 7 * 24 * 60 * 60;
+function bankAgent(config) {
+  refuseAWeakSecret(config.secret);
+  return config.gateway.attend({
+    onError: config.onError,
+    answer: async (paymentHash) => {
+      const order = await config.orders(paymentHash);
+      if (order === null) {
+        return null;
+      }
+      const currency = order.currency ?? DEFAULT_CURRENCY;
+      return await creditedPreimage({
+        secret: config.secret,
+        asked: {
+          iban: accountOf(order.iban),
+          reference: order.reference,
+          amountMinor: order.amountMinor,
+          currency,
+          expiresAt: order.expiresAt
+        },
+        statement: order.statement,
+        lookBackSecs: config.lookBackSecs
+      });
+    }
+  });
+}
+async function creditedPreimage(params) {
+  const since = unixNow() - (params.lookBackSecs ?? DEFAULT_LOOK_BACK_SECS);
+  const landed = (await params.statement(since)).some((credit) => pays(credit, params.asked));
+  if (!landed) {
+    return null;
+  }
+  return await hmacHex(params.secret, `preimage|${subjectOf(params.asked)}`);
+}
+function pays(credit, asked) {
+  return credit.amountMinor === asked.amountMinor && credit.currency.toUpperCase() === asked.currency.toUpperCase() && namesOnly(credit.reference, asked.reference);
+}
+function namesOnly(written, reference) {
+  const wanted = reference.toUpperCase();
+  const alike = [...written.toUpperCase().matchAll(wordsShapedLike(wanted))].map(([word]) => word);
+  return alike.includes(wanted) && (!/\d/.test(wanted) || alike.every((word) => word === wanted));
+}
+function wordsShapedLike(reference) {
+  const shape = [...reference].map((char) => {
+    if (/\d/.test(char)) {
+      return "\\d";
+    }
+    return /\p{L}/u.test(char) ? "\\p{L}" : char.replace(/[\^$\\.*+?()[\]{}|/]/g, "\\$&");
+  }).join("");
+  return new RegExp(`(?<![\\p{L}\\p{N}])${shape}(?![\\p{L}\\p{N}])`, "gu");
+}
+function subjectOf({ iban, amountMinor, currency, expiresAt, reference }) {
+  return `${iban}|${amountMinor}|${currency.toUpperCase()}|${expiresAt}|${reference}`;
+}
+function accountOf(iban) {
+  return iban.replace(/\s+/g, "").toUpperCase();
+}
+function unixNow() {
+  return Math.floor(Date.now() / 1e3);
+}
+
 // src/fio.ts
 var BASE_URL = "https://fioapi.fio.cz/v1/rest";
 var MINOR_UNITS = 100;
@@ -137,5 +333,6 @@ function asDate(unix) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  bankAgent,
   fioStatement
 });

package/dist/bank.d.cts

@@ -1,5 +1,7 @@
-import { S as Statement } from './bank-B3mHISn1.cjs';
-export { B as BankTransfer, a as BankTransferParams, b as BankVerifyConfig, C as Credit } from './bank-B3mHISn1.cjs';
+import { S as Statement } from './bank-CEIuNhV_.cjs';
+export { B as BankAgentConfig, a as BankOrder, b as BankTransfer, c as BankTransferParams, d as BankVerifyConfig, C as Credit, e as bankAgent } from './bank-CEIuNhV_.cjs';
+import './qr-CF-YeXU1.cjs';
+import './types-DYZ9EkmJ.cjs';
 
 /** A Fio account to read credits from, as its own API describes one */
 interface FioConfig {

package/dist/bank.d.ts

@@ -1,5 +1,7 @@
-import { S as Statement } from './bank-B3mHISn1.js';
-export { B as BankTransfer, a as BankTransferParams, b as BankVerifyConfig, C as Credit } from './bank-B3mHISn1.js';
+import { S as Statement } from './bank-M8flcMks.js';
+export { B as BankAgentConfig, a as BankOrder, b as BankTransfer, c as BankTransferParams, d as BankVerifyConfig, C as Credit, e as bankAgent } from './bank-M8flcMks.js';
+import './qr-CF-YeXU1.js';
+import './types-DYZ9EkmJ.js';
 
 /** A Fio account to read credits from, as its own API describes one */
 interface FioConfig {