@bwalletx/connect 0.5.4 → 0.7.0

package/dist/choice-B97AjqF4.d.cts

@@ -0,0 +1,442 @@
+import { WalletInterface } from '@bsv/sdk';
+
+/** localStorage-shaped storage. Methods may be sync or async. */
+interface PairStorage {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+/** The minimum of the browser WebSocket API this package uses (the `ws` package also fits). */
+interface SocketLike {
+    readonly readyState: number;
+    onopen: ((ev: unknown) => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onerror: ((ev: unknown) => void) | null;
+    onclose: ((ev: unknown) => void) | null;
+    send(data: string): void;
+    close(): void;
+}
+type SocketFactory = (url: string) => SocketLike;
+interface PairConnectionOptions {
+    /** Where the pairing is kept so it survives a reload. Default: localStorage, else memory only. */
+    storage?: PairStorage | null;
+    /** Storage key. Default 'bwalletx.connect.pairing.v1'. */
+    storageKey?: string;
+    /** Opens a socket. Default: the global WebSocket. Pass one to run in Node or to test. */
+    socket?: SocketFactory;
+    /** Per-call timeout in ms. Default 120000. */
+    callTimeoutMs?: number;
+}
+interface PairingOptions extends PairConnectionOptions {
+    /** Show this link as a QR code, and as text to copy (web.bwalletx.com takes it pasted). */
+    onLink: (link: string) => void;
+    /** Show this 4-digit code. The wallet shows the same one; the user checks they match. */
+    onCode: (code: string) => void;
+    signal?: AbortSignal;
+    /** Relay host. Default relay.bwallet.space. */
+    relay?: string;
+    /** This page's origin, as the relay will see it. Default location.origin. */
+    origin?: string;
+}
+/** A BRC-100 wallet whose every call goes, end-to-end encrypted, to the paired phone or web wallet. */
+type PairedWallet = WalletInterface & {
+    /** Close the relay connection. The pairing stays stored; the next call reconnects. */
+    close(): void;
+    /** Tell the wallet to unpair, close, and delete the stored pairing. */
+    forget(): Promise<void>;
+};
+/**
+ * Pair with bWalletX on a phone (scan the QR) or web.bwalletx.com (paste the link).
+ * Resolves with a wallet once the user taps Connect. The pairing is stored (see `storage`) so
+ * `restorePairing()` can reconnect after a reload without a new QR.
+ */
+declare function pairBwalletX(opts: PairingOptions): Promise<PairedWallet>;
+/**
+ * The wallet from a pairing stored by an earlier `pairBwalletX`, or null if there is none.
+ * It connects on the first call. The wallet must still have this site paired.
+ */
+declare function restorePairing(opts?: PairConnectionOptions): Promise<PairedWallet | null>;
+/** Delete the stored pairing without telling the wallet. */
+declare function clearPairing(opts?: Pick<PairConnectionOptions, 'storage' | 'storageKey'>): Promise<void>;
+
+/**
+ * Browser-side payment helpers on top of the BRC-100 wallet's createAction. Works with any
+ * BRC-100 wallet. Each helper asks the wallet once; it never retries a spend. If a call fails
+ * the error says whether the wallet may have sent anything (`maybeSent`).
+ */
+
+/** BRC-29 payment protocol id. */
+declare const BRC29_PROTOCOL: [2, string];
+type PayTo = string;
+interface PayOutput {
+    /** Locking script hex. */
+    script: string;
+    satoshis: number;
+    description?: string;
+}
+interface PayRequest {
+    to: PayTo;
+    /** Amount in satoshis. Give this or `usd`. */
+    sats?: number;
+    /** Amount in US dollars, converted at `usdPerBsv` (or the live WhatsOnChain rate). */
+    usd?: number;
+    /** Shown in the wallet and, with `memoOnChain`, written in an OP_RETURN output. */
+    memo?: string;
+    memoOnChain?: boolean;
+    /** Labels for the wallet's history. */
+    labels?: string[];
+}
+interface PayOptions {
+    /** Fixed rate for `usd`. Otherwise fetched from WhatsOnChain. */
+    usdPerBsv?: number | (() => Promise<number>);
+    /** Resolve a paymail to outputs. Default: bsvalias P2P payment destination (needs CORS on the paymail host). */
+    resolvePaymail?: (paymail: string, sats: number) => Promise<{
+        outputs: PayOutput[];
+        reference?: string;
+        submit?: (rawTxHex: string) => Promise<void>;
+    }>;
+    fetch?: typeof fetch;
+}
+interface Brc29Remittance {
+    senderIdentityKey: string;
+    derivationPrefix: string;
+    derivationSuffix: string;
+    outputIndex: number;
+}
+interface PayResult {
+    txid: string;
+    /** Atomic BEEF (BRC-95) if the wallet returned it. Send it to your server's verifyPayment. */
+    tx?: number[];
+    sats: number;
+    outputs: PayOutput[];
+    /** For an identity-key payment: what the recipient needs to internalize the output (BRC-29). Deliver it to them. */
+    remittance?: Brc29Remittance;
+}
+type PaymentErrorCode = 'BAD_REQUEST' | 'RESOLVE_FAILED' | 'RATE_FAILED' | 'WALLET_REJECTED' | 'WALLET_ERROR' | 'NOT_SUPPORTED' | 'INSUFFICIENT_FUNDS';
+/** (0.7.0) The plain message for a wallet with no coins for the network fee (PaymentError code INSUFFICIENT_FUNDS). */
+declare const NO_COINS_TEXT = "Your wallet doesn't have enough to cover this payment and its small network fee. Add a little and try again.";
+/**
+ * True when createAction failed because the wallet has no coins (or too few) to fund it: the SDK's
+ * WERR_INSUFFICIENT_FUNDS (code 7, also as it arrives from Metanet Desktop over the JSON API), or a wallet's own
+ * "insufficient funds" text. Nothing was sent in that case.
+ */
+declare function isInsufficientFunds(e: unknown): boolean;
+declare class PaymentError extends Error {
+    readonly code: PaymentErrorCode;
+    /** true when the wallet was asked to spend and the outcome is unknown. Check before trying again. */
+    readonly maybeSent: boolean;
+    readonly cause?: unknown | undefined;
+    constructor(code: PaymentErrorCode, message: string, 
+    /** true when the wallet was asked to spend and the outcome is unknown. Check before trying again. */
+    maybeSent?: boolean, cause?: unknown | undefined);
+}
+/** A wallet that is not BRC-100 (the HandCash transitional adapter) can still pay through this. */
+interface LegacyPayer {
+    pay(req: PayRequest & {
+        sats: number;
+    }): Promise<PayResult>;
+}
+type PaySource = WalletInterface | LegacyPayer;
+declare const isIdentityKeyHex: (s: string) => boolean;
+declare const isPaymail: (s: string) => boolean;
+/** Satoshis for a request (sats as given, or usd converted, rounded up). */
+declare function amountInSats(req: Pick<PayRequest, 'sats' | 'usd'>, o?: PayOptions): Promise<number>;
+/** Default paymail resolver: bsvalias P2P Payment Destination (BRC-? / capability 2a40af698840). */
+declare function resolvePaymailP2P(paymail: string, sats: number, f?: typeof fetch): Promise<{
+    outputs: {
+        script: string;
+        satoshis: number;
+    }[];
+    reference: string | undefined;
+    submit: ((hex: string) => Promise<void>) | undefined;
+}>;
+/** Pay a paymail, address or identity key. One wallet prompt; never retried. */
+declare function pay(source: PaySource, req: PayRequest, o?: PayOptions): Promise<PayResult>;
+/** pay() labelled as a tip. */
+declare function tip(source: PaySource, req: PayRequest, o?: PayOptions): Promise<PayResult>;
+interface TokenQuote {
+    /** Outputs to fund, as your server priced them (e.g. payment to the seller + fee). */
+    outputs: PayOutput[];
+    description?: string;
+    /** Called with the result after the wallet signs; e.g. POST txid + tx to your server for verifyPayment. */
+    onPaid?: (r: PayResult) => Promise<void> | void;
+}
+interface BuyTokenRequest {
+    token: string;
+    amount: number | string;
+    /** The hook point: return the outputs for this purchase (usually from your server). */
+    quote: (req: {
+        token: string;
+        amount: number | string;
+    }) => Promise<TokenQuote>;
+    labels?: string[];
+}
+/** Buy a token: your `quote` hook prices it, the wallet pays once, `onPaid` delivers it. */
+declare function buyToken(source: PaySource, req: BuyTokenRequest): Promise<PayResult>;
+
+/**
+ * Every wallet the user could connect with, behind one interface. BRC-100 first: bWalletX, then any
+ * other wallet that announces itself (Yours, Metanet, ...), the in-app browser, optional localhost
+ * desktop wallets, phone pairing, and app-supplied adapters (e.g. the transitional HandCash one).
+ */
+
+type WalletKind = 'brc100' | 'pairing' | 'handcash' | 'custom';
+/**
+ * How a wallet reaches the page. 'extension' / 'in-app': bWalletX announced itself (its own rdns); 'xdm': the bWalletX
+ * app frame around the page; 'injected': another wallet that announced itself; 'window.CWI': something set window.CWI
+ * without announcing (it can't be told apart from any other wallet); 'json-api' / 'cicada': a desktop wallet on
+ * localhost (Metanet / BSV Desktop on 3321, Cicada on 3301); 'pairing': bWalletX on a phone over the relay;
+ * 'adapter': an app-supplied option (HandCash today).
+ */
+type Substrate = 'extension' | 'in-app' | 'xdm' | 'injected' | 'window.CWI' | 'json-api' | 'cicada' | 'pairing' | 'adapter';
+interface ConnectedWallet {
+    /** The BRC-100 wallet. null for a non-BRC-100 adapter (HandCash today). */
+    wallet: WalletInterface | null;
+    /** What pay/tip use: the BRC-100 wallet, or the adapter's own payer. */
+    payer: PaySource | null;
+    /** The identity public key (hex) when the wallet has one. */
+    identityKey: string | null;
+    handle?: string;
+    paymail?: string;
+    /** Which option connected. */
+    optionId: string;
+    kind: WalletKind;
+    /** True for adapters kept only until the vendor ships BRC-100. */
+    transitional?: boolean;
+}
+interface WalletOption {
+    id: string;
+    name: string;
+    icon?: string;
+    kind: WalletKind;
+    rdns?: string;
+    /** True for bWalletX (extension, in-app or paired). */
+    isBwalletX: boolean;
+    /** How it reaches the page (0.5.6). Options built by this package always set it. */
+    substrate?: Substrate;
+    /** The BRC-100 wallet behind a detected option (brc100 kind), when known before connecting. */
+    wallet?: WalletInterface;
+    /**
+     * Open the wallet. By default it also asks for the identity key (one wallet call). Pass `{ identity: false }` when
+     * you sign in straight after (BwalletXProvider does): the key then comes with the sign-in signature, in ONE sheet,
+     * and `identityKey` is null here.
+     */
+    connect(opts?: ConnectOptions): Promise<ConnectedWallet>;
+}
+interface ConnectOptions {
+    /** Ask for the identity key now. Default true. */
+    identity?: boolean;
+}
+/** Wrap any BRC-100 wallet as a picker option. */
+declare function brc100Option(wallet: WalletInterface, info: {
+    id: string;
+    name: string;
+    icon?: string;
+    rdns?: string;
+    isBwalletX?: boolean;
+    substrate?: Substrate;
+}): WalletOption;
+/** Phone / web.bwalletx.com pairing as an option (shows a QR through `pairing`). Reuses a stored pairing first. */
+declare function pairingOption(pairing: PairingOptions | (() => PairingOptions)): WalletOption;
+interface HandCashAdapterOptions {
+    /**
+     * Your existing HandCash Connect login (redirect/popup + your server route). Resolve with the
+     * profile once the user is signed in. This package does not import any HandCash SDK.
+     */
+    login(): Promise<{
+        handle: string;
+        paymail?: string;
+        identityKey?: string;
+    }>;
+    /** Your existing HandCash pay call (usually a server route using the auth token). Optional. */
+    pay?: Extract<PaySource, {
+        pay: unknown;
+    }>['pay'];
+    icon?: string;
+}
+/**
+ * TRANSITIONAL. Keeps existing HandCash users working behind the same picker until HandCash's
+ * BRC-100 support ships; then remove this and HandCash appears as an ordinary BRC-100 wallet.
+ */
+declare function handcashAdapter(o: HandCashAdapterOptions): WalletOption;
+interface DiscoverWalletsOptions {
+    /** Longest wait for BRC-100 announcements, ms. Default 300; ends early once a wallet has announced. */
+    ms?: number;
+    /**
+     * Also probe desktop wallets on localhost (Metanet / json-api on 3321, Cicada on 3301) while listing.
+     * Off by default, and best left off: Chrome asks for Local Network Access on the first probe. The chooser
+     * (chooseWallet) offers "Desktop wallet" instead, which probes only when the user taps it (desktopOption).
+     */
+    probeLocal?: boolean;
+    /** Add the phone pairing option (needs a way to show the QR, e.g. pairingModal()). */
+    pairing?: PairingOptions | (() => PairingOptions);
+    /** App-supplied options appended at the end (e.g. handcashAdapter(...)). */
+    extra?: WalletOption[];
+}
+/**
+ * True when window.CWI is a wallet that already announced itself, so the picker must not list it twice. bWalletX
+ * (extension and in-app) sets window.CWI to the very object it announces; the in-app browser is matched by rdns too.
+ */
+declare function cwiIsAnnounced(cwi: WalletInterface, announced: WalletOption[]): boolean;
+/** All wallets we can see, bWalletX first. SSR-safe: resolves [] (plus `extra`) outside a browser. */
+declare function discoverWallets(o?: DiscoverWalletsOptions): Promise<WalletOption[]>;
+/** Id of the "Desktop wallet" option (desktopOption). */
+declare const DESKTOP_OPTION_ID = "desktop";
+/**
+ * "Desktop wallet" (Metanet / BSV Desktop on localhost:3321, Cicada on 3301) as an option that looks for the wallet
+ * only when connect() runs, i.e. after the user picked it. Nothing touches localhost before that: the first request
+ * makes Chrome ask for Local Network Access, which must follow a tap, never a page load. connect() rejects with
+ * code NOT_FOUND when neither port answers within `ms`.
+ */
+declare function desktopOption(ms?: number): WalletOption;
+/**
+ * The 0.5.5 rule, kept for `fastPath: false` (0.5.6 sites use decideWallet, which never picks another wallet unasked).
+ * Which option to use without showing the picker, or undefined when the user has a real choice.
+ *   - nothing found → null;
+ *   - one option → it;
+ *   - exactly one wallet detected in this browser and no app-supplied option (HandCash, custom) → that wallet, with no
+ *     picker: phone pairing is a fallback for "no wallet here", not a second choice;
+ *   - only phone pairing → pairing.
+ * `force` (picker off): the first detected wallet, else the first non-pairing option, else pairing.
+ */
+declare function autoChoice(list: WalletOption[], force?: boolean): WalletOption | null | undefined;
+/**
+ * (0.7.0) A desktop wallet reached over localhost (json-api on 3321 = Metanet Desktop, Cicada on 3301): never picked
+ * by the button, the fast path or a remembered choice; only by its own tap ("Use Metanet Desktop…").
+ */
+declare function isLocalDesktop(w: Pick<WalletOption, 'id' | 'substrate'>): boolean;
+
+/** The wallet type every bWalletX (extension, in-app, app frame, phone) reports. */
+declare const BWALLETX_TYPE = "bwalletx";
+/** How the option reaches the page (WalletOption.substrate, inferred for options built elsewhere). */
+declare function substrateOf(o: WalletOption): Substrate;
+/** 'bwalletx' for any bWalletX; otherwise the wallet's rdns, else its option id ('desktop', 'window.CWI', 'handcash'). */
+declare function walletTypeOf(o: WalletOption): string;
+/**
+ * bWalletX found in this browser by its own marker (announcement or app frame). A wallet that only sits on
+ * window.CWI never counts, whatever it claims to be.
+ */
+declare function isPresentBwalletX(o: WalletOption): boolean;
+/** True when bWalletX itself is in this browser (not just phone pairing). */
+declare function hasBwalletX(list: readonly WalletOption[]): boolean;
+/** Wallets other than bWalletX that are actually in this browser (announced, window.CWI, or a probed desktop wallet). */
+declare function otherDetected(list: readonly WalletOption[]): WalletOption[];
+/** The chooser's order: bWalletX here, phone pairing, other detected wallets, app-supplied options last. */
+declare function chooserOrder(list: readonly WalletOption[]): WalletOption[];
+/**
+ * Why decideWallet chose what it did. 'requested': walletId; 'bwalletx': bWalletX is here (fast path);
+ * 'bwalletx-phone': picker off and no bWalletX here, so the phone; 'legacy': fastPath false (0.5.5 autoChoice);
+ * 'chooser': show the chooser; 'none': nothing to offer.
+ */
+type ChoiceReason = 'requested' | 'remembered' | 'bwalletx' | 'bwalletx-phone' | 'legacy' | 'chooser' | 'none';
+interface WalletChoice {
+    option: WalletOption | null;
+    reason: ChoiceReason;
+}
+interface DecideWalletOptions {
+    /** Use this option (an explicit choice the site already has). */
+    walletId?: string;
+    /** "Other wallets": the user asked for the chooser, so show it even with bWalletX here. */
+    chooser?: boolean;
+    /** false: never show the chooser (bWalletX, else the phone, else nothing; never another wallet). */
+    picker?: boolean;
+    /** The bWalletX-first rule. Default true; false restores the 0.5.5 behaviour (autoChoice). */
+    fastPath?: boolean;
+    /** (0.6.0) The wallet the user picked on this origin before (rememberedWalletChoice()). Used when it is here. */
+    remembered?: RememberedWallet | null;
+    /** (0.6.0) "Switch" to bWalletX: ignore a remembered other wallet. */
+    preferBwalletX?: boolean;
+}
+/** The wallet to connect now, or the chooser ({ option: null, reason: 'chooser' }). */
+declare function decideWallet(list: readonly WalletOption[], o?: DecideWalletOptions): WalletChoice;
+/** How a connect attempt ended. */
+type AttemptOutcome = 'signed-in' | 'connected' | 'cancelled' | 'rejected' | 'not-found' | 'error';
+/**
+ * One connect attempt, for your metrics. Deliberately nothing else: no identity key, address, paymail, handle,
+ * origin or error text. `walletType`/`substrate` are null when no wallet was chosen (chooser closed, nothing found).
+ */
+interface ConnectAttempt {
+    walletType: string | null;
+    substrate: Substrate | null;
+    outcome: AttemptOutcome;
+    /** From the tap to the outcome, rounded to whole ms. */
+    ms: number;
+}
+type AttemptHook = (attempt: ConnectAttempt) => void;
+/** The outcome for an error thrown by a connect attempt. */
+declare function outcomeOf(e: unknown): AttemptOutcome;
+/** Build the attempt record for `option` (or none). */
+declare function attemptFor(option: WalletOption | null | undefined, outcome: AttemptOutcome, startedAt: number, now?: number): ConnectAttempt;
+/** Call the hook with exactly the four fields; a throwing hook never breaks sign-in. */
+declare function reportAttempt(hook: AttemptHook | undefined, a: ConnectAttempt): void;
+/** localStorage key (per origin, like all localStorage) for the wallet type picked here. Never holds a key. */
+declare const WALLET_CHOICE_KEY = "bwx:wallet";
+/** What is remembered: the wallet type and how it reached the page. Nothing that identifies the user. */
+interface RememberedWallet {
+    type: string;
+    substrate: Substrate;
+}
+/**
+ * True when the same wallet can be found again next time: bWalletX, an announced wallet (by its rdns), a desktop
+ * wallet, an app adapter. A bare window.CWI cannot (whoever holds it next time may be another wallet), so it is
+ * never remembered.
+ */
+declare function isRememberable(o: WalletOption): boolean;
+/** Whether a successful connect counts as the user's explicit pick: bWalletX (they tapped its button), or chosen. */
+declare function isExplicitPick(o: WalletOption, reason: ChoiceReason): boolean;
+/** Remember the wallet type picked on this origin (or forget with null). Silently skips what can't be remembered. */
+declare function rememberWalletChoice(o: WalletOption | null): void;
+/** The wallet type picked on this origin before, or null. Anything malformed or key-like is ignored. */
+declare function rememberedWalletChoice(): RememberedWallet | null;
+/** Forget the remembered wallet (Disconnect does this). */
+declare function forgetWalletChoice(): void;
+/** True when this wallet type is not bWalletX: show "Some features need bWalletX · Switch". */
+declare function needsBwalletX(type: string | null | undefined): boolean;
+/**
+ * (0.7.0) True when the signed-out button's tap goes to this remembered wallet instead of bWalletX ("Continue with your
+ * wallet", the Switch note). Never for Metanet: the button never picks it (it has its own link and "Not you?").
+ */
+declare function tapGoesElsewhere(type: string | null | undefined): boolean;
+/** (0.7.0) A remembered desktop wallet on localhost (Metanet, 'desktop', json-api, cicada): never the button's pick. */
+declare function isLocalDesktopType(r: RememberedWallet): boolean;
+/**
+ * The option in `list` for a remembered wallet, or null when it isn't here. bWalletX counts only by its own marker
+ * (or the phone, when the phone was picked). A remembered desktop wallet on localhost (Metanet / 'desktop') gives null
+ * (0.7.0): the button never picks it; its own link does.
+ */
+declare function matchRemembered(list: readonly WalletOption[], r: RememberedWallet): WalletOption | null;
+/**
+ * What to do on page load for a returning visitor (0.6.0).
+ *   'attach'       signed in already (a server session) and the remembered wallet is in the page: pick it up by
+ *                  discovery alone (no wallet call, so no prompt) so pay/tip work without another tap;
+ *   'wait-for-tap' anything else a wallet would have to answer (a key, a signature, a localhost probe, a relay
+ *                  reconnect): nothing fires; the next tap goes straight to the remembered wallet;
+ *   'silent-metanet' (0.7.0) Metanet Desktop remembered, on a computer outside any frame: ONE silent attempt this page
+ *                  load (trySilentMetanet: 2 s, known identity keys only), else the normal choice;
+ *   'none'         nothing remembered, or auto-connect off (or Metanet remembered where it isn't offered).
+ */
+type AutoConnectAction = 'attach' | 'wait-for-tap' | 'silent-metanet' | 'none';
+interface AutoConnectPlan {
+    action: AutoConnectAction;
+    remembered: RememberedWallet | null;
+    /** The remembered wallet isn't bWalletX: show "Some features need bWalletX · Switch". */
+    needsBwalletX: boolean;
+}
+declare function planAutoConnect(o: {
+    remembered: RememberedWallet | null;
+    signedIn: boolean;
+    enabled?: boolean;
+    /** (0.7.0) Metanet is offered here (a computer, outside any frame). Default metanetOffered(). */
+    metanetHere?: boolean;
+}): AutoConnectPlan;
+/**
+ * Find the remembered wallet in the page by discovery alone: no wallet method is called, nothing touches localhost,
+ * no relay is opened. null when it isn't here (or it isn't something that can be attached silently).
+ */
+declare function attachRemembered(r: RememberedWallet, o?: {
+    ms?: number;
+}): Promise<WalletOption | null>;
+
+export { hasBwalletX as $, type AttemptHook as A, type BuyTokenRequest as B, type ConnectedWallet as C, DESKTOP_OPTION_ID as D, type SocketFactory as E, type SocketLike as F, WALLET_CHOICE_KEY as G, type HandCashAdapterOptions as H, type WalletChoice as I, type WalletKind as J, amountInSats as K, type LegacyPayer as L, attachRemembered as M, NO_COINS_TEXT as N, attemptFor as O, type PayRequest as P, buyToken as Q, type RememberedWallet as R, type Substrate as S, type TokenQuote as T, chooserOrder as U, clearPairing as V, type WalletOption as W, cwiIsAnnounced as X, decideWallet as Y, desktopOption as Z, forgetWalletChoice as _, type PayResult as a, isExplicitPick as a0, isIdentityKeyHex as a1, isInsufficientFunds as a2, isLocalDesktop as a3, isLocalDesktopType as a4, isPaymail as a5, isPresentBwalletX as a6, isRememberable as a7, matchRemembered as a8, needsBwalletX as a9, otherDetected as aa, outcomeOf as ab, pairBwalletX as ac, pay as ad, planAutoConnect as ae, rememberWalletChoice as af, rememberedWalletChoice as ag, reportAttempt as ah, resolvePaymailP2P as ai, restorePairing as aj, substrateOf as ak, tapGoesElsewhere as al, tip as am, walletTypeOf as an, type PayOptions as b, PaymentError as c, autoChoice as d, brc100Option as e, discoverWallets as f, type PairingOptions as g, handcashAdapter as h, type ChoiceReason as i, type AttemptOutcome as j, type AutoConnectAction as k, type AutoConnectPlan as l, BRC29_PROTOCOL as m, BWALLETX_TYPE as n, type Brc29Remittance as o, pairingOption as p, type ConnectAttempt as q, type ConnectOptions as r, type DecideWalletOptions as s, type DiscoverWalletsOptions as t, type PairConnectionOptions as u, type PairStorage as v, type PairedWallet as w, type PayOutput as x, type PaySource as y, type PaymentErrorCode as z };