@bwalletx/connect 0.5.4 → 0.7.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { WalletInterface, WalletProtocol } from '@bsv/sdk';
-import { f as PairingOptions, W as WalletOption } from './wallets-CbzMtxrf.js';
-export { g as BRC29_PROTOCOL, i as Brc29Remittance, B as BuyTokenRequest, C as ConnectedWallet, D as DiscoverWalletsOptions, H as HandCashAdapterOptions, L as LegacyPayer, j as PairConnectionOptions, k as PairStorage, l as PairedWallet, b as PayOptions, m as PayOutput, P as PayRequest, a as PayResult, n as PaySource, c as PaymentError, o as PaymentErrorCode, S as SocketFactory, q as SocketLike, T as TokenQuote, r as WalletKind, s as amountInSats, d as brc100Option, t as buyToken, u as clearPairing, e as discoverWallets, h as handcashAdapter, v as isIdentityKeyHex, w as isPaymail, x as pairBwalletX, p as pairingOption, y as pay, z as resolvePaymailP2P, A as restorePairing, E as tip } from './wallets-CbzMtxrf.js';
-export { AuthorizeParams, GET_URL, SIGNIN_CSS, SIGNIN_TAG, SigninBrand, SigninLabel, SigninSize, SigninTheme, WEB_WALLET_URL, buildAuthorizeUrl, defineBwalletxSignin, markSvg, signinText } from './element.js';
+import { g as PairingOptions, W as WalletOption, R as RememberedWallet, A as AttemptHook, C as ConnectedWallet, S as Substrate, i as ChoiceReason } from './choice-B97AjqF4.js';
+export { j as AttemptOutcome, k as AutoConnectAction, l as AutoConnectPlan, m as BRC29_PROTOCOL, n as BWALLETX_TYPE, o as Brc29Remittance, B as BuyTokenRequest, q as ConnectAttempt, r as ConnectOptions, D as DESKTOP_OPTION_ID, s as DecideWalletOptions, t as DiscoverWalletsOptions, H as HandCashAdapterOptions, L as LegacyPayer, N as NO_COINS_TEXT, u as PairConnectionOptions, v as PairStorage, w as PairedWallet, b as PayOptions, x as PayOutput, P as PayRequest, a as PayResult, y as PaySource, c as PaymentError, z as PaymentErrorCode, E as SocketFactory, F as SocketLike, T as TokenQuote, G as WALLET_CHOICE_KEY, I as WalletChoice, J as WalletKind, K as amountInSats, M as attachRemembered, O as attemptFor, d as autoChoice, e as brc100Option, Q as buyToken, U as chooserOrder, V as clearPairing, X as cwiIsAnnounced, Y as decideWallet, Z as desktopOption, f as discoverWallets, _ as forgetWalletChoice, h as handcashAdapter, $ as hasBwalletX, a0 as isExplicitPick, a1 as isIdentityKeyHex, a2 as isInsufficientFunds, a3 as isLocalDesktop, a4 as isLocalDesktopType, a5 as isPaymail, a6 as isPresentBwalletX, a7 as isRememberable, a8 as matchRemembered, a9 as needsBwalletX, aa as otherDetected, ab as outcomeOf, ac as pairBwalletX, p as pairingOption, ad as pay, ae as planAutoConnect, af as rememberWalletChoice, ag as rememberedWalletChoice, ah as reportAttempt, ai as resolvePaymailP2P, aj as restorePairing, ak as substrateOf, al as tapGoesElsewhere, am as tip, an as walletTypeOf } from './choice-B97AjqF4.js';
+export { A as AuthorizeParams, C as CONTINUE_OTHER_LABEL, G as GET_URL, M as MENU_CSS, P as PENDING_LABEL, e as PENDING_LABEL_OTHER, f as PENDING_NOTE, g as SIGNIN_CSS, h as SIGNIN_TAG, i as SWITCH_NOTE, j as SigninAccount, c as SigninBrand, b as SigninLabel, k as SigninMode, S as SigninSize, d as SigninState, a as SigninTheme, W as WEB_WALLET_URL, l as buildAuthorizeUrl, m as defineBwalletxSignin, n as markSvg, s as signinText } from './element-BXEoOdXY.js';
+export { BUTTON_TAG, ButtonState, CONNECTED_KEY, defineBwalletxButton, dropLegacyConnectedKey, getUrlFor, handleLabel, migrateConnectedKey, stateFor } from './element.js';
 import { b as AccessResponse, H as HoldingProof, A as AccessError } from './access-Dp0eKIOc.js';
 export { f as ACCESS_ERROR_STATUS, d as ACCESS_PROTOCOL, g as ACCESS_VERSION, h as AccessChallenge, i as AccessErrorBody, j as AccessErrorCode, c as AccessKind, a as AccessRequirement, P as PROTOCOL_MEDIA, T as TokenRequirement, k as accessErrorMessage, m as canonicalJson, r as protocolMediaUrl } from './access-Dp0eKIOc.js';
 
@@ -17,16 +18,21 @@ interface FoundWallet {
     rdns: string | null;
 }
 /**
- * Default wait for a wallet that has not answered yet, ms. bWalletX for Chrome answers `brc100:requestWallet`
- * synchronously and the in-app browser sets `window.CWI` before the page runs, so a found wallet resolves at once;
+ * Default wait for a wallet that has not answered yet, ms. bWalletX for Chrome and the in-app browser both answer
+ * `brc100:requestWallet` synchronously, so a found wallet resolves at once;
  * this is only how long "nothing here" takes before the pairing QR shows. Was 1200 (0.5.3 and earlier).
  */
 declare const DEFAULT_DISCOVER_MS = 300;
 /**
  * Like findBwalletX, but also says which bWalletX answered.
- * Order: a BRC-100 announcement with a bWalletX rdns (answered at once by the extension); then `window.CWI` (set by
- * the in-app browser, and by older builds that do not announce), taken straight away; then, only when framed, the
- * parent's XDM answer (probed in parallel with the wait). Otherwise null after `ms`.
+ *
+ * bWalletX is recognised ONLY by its own markers: a BRC-100 announcement carrying a bWalletX rdns
+ * (`com.bwalletx.extension` from the Chrome extension, `space.bwallet.mobile` from the in-app browser; both answer
+ * `brc100:requestWallet` at once), or, only when framed, the XDM answer of a parent on BWALLETX_PARENT_ORIGINS.
+ *
+ * Never by `window.CWI` (0.5.6): another wallet (Metanet / BSV Desktop, Yours) can set or overwrite it, and treating
+ * whoever holds it as bWalletX handed our sign-in to that wallet. Every bWalletX build since 3 Oct 2026 announces.
+ * Resolves null after `ms` when no bWalletX announced (other wallets: discoverWallets).
  */
 declare function discoverBwalletX(ms?: number): Promise<FoundWallet | null>;
 /**
@@ -34,6 +40,8 @@ declare function discoverBwalletX(ms?: number): Promise<FoundWallet | null>;
  * open in bWalletX's in-app browser. Resolves null if nothing answered within `ms`.
  */
 declare function findBwalletX(ms?: number): Promise<WalletInterface | null>;
+/** True inside a frame (or when the parent can't be read). */
+declare const isFramed: () => boolean;
 /**
  * Wake the wallet before the click (call on pointerenter / focus / touchstart of your Connect button). Chrome stops an
  * idle extension worker after ~30 s, and a cold worker needs 1-3 s to reopen the wallet; this sends a liveness call
@@ -57,12 +65,32 @@ type SignInMethod = 'extension' | 'in-app' | 'pairing' | 'wallet';
 /**
  * Progress for the button label. 'finding': looking for a wallet (sub-second); 'opening': a wallet was found and its
  * approval is on the way ("Opening your wallet…"); 'pairing': no wallet in this browser, the QR is showing;
- * 'signing': the identity key arrived, the sign-in signature is being asked for.
+ * 'signing': the challenge arrived, the wallet's sign-in approval is being asked for.
  */
 type SignInStatus = 'finding' | 'opening' | 'pairing' | 'signing';
 interface SignInOptions {
-    /** Ask your server for a challenge for this identity key. */
-    challenge: (identityKey: string) => Promise<Challenge>;
+    /**
+     * Ask your server for a challenge. Since 0.5.5 it is called BEFORE the wallet is asked anything, and gets an identity
+     * key only when you pass `identityKey` (an identity you already connected) or set `challengeNeedsIdentityKey`;
+     * otherwise undefined. The 0.5.5 server helpers (createChallenge) accept no key, and verifySignIn binds the key the
+     * browser then claims to the signature. A pre-0.5.5 server that refuses a keyless challenge is detected and retried
+     * in the old order automatically.
+     */
+    challenge(identityKey?: string): Promise<Challenge>;
+    /**
+     * The identity key you already have from an earlier connect (reuse the connected identity): the wallet is then asked
+     * for the signature only. Without it, getPublicKey({ identityKey: true }) and createSignature go to the wallet
+     * together (Promise.all), so the wallet shows ONE sheet, not three.
+     */
+    identityKey?: string;
+    /**
+     * Servers older than 0.5.5 refuse a challenge without an identity key. Set true to use the old order straight away
+     * (identity key, then the challenge, then the signature: two wallet calls). Without it, the old order is used only
+     * after such a server has refused a keyless challenge.
+     */
+    challengeNeedsIdentityKey?: boolean;
+    /** Skip waitForAuthentication before signing (the provider already waited). Default false. */
+    skipWaitForAuthentication?: boolean;
     /** Use this wallet instead of looking for one. `method` is then 'wallet'. */
     wallet?: WalletInterface;
     /** How to show the QR and code if pairing is needed. Without it, pairing is not tried. */
@@ -89,10 +117,41 @@ declare function connectBwalletX(opts?: Pick<SignInOptions, 'wallet' | 'pairing'
     method: SignInMethod;
 }>;
 /**
- * Sign the server's challenge with the user's bWalletX identity key. Post the result's
- * identityKey, nonce and signature to your verify route.
+ * Wait for the user to unlock only when the wallet says it is locked. isAuthenticated never shows anything; an
+ * unconditional waitForAuthentication is not free: bWalletX answers it by fetching the site's manifest.json and, when
+ * that asks for permissions, shows a separate sheet, once per call.
+ */
+declare function waitIfLocked(wallet: WalletInterface): Promise<void>;
+/**
+ * True when a server refused a challenge because it wanted an identity key (createChallenge before 0.5.5 answers 400
+ * "identityKey must be a compressed public key (66 hex chars)").
+ */
+declare function challengeWantsIdentityKey(e: unknown): boolean;
+/**
+ * Sign the server's challenge with the user's bWalletX identity key. Post the result's identityKey, nonce and
+ * signature to your verify route.
+ *
+ * Wallet calls, in order:
+ *   1. the challenge comes from your server first (no wallet call);
+ *   2. getPublicKey({ identityKey: true }) and createSignature go to the wallet TOGETHER, so the wallet merges them
+ *      into one approval. With `identityKey` (already connected) only createSignature is asked for.
  */
 declare function signInWithBwalletX(opts: SignInOptions): Promise<SignInResult>;
+interface SignInAndVerifyOptions extends SignInOptions {
+    /** POST the result to your verify route; resolve with its JSON. A 401 (status on the error) means "sign-in failed". */
+    verify: (r: SignInResult) => Promise<Record<string, unknown>>;
+    /**
+     * A remembered identity key (rememberedIdentity()). Used like `identityKey` (one wallet call: the signature only),
+     * but if the server rejects the signature (another account is active now), it is dropped and the sign-in is retried
+     * with the key asked for.
+     */
+    identityKeyHint?: string;
+}
+/** signInWithBwalletX + your verify route, with the identity-hint fallback. */
+declare function signInAndVerify(opts: SignInAndVerifyOptions): Promise<{
+    result: SignInResult;
+    verified: Record<string, unknown>;
+}>;
 /** Where a sign-in failed: the wallet's identity prompt, the site's challenge endpoint, or the wallet's signature. */
 type SignInStage = 'identity' | 'challenge' | 'signature' | 'verify';
 
@@ -115,8 +174,39 @@ declare function renderButton(el: HTMLElement | string, opts?: ButtonOptions): H
  */
 declare function inOrder<T>(handle: (frame: T) => Promise<void> | void, onError?: (e: unknown) => void): (frame: T) => Promise<void>;
 
-/** An SVG QR code for `text` (error correction M). */
-declare function qrSvg(text: string): string;
+/**
+ * The signed-in account as the badge shows it: paymail (best-effort lookup by identity key), a $handle label, a short
+ * key when there is no paymail, and the bAvatar picture (gold by default, generated for any key).
+ */
+declare const PAYMAIL_LOOKUP_URL = "https://pay.bwallet.space/api/paymail/lookup?key=";
+declare const BAVATAR_URL = "https://chat.bwalletx.com/api/bavatar/";
+/** 0266c1…7c83 */
+declare function shortKey(key: string): string;
+/** $alice for alice@bwalletx.com, a site handle as given, other paymails in full, else a short key. */
+declare function accountLabel(a: {
+    identityKey?: string | null;
+    paymail?: string | null;
+    handle?: string | null;
+}): string;
+/** The bAvatar for an identity key (a generated gold avatar when the user has not set one). */
+declare function avatarUrlFor(identityKey: string | null | undefined): string | null;
+/** The paymail for an identity key, or null. Best effort: never throws, one request per key per page. */
+declare function lookupPaymail(identityKey: string, url?: string): Promise<string | null>;
+/** True when the user said no in the wallet (BRC-100 denial, or a picker / sheet closed). */
+declare function isUserRejection(e: unknown): boolean;
+/** One plain line for an error: "Sign-in cancelled" for a no in the wallet, otherwise the gist. */
+declare function signInErrorText(e: unknown): string;
+/** localStorage key for the identity key that last signed in on this site (public data; a hint, never trusted). */
+declare const IDENTITY_HINT_KEY = "bwx:identityKey";
+/**
+ * The identity key that last signed in on this site, if any. Passing it to signInWithBwalletX makes a repeat sign-in
+ * ONE wallet call (createSignature only). It is only a hint: the server still checks the signature against it, and a
+ * wrong hint (another account) fails verification and is retried with the key asked for.
+ */
+declare function rememberedIdentity(): string | undefined;
+declare function rememberIdentity(key: string | null): void;
+
+/** Device checks shared by the modal and the Metanet Desktop option (no DOM created here). */
 /**
  * True on a phone or tablet: a coarse pointer with no hover, or a mobile user agent (iPadOS reports
  * a Mac UA, so touch points count too). Scanning a QR shown on the same screen is impossible there.
@@ -125,6 +215,9 @@ declare function isTouchDevice(env?: {
     navigator?: Navigator;
     matchMedia?: (q: string) => MediaQueryList;
 }): boolean;
+
+/** An SVG QR code for `text` (error correction M). */
+declare function qrSvg(text: string): string;
 interface PairingModalOptions {
     title?: string;
     /**
@@ -149,6 +242,25 @@ declare function pairingModal(o?: PairingModalOptions): PairingOptions & {
 declare function pickWallet(options: WalletOption[], o?: {
     title?: string;
 }): Promise<WalletOption | null>;
+interface ChooseWalletOptions {
+    /** Default "Choose a wallet". */
+    title?: string;
+    /** Where "Get bWalletX" points. Default https://bwalletx.com/get */
+    getUrl?: string;
+    /**
+     * Offer "Use Metanet Desktop or another BRC-100 wallet" (0.7.0; was "Desktop wallet"). Default true. It calls
+     * localhost:3321 only when tapped (metanetOption), never while the chooser opens, and is never shown on a phone or
+     * inside a frame.
+     */
+    desktop?: boolean;
+}
+/**
+ * The wallet chooser (0.5.6). Without bWalletX in this browser, "Get bWalletX" comes first; then bWalletX on the
+ * phone, the other wallets that were detected, "Use Metanet Desktop or another BRC-100 wallet" (0.7.0: localhost:3321
+ * only when tapped; computers only) and app-supplied options. Opened from "Other wallets" while bWalletX is here, bWalletX is the first, gold row.
+ * Resolves with the chosen option, or null when closed. "Get bWalletX" is a link and leaves the chooser open.
+ */
+declare function chooseWallet(options: readonly WalletOption[], o?: ChooseWalletOptions): Promise<WalletOption | null>;
 
 /**
  * Browser side of the access protocol: ask the wallet to sign the site's challenge and prove the
@@ -201,4 +313,199 @@ declare const WALLET_THEME_META = "bwalletx-theme";
 /** Declare (or with null, withdraw) the theme the wallet should wear for this page. No-op outside a browser. */
 declare function declareWalletTheme(theme: string | null | undefined): void;
 
-export { type AccessChallengeLike, AccessError, AccessResponse, BWALLETX_RDNS, type ButtonOptions, type Challenge, DEFAULT_DISCOVER_MS, type FoundBy, type FoundWallet, HoldingProof, LOGIN_PROTOCOL, LOGO_URL, type PairingModalOptions, PairingOptions, RDNS_EXTENSION, RDNS_MOBILE, type RequestAccessOptions, type RequestAccessResult, type SignInMethod, type SignInOptions, type SignInResult, type SignInStage, type SignInStatus, WALLET_THEME_META, WalletOption, bindPrewarm, connectBwalletX, declareWalletTheme, discoverBwalletX, findBwalletX, inOrder, isTouchDevice, pairingModal, pickWallet, prewarmBwalletX, proveHoldings, qrSvg, renderButton, requestAccess, signInWithBwalletX, throwIfAccessError, toAccessError };
+/**
+ * 0.7.0: "Use Metanet Desktop or another BRC-100 wallet" (owner, 6 Nov 2026: "ship a new one now with the metanet
+ * option"). The same rules as the live bChatX door (bit-sign src/lib/metanet-door.ts):
+ *
+ *   1. bWalletX stays the default. It is found by its own announcement only, never by window.CWI, and the gold
+ *      button's discovery NEVER picks Metanet (matchRemembered returns null for it).
+ *   2. A visible, explicit choice. PINNED to WalletClient('json-api') on localhost:3321, never 'auto': 'auto' races
+ *      the substrates starting with window.CWI, so the bWalletX extension would silently win and this would be a
+ *      label, not a choice. On a first visit it connects ONLY on its own tap; nothing calls :3321 on page load.
+ *   3. After a successful connect: the wallet TYPE for this origin (bwx:wallet = { type: 'metanet', substrate:
+ *      'json-api' }) plus the identity keys known on this origin (bwx:known-keys). Public keys only; never a secret.
+ *   4. Back with Metanet remembered: at most ONE silent attempt per page load, a 2 s window, and it goes on only if the
+ *      identity key Metanet returns is already known here. Whatever answers on :3321 could be another profile, our own
+ *      `bwalletx serve` agent wallet or any local process; letting an unknown key sign in silently would land the
+ *      person in THAT key's account (login CSRF). Any failure is silent: no banner, no retry.
+ *   5. "Not you? Use another wallet" and Disconnect forget the choice.
+ *   6. Offered only on a computer and outside any frame (Metanet Desktop is a desktop app).
+ *   7. The minimum asked: getVersion (is it running?), isAuthenticated (never prompts), the identity public key, then
+ *      whatever the site's own call needs (the sign-in signature). No protocol permission requests at connect, and the
+ *      calls go one at a time: two prompts at once is how Metanet Desktop froze on a "Trust" sheet (6 Nov 2026).
+ */
+
+/** The wallet type remembered for Metanet Desktop (and any BRC-100 wallet serving the JSON API on :3321). */
+declare const METANET_TYPE = "metanet";
+/** WalletOption.id of the Metanet option. */
+declare const METANET_OPTION_ID = "metanet";
+/** Where Metanet Desktop serves the BRC-100 JSON API. */
+declare const METANET_JSON_API = "http://localhost:3321";
+declare const METANET_LABEL = "Use Metanet Desktop or another BRC-100 wallet";
+declare const METANET_NOTE = "Metanet Desktop must be running on this computer";
+/** Shown when Metanet is the wallet remembered on this site. */
+declare const METANET_REMEMBERED_NOTE = "Signs in with Metanet Desktop on this computer.";
+declare const NOT_YOU_LABEL = "Not you? Use another wallet";
+declare const METANET_UNREACHABLE = "We couldn\u2019t reach Metanet Desktop. Open it, then try again.";
+/** How long Metanet Desktop has to answer getVersion after a tap. */
+declare const METANET_ANSWER_MS = 4000;
+/** The silent attempt's whole window (reachable, unlocked, identity key): short, since nobody asked for it. */
+declare const METANET_SILENT_MS = 2000;
+/** Nothing answered on localhost:3321 in time. `code` is NOT_FOUND, like every "no wallet here". */
+declare class MetanetUnreachableError extends Error {
+    readonly code = "NOT_FOUND";
+    constructor();
+}
+/** Inside any frame at all (bWalletX's or anyone's), or the top can't be read. */
+/** The two window fields the frame check reads. */
+type FrameWindow = {
+    readonly self: unknown;
+    readonly top: unknown;
+};
+declare function inAnyFrame(win?: FrameWindow | undefined): boolean;
+/** Where the Metanet option is offered at all: a browser on a computer (not a phone or tablet), outside any frame. */
+declare function metanetOffered(env?: {
+    navigator?: Navigator;
+    matchMedia?: (q: string) => MediaQueryList;
+    window?: FrameWindow;
+}): boolean;
+interface MetanetOptions {
+    /** This site's host, as WalletClient's originator (the browser sets the real Origin header). Default location.host. */
+    originator?: string;
+    /** How long Metanet has to answer getVersion. Default METANET_ANSWER_MS. */
+    timeoutMs?: number;
+    /** Tests and custom hosts: stands in for `new WalletClient('json-api', originator)`. */
+    make?: () => WalletInterface;
+}
+/**
+ * The wallet on localhost:3321 once it has answered getVersion; MetanetUnreachableError if nothing does in time.
+ * ⚠ WalletClient builds a pinned substrate in its constructor, so connectToSubstrate proves nothing: this asks.
+ */
+declare function connectMetanetDesktop(o?: MetanetOptions): Promise<WalletInterface>;
+/**
+ * "Use Metanet Desktop or another BRC-100 wallet" as a WalletOption. Nothing touches localhost until connect() runs,
+ * i.e. after the tap. connect() always asks for the identity key first, on its own (also with `{ identity: false }`):
+ * the sign-in then asks for the signature alone, so Metanet never gets two requests at once.
+ */
+declare function metanetOption(o?: MetanetOptions): WalletOption;
+/** localStorage key (per origin) for the identity keys that connected or signed in here. Public keys only. */
+declare const KNOWN_KEYS_KEY = "bwx:known-keys";
+/** The identity keys known on this origin, newest first. */
+declare function knownIdentityKeys(): string[];
+/** True when this identity key connected or signed in on this origin before (or is the last sign-in's key). */
+declare function isKnownIdentityKey(key: string | null | undefined): boolean;
+/** Add an identity key to this origin's known keys (after a successful connect or sign-in). */
+declare function rememberKnownIdentityKey(key: string | null | undefined): void;
+/** True once this page load's one silent attempt has been used (however many buttons or providers mount). */
+declare function silentAttemptUsed(): boolean;
+/** Claim this page load's one silent attempt. False if it was already used. */
+declare function claimSilentAttempt(): boolean;
+/** Tests only (and a single-page app that wants a fresh "page load"). */
+declare function resetSilentAttempt(): void;
+/** Why a silent attempt stopped. Every one of them is silent: the normal choice stays on screen. */
+type SilentStop = 'used' | 'not-here' | 'unreachable' | 'locked' | 'slow' | 'unknown-key';
+type SilentMetanetResult = {
+    ok: true;
+    wallet: WalletInterface;
+    identityKey: string;
+} | {
+    ok: false;
+    stop: SilentStop;
+};
+/**
+ * The silent part of a return visit: claim the page load's one attempt, then, within `windowMs` (2 s) in all,
+ * Metanet must answer getVersion, say it is unlocked (isAuthenticated, which never prompts) and return an identity
+ * key already known on this origin. Never waits for an unlock, never asks for anything else, never throws.
+ */
+declare function trySilentMetanet(o?: MetanetOptions & {
+    windowMs?: number;
+}): Promise<SilentMetanetResult>;
+/**
+ * (0.7.0) A sign-in with a verify route and no logout route: "Not you?" (and Disconnect) cannot end a session the
+ * verify route already set, so the person stays signed in as the key they just rejected. Warns once per page, in
+ * development only. Returns true when it warned.
+ */
+declare function warnIfNoLogout(o: {
+    verifyUrl?: string | null;
+    logoutUrl?: string | null;
+    where: string;
+}): boolean;
+
+interface ConnectFlowOptions {
+    /** The wallets found (discoverWallets). */
+    list: WalletOption[];
+    /** Connect this option without asking. */
+    walletId?: string;
+    /** false: never show the chooser (bWalletX, else the phone; never another wallet unasked). Default true. */
+    picker?: boolean;
+    /** "Other wallets": show the chooser even when bWalletX is here. */
+    chooser?: boolean;
+    /**
+     * bWalletX first (0.5.6, default true): bWalletX in this browser is connected with no chooser; without it the
+     * chooser opens ("Get bWalletX" first) and no other wallet is connected unless picked. false: the 0.5.5 rule.
+     */
+    fastPath?: boolean;
+    /**
+     * (0.6.0) The wallet picked on this origin before (rememberedWalletChoice()). When it is here, the tap goes straight
+     * to it, with no chooser, even when it isn't bWalletX (the user chose it).
+     */
+    remembered?: RememberedWallet | null;
+    /** (0.6.0) After a successful connect the user explicitly picked, remember the wallet type for this origin. */
+    remember?: boolean;
+    /** (0.6.0) "Switch" to bWalletX: ignore a remembered other wallet (bWalletX here, else the chooser). */
+    preferBwalletX?: boolean;
+    /**
+     * (0.7.0) The user tapped "Use Metanet Desktop or another BRC-100 wallet": connect to localhost:3321 (pinned
+     * 'json-api', never 'auto'), with no chooser. Rejects NOT_SUPPORTED on a phone or inside a frame.
+     */
+    metanet?: boolean | MetanetOptions;
+    /** Show the chooser; resolves null when closed. chooseWallet (modal.ts) or your own UI. */
+    pick: (list: WalletOption[]) => Promise<WalletOption | null>;
+    /** With verifyUrl: sign in after connecting. */
+    challengeUrl?: string;
+    verifyUrl?: string;
+    challengeNeedsIdentityKey?: boolean;
+    /** POST JSON; throws with `status` on a non-2xx answer. */
+    post: (url: string, body: unknown) => Promise<Record<string, unknown>>;
+    /** Called once per attempt with { walletType, substrate, outcome, ms }. No keys, addresses or identity data. */
+    onAttempt?: AttemptHook;
+}
+interface ConnectFlowResult {
+    connected: ConnectedWallet;
+    identityKey: string | null;
+    handle: string | null;
+    paymail: string | null;
+    signedIn: boolean;
+    /** 'bwalletx' for bWalletX, else the wallet's rdns / option id. */
+    walletType: string;
+    substrate: Substrate;
+    /** Why this wallet: 'bwalletx' (fast path), 'chooser' (picked), 'requested' (walletId), … */
+    reason: ChoiceReason;
+}
+/** Resolves null when the user closed the chooser. Throws NOT_FOUND when there is nothing to connect. */
+declare function runConnect(o: ConnectFlowOptions): Promise<ConnectFlowResult | null>;
+interface SilentMetanetOptions extends MetanetOptions {
+    /** With verifyUrl: sign in once the known key is confirmed (the signature alone; the key is already in hand). */
+    challengeUrl?: string;
+    verifyUrl?: string;
+    post?: (url: string, body: unknown) => Promise<Record<string, unknown>>;
+    /** A server session is already in place for this identity key: attach the wallet only if it is the same key. */
+    sessionKey?: string | null;
+    /** The silent window, ms. Default METANET_SILENT_MS (2 s). */
+    windowMs?: number;
+    /** Called when the known key is confirmed and the sign-in signature is about to be asked for. */
+    onSignIn?: () => void;
+    /** "Not you?" was pressed meanwhile: land nobody (and end a session the verify route already set, via `logout`). */
+    isAbandoned?: () => boolean;
+    logout?: () => Promise<unknown>;
+    onAttempt?: AttemptHook;
+}
+/**
+ * (0.7.0) The return visit with Metanet remembered: ONE silent attempt per page load (trySilentMetanet: 2 s, known
+ * identity keys only), then, with a session already there, attach the wallet when it is the session's key; without
+ * one, sign in with the signature alone. Resolves null on any stop or failure, and never throws: the caller shows
+ * the normal choice and waits for a tap, with no error.
+ */
+declare function runSilentMetanet(o?: SilentMetanetOptions): Promise<ConnectFlowResult | null>;
+
+export { type AccessChallengeLike, AccessError, AccessResponse, AttemptHook, BAVATAR_URL, BWALLETX_RDNS, type ButtonOptions, type Challenge, ChoiceReason, type ChooseWalletOptions, type ConnectFlowOptions, type ConnectFlowResult, ConnectedWallet, DEFAULT_DISCOVER_MS, type FoundBy, type FoundWallet, type FrameWindow, HoldingProof, IDENTITY_HINT_KEY, KNOWN_KEYS_KEY, LOGIN_PROTOCOL, LOGO_URL, METANET_ANSWER_MS, METANET_JSON_API, METANET_LABEL, METANET_NOTE, METANET_OPTION_ID, METANET_REMEMBERED_NOTE, METANET_SILENT_MS, METANET_TYPE, METANET_UNREACHABLE, type MetanetOptions, MetanetUnreachableError, NOT_YOU_LABEL, PAYMAIL_LOOKUP_URL, type PairingModalOptions, PairingOptions, RDNS_EXTENSION, RDNS_MOBILE, RememberedWallet, type RequestAccessOptions, type RequestAccessResult, type SignInAndVerifyOptions, type SignInMethod, type SignInOptions, type SignInResult, type SignInStage, type SignInStatus, type SilentMetanetOptions, type SilentMetanetResult, type SilentStop, Substrate, WALLET_THEME_META, WalletOption, accountLabel, avatarUrlFor, bindPrewarm, challengeWantsIdentityKey, chooseWallet, claimSilentAttempt, connectBwalletX, connectMetanetDesktop, declareWalletTheme, discoverBwalletX, findBwalletX, inAnyFrame, inOrder, isFramed, isKnownIdentityKey, isTouchDevice, isUserRejection, knownIdentityKeys, lookupPaymail, metanetOffered, metanetOption, pairingModal, pickWallet, prewarmBwalletX, proveHoldings, qrSvg, rememberIdentity, rememberKnownIdentityKey, rememberedIdentity, renderButton, requestAccess, resetSilentAttempt, runConnect, runSilentMetanet, shortKey, signInAndVerify, signInErrorText, signInWithBwalletX, silentAttemptUsed, throwIfAccessError, toAccessError, trySilentMetanet, waitIfLocked, warnIfNoLogout };