@bwalletx/connect 0.5.4 → 0.7.0

package/dist/chunk-6EFFOIHK.js

@@ -0,0 +1,2441 @@
+import {
+  ACCESS_PROTOCOL,
+  AccessError,
+  MAX_HOLDING_PROOFS,
+  challengeBytes,
+  parseAccessChallenge
+} from "./chunk-MWD4BCO5.js";
+
+// src/discover.ts
+import { WalletClient, XDM } from "@bsv/sdk";
+var RDNS_EXTENSION = "com.bwalletx.extension";
+var RDNS_MOBILE = "space.bwallet.mobile";
+var BWALLETX_RDNS = [RDNS_EXTENSION, RDNS_MOBILE];
+var DEFAULT_DISCOVER_MS = 300;
+function discoverBwalletX(ms = DEFAULT_DISCOVER_MS) {
+  if (typeof window === "undefined") return Promise.resolve(null);
+  return new Promise((resolve) => {
+    let done = false;
+    let timer;
+    const finish2 = (r) => {
+      if (done) return;
+      done = true;
+      if (timer !== void 0) clearTimeout(timer);
+      window.removeEventListener("brc100:announceWallet", onAnnounce);
+      resolve(r);
+    };
+    const onAnnounce = (e) => {
+      const d = e.detail;
+      const rdns = d?.info?.rdns ?? "";
+      if (d?.wallet && BWALLETX_RDNS.includes(rdns)) {
+        finish2({ wallet: d.wallet, method: rdns === RDNS_EXTENSION ? "extension" : "in-app", rdns });
+      }
+    };
+    window.addEventListener("brc100:announceWallet", onAnnounce);
+    window.dispatchEvent(new Event("brc100:requestWallet"));
+    if (done) return;
+    if (isFramed()) {
+      void probeXdm(Math.max(ms, 1200)).then((w) => finish2(w ? { wallet: w, method: "in-app", rdns: null } : null));
+      return;
+    }
+    timer = setTimeout(() => {
+      timer = void 0;
+      finish2(null);
+    }, ms);
+  });
+}
+async function findBwalletX(ms = DEFAULT_DISCOVER_MS) {
+  return (await discoverBwalletX(ms))?.wallet ?? null;
+}
+var isFramed = () => {
+  try {
+    return window.parent !== window;
+  } catch {
+    return true;
+  }
+};
+var BWALLETX_PARENT_ORIGINS = [
+  "https://web.bwalletx.com",
+  "https://desktop.bwalletx.com",
+  "https://bwalletx.com",
+  "https://www.bwallet.space",
+  "https://bwallet.space",
+  "capacitor://localhost",
+  // iOS app shell
+  "https://localhost",
+  // Android app shell
+  "tauri://localhost",
+  // bWalletX Desktop (macOS)
+  "https://tauri.localhost",
+  // bWalletX Desktop (Windows)
+  "chrome-extension://bombmmcjghjdlbmcclnhjodgcelnehgl"
+  // bWalletX for Chrome (fixed id)
+];
+var parentOrigin = () => {
+  try {
+    const anc = window.location.ancestorOrigins;
+    if (anc && anc.length > 0) return anc[0] ?? null;
+    if (!document.referrer) return null;
+    const u = new URL(document.referrer);
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return null;
+  }
+};
+async function probeXdm(ms = 1200, allowed = BWALLETX_PARENT_ORIGINS) {
+  const origin = parentOrigin();
+  if (!origin || !allowed.includes(origin)) return null;
+  try {
+    const w = new WalletClient(new XDM(origin));
+    const ok = await Promise.race([
+      w.isAuthenticated({}).then(
+        () => true,
+        () => false
+      ),
+      new Promise((r) => setTimeout(() => r(false), ms))
+    ]);
+    return ok ? w : null;
+  } catch {
+    return null;
+  }
+}
+var warmedAt = 0;
+function prewarmBwalletX() {
+  if (typeof window === "undefined" || Date.now() - warmedAt < 2e4) return;
+  warmedAt = Date.now();
+  void discoverBwalletX(0).then((f) => {
+    if (f && f.method === "extension") void f.wallet.isAuthenticated({}).catch(() => {
+    });
+  });
+}
+function bindPrewarm(el2) {
+  const on = () => prewarmBwalletX();
+  const evs = ["pointerenter", "focus", "touchstart"];
+  for (const e of evs) el2.addEventListener(e, on, { passive: true });
+  return () => evs.forEach((e) => el2.removeEventListener(e, on));
+}
+
+// src/in-order.ts
+function inOrder(handle, onError) {
+  let queue = Promise.resolve();
+  return (frame) => {
+    queue = queue.then(() => handle(frame)).catch((e) => onError?.(e));
+    return queue;
+  };
+}
+
+// src/pair.ts
+import { PrivateKey as PrivateKey2 } from "@bsv/sdk";
+
+// src/protocol.ts
+import { PublicKey } from "@bsv/sdk";
+var PAIR_VERSION = "1";
+var PAIR_INFO = "bwallet-pair-v1";
+var PAIR_HOST = "www.bwallet.space";
+var DEFAULT_RELAY = "relay.bwallet.space";
+var QR_LIFETIME_S = 120;
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+var binary = (bytes) => {
+  let s = "";
+  for (let i = 0; i < bytes.length; i += 32768) s += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return s;
+};
+var b64url = (bytes) => btoa(binary(bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var fromB64url = (s) => {
+  const t = s.replace(/-/g, "+").replace(/_/g, "/");
+  const bin = atob(t + "=".repeat((4 - t.length % 4) % 4));
+  return Uint8Array.from(bin, (ch) => ch.charCodeAt(0));
+};
+var b64 = (bytes) => btoa(binary(bytes));
+var fromB64 = (s) => Uint8Array.from(atob(s), (ch) => ch.charCodeAt(0));
+var newChannel = () => b64url(crypto.getRandomValues(new Uint8Array(16)));
+function pairUrl(link) {
+  const q = new URLSearchParams({ v: link.v, r: link.r, c: link.c, k: link.k, o: link.o, e: String(link.e) });
+  return `https://${PAIR_HOST}/pair?${q}`;
+}
+var newClaim = () => b64url(crypto.getRandomValues(new Uint8Array(16)));
+var WALLET_CLAIM_INFO = "bwallet-pair-wallet-claim-v1";
+var hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+async function walletClaimFor(channel, sitePub) {
+  const d = await crypto.subtle.digest("SHA-256", enc.encode(`${WALLET_CLAIM_INFO}|${channel}|${sitePub}`));
+  return b64url(new Uint8Array(d));
+}
+async function claimDigest(claim) {
+  return hex(new Uint8Array(await crypto.subtle.digest("SHA-256", enc.encode(claim))));
+}
+var relaySocketUrl = (relay, channel, role, expiry, claim, walletClaimHash) => {
+  const local = /^(localhost|127\.0\.0\.1)(:\d+)?$/.test(relay);
+  const q = new URLSearchParams({ role });
+  if (expiry) q.set("e", String(expiry));
+  if (claim) q.set("claim", claim);
+  if (walletClaimHash && role === "site") q.set("wc", walletClaimHash);
+  return `${local ? "ws" : "wss"}://${relay}/v1/c/${channel}?${q}`;
+};
+async function deriveSession(mine, theirs, channel) {
+  const point = mine.deriveSharedSecret(PublicKey.fromString(theirs));
+  const ikm = new Uint8Array(point.encode(true));
+  const base = await crypto.subtle.importKey("raw", ikm, "HKDF", false, ["deriveBits"]);
+  const bits = new Uint8Array(
+    await crypto.subtle.deriveBits(
+      { name: "HKDF", hash: "SHA-256", salt: fromB64url(channel), info: enc.encode(PAIR_INFO) },
+      base,
+      256
+    )
+  );
+  const key = await crypto.subtle.importKey("raw", bits, "AES-GCM", false, ["encrypt", "decrypt"]);
+  const h = new Uint8Array(await crypto.subtle.digest("SHA-256", bits));
+  const code = String((h[0] << 8 | h[1]) % 1e4).padStart(4, "0");
+  return { key, code };
+}
+var Sealer = class {
+  constructor(key, me) {
+    this.key = key;
+    this.me = me;
+  }
+  key;
+  me;
+  sent = 0;
+  lastSeen = 0;
+  async seal(msg) {
+    const s = ++this.sent;
+    const n = crypto.getRandomValues(new Uint8Array(12));
+    const ct = new Uint8Array(
+      await crypto.subtle.encrypt(
+        { name: "AES-GCM", iv: n, additionalData: enc.encode(`${this.me}|${s}`) },
+        this.key,
+        enc.encode(JSON.stringify(msg))
+      )
+    );
+    return { s, n: b64(n), d: b64(ct) };
+  }
+  /** Decrypts a frame from the other side; null for replays, reflections or tampering. */
+  async open(f) {
+    if (!Number.isInteger(f.s) || f.s <= this.lastSeen) return null;
+    const from = this.me === "site" ? "wallet" : "site";
+    try {
+      const pt = await crypto.subtle.decrypt(
+        { name: "AES-GCM", iv: fromB64(f.n), additionalData: enc.encode(`${from}|${f.s}`) },
+        this.key,
+        fromB64(f.d)
+      );
+      this.lastSeen = f.s;
+      return JSON.parse(dec.decode(pt));
+    } catch {
+      return null;
+    }
+  }
+  /** For resuming a session after a reload: continue counters where they were. */
+  get counters() {
+    return { sent: this.sent, lastSeen: this.lastSeen };
+  }
+  restore(c) {
+    this.sent = c.sent;
+    this.lastSeen = c.lastSeen;
+  }
+};
+var isSealed = (x) => !!x && typeof x === "object" && "d" in x && "n" in x && "s" in x;
+
+// src/pair.ts
+var DEFAULT_KEY = "bwalletx.connect.pairing.v1";
+var OPEN = 1;
+function memoryStorage() {
+  const m = /* @__PURE__ */ new Map();
+  return { getItem: (k) => m.get(k) ?? null, setItem: (k, v) => void m.set(k, v), removeItem: (k) => void m.delete(k) };
+}
+function defaultStorage() {
+  try {
+    if (typeof localStorage !== "undefined") return localStorage;
+  } catch {
+  }
+  return memoryStorage();
+}
+function defaultSocket() {
+  return (url) => {
+    if (typeof WebSocket === "undefined") throw new Error("No WebSocket here. Pass options.socket.");
+    return new WebSocket(url);
+  };
+}
+function parseStored(raw) {
+  if (!raw) return null;
+  try {
+    const p = JSON.parse(raw);
+    const n = (x) => Number.isInteger(x) && x >= 0;
+    if (p.v !== 1) return null;
+    if (typeof p.c !== "string" || !/^[A-Za-z0-9_-]{22}$/.test(p.c)) return null;
+    if (typeof p.r !== "string" || !/^[a-z0-9.-]+(:\d+)?$/i.test(p.r)) return null;
+    if (typeof p.s !== "string" || !/^[0-9a-f]{64}$/i.test(p.s)) return null;
+    if (typeof p.k !== "string" || !/^0[23][0-9a-f]{64}$/i.test(p.k)) return null;
+    if (!n(p.sent) || !n(p.lastSeen) || !n(p.pairedAt)) return null;
+    if (p.sc !== void 0 && (typeof p.sc !== "string" || !/^[A-Za-z0-9_-]{22,64}$/.test(p.sc))) return null;
+    return p;
+  } catch {
+    return null;
+  }
+}
+var Link = class {
+  constructor(p, sealer, storage, key, socket, timeoutMs) {
+    this.p = p;
+    this.sealer = sealer;
+    this.storage = storage;
+    this.key = key;
+    this.socket = socket;
+    this.timeoutMs = timeoutMs;
+  }
+  p;
+  sealer;
+  storage;
+  key;
+  socket;
+  timeoutMs;
+  ws = null;
+  opening = null;
+  waiting = /* @__PURE__ */ new Map();
+  forgotten = false;
+  /** Take over a socket that is already open (the one pairing used). */
+  adopt(ws) {
+    this.ws = ws;
+    this.wire(ws);
+  }
+  wire(ws) {
+    ws.onmessage = inOrder((ev) => this.onFrame(String(ev.data)));
+    ws.onerror = null;
+    ws.onclose = () => {
+      if (this.ws === ws) this.ws = null;
+      this.failAll(new Error("The connection to bWalletX closed"));
+    };
+  }
+  persist() {
+    if (this.forgotten) return;
+    this.p = { ...this.p, ...this.sealer.counters };
+    void Promise.resolve(this.storage.setItem(this.key, JSON.stringify(this.p))).catch(() => {
+    });
+  }
+  failAll(e) {
+    for (const w of this.waiting.values()) {
+      clearTimeout(w.timer);
+      w.reject(e);
+    }
+    this.waiting.clear();
+  }
+  async ensure() {
+    if (this.forgotten) throw new Error("This pairing was removed. Pair again.");
+    if (this.ws && this.ws.readyState === OPEN) return;
+    this.opening ??= this.reopen().finally(() => this.opening = null);
+    await this.opening;
+  }
+  reopen() {
+    if (!this.p.sc) {
+      this.p = { ...this.p, sc: newClaim() };
+      this.persist();
+    }
+    const e = Math.floor(Date.now() / 1e3) + QR_LIFETIME_S - 10;
+    const ws = this.socket(relaySocketUrl(this.p.r, this.p.c, "site", e, this.p.sc));
+    return new Promise((resolve, reject) => {
+      ws.onopen = () => {
+        this.ws = ws;
+        this.wire(ws);
+        resolve();
+      };
+      ws.onerror = () => reject(new Error("Could not reach the bWalletX pairing service"));
+      ws.onclose = () => reject(new Error("Could not reach the bWalletX pairing service"));
+    });
+  }
+  async onFrame(raw) {
+    let f;
+    try {
+      f = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const t = f.t;
+    if (t === "relay" && f.error) {
+      return this.failAll(new Error(`bWalletX pairing service: ${f.error}`));
+    }
+    if (!isSealed(f)) return;
+    const msg = await this.sealer.open(f);
+    if (!msg) return;
+    this.persist();
+    if (msg.t === "res") {
+      const w = this.waiting.get(msg.id);
+      if (!w) return;
+      clearTimeout(w.timer);
+      this.waiting.delete(msg.id);
+      if (msg.error) w.reject(Object.assign(new Error(msg.error.message), { code: msg.error.code }));
+      else w.resolve(msg.result);
+    } else if (msg.t === "close") {
+      this.drop();
+      this.failAll(new Error("bWalletX disconnected this site. Pair again."));
+    }
+  }
+  async call(action, params) {
+    await this.ensure();
+    const ws = this.ws;
+    const id = `${action}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    const result = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.waiting.delete(id)) reject(new Error("No answer from bWalletX. Open it, unlocked, and approve."));
+      }, this.timeoutMs);
+      this.waiting.set(id, { resolve, reject, timer });
+    });
+    ws.send(JSON.stringify(await this.sealer.seal({ t: "req", id, action, params })));
+    this.persist();
+    return result;
+  }
+  close() {
+    const ws = this.ws;
+    this.ws = null;
+    ws?.close();
+  }
+  drop() {
+    this.forgotten = true;
+    void Promise.resolve(this.storage.removeItem(this.key)).catch(() => {
+    });
+    this.close();
+  }
+  async forget() {
+    if (this.forgotten) return;
+    try {
+      if (this.ws && this.ws.readyState === OPEN) {
+        this.ws.send(JSON.stringify(await this.sealer.seal({ t: "close", reason: "site unpaired" })));
+      }
+    } catch {
+    }
+    this.drop();
+  }
+  wallet() {
+    return new Proxy({}, {
+      get: (_t, method) => {
+        if (method === "close") return () => this.close();
+        if (method === "forget") return () => this.forget();
+        if (typeof method !== "string" || method === "then" || method === "toJSON") return void 0;
+        return (params) => this.call(method, params ?? {});
+      }
+    });
+  }
+};
+function pairBwalletX(opts) {
+  const storage = opts.storage === void 0 ? defaultStorage() : opts.storage ?? memoryStorage();
+  const key = opts.storageKey ?? DEFAULT_KEY;
+  const socket = opts.socket ?? defaultSocket();
+  const relay = opts.relay ?? DEFAULT_RELAY;
+  const origin = opts.origin ?? (typeof location !== "undefined" ? location.origin : "");
+  if (!origin) return Promise.reject(new Error("pairBwalletX needs options.origin outside a browser"));
+  const siteKey = PrivateKey2.fromRandom();
+  const channel = newChannel();
+  const expiry = Math.floor(Date.now() / 1e3) + QR_LIFETIME_S;
+  const siteClaim = newClaim();
+  const sitePub = siteKey.toPublicKey().toString();
+  return walletClaimFor(channel, sitePub).then(claimDigest).then((wc) => new Promise((resolve, reject) => {
+    if (opts.signal?.aborted) return reject(new Error("cancelled"));
+    let ws;
+    try {
+      ws = socket(relaySocketUrl(relay, channel, "site", expiry, siteClaim, wc));
+    } catch (e) {
+      return reject(e);
+    }
+    let sealer = null;
+    let walletKey = "";
+    let settled = false;
+    const fail = (e) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      ws.close();
+      reject(e);
+    };
+    const timer = setTimeout(() => fail(new Error("The pairing code expired. Show a new one.")), QR_LIFETIME_S * 1e3);
+    opts.signal?.addEventListener("abort", () => fail(new Error("cancelled")));
+    ws.onerror = () => fail(new Error("Could not reach the bWalletX pairing service"));
+    ws.onclose = () => fail(new Error("The connection to bWalletX closed before pairing finished"));
+    ws.onmessage = inOrder(async (ev) => {
+      if (settled) return;
+      let f;
+      try {
+        f = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      if (f.t === "hello" && !sealer) {
+        walletKey = f.k;
+        const s = await deriveSession(siteKey, walletKey, channel);
+        sealer = new Sealer(s.key, "site");
+        opts.onCode(s.code);
+        return;
+      }
+      if (!sealer || !isSealed(f)) return;
+      const msg = await sealer.open(f);
+      if (!msg) return;
+      if (msg.t === "ready") {
+        settled = true;
+        clearTimeout(timer);
+        const p = { v: 1, c: channel, r: relay, s: siteKey.toHex(), k: walletKey, ...sealer.counters, pairedAt: Date.now(), sc: siteClaim };
+        await Promise.resolve(storage.setItem(key, JSON.stringify(p))).catch(() => {
+        });
+        const link = new Link(p, sealer, storage, key, socket, opts.callTimeoutMs ?? 12e4);
+        link.adopt(ws);
+        resolve(link.wallet());
+      } else if (msg.t === "close") {
+        fail(new Error("Pairing was declined in bWalletX"));
+      }
+    });
+    opts.onLink(pairUrl({ v: PAIR_VERSION, r: relay, c: channel, k: sitePub, o: origin, e: expiry }));
+  }));
+}
+async function restorePairing(opts = {}) {
+  const storage = opts.storage === void 0 ? defaultStorage() : opts.storage ?? memoryStorage();
+  const key = opts.storageKey ?? DEFAULT_KEY;
+  const p = parseStored(await Promise.resolve(storage.getItem(key)).catch(() => null));
+  if (!p) return null;
+  const { key: aes } = await deriveSession(PrivateKey2.fromHex(p.s), p.k, p.c);
+  const sealer = new Sealer(aes, "site");
+  sealer.restore({ sent: p.sent, lastSeen: p.lastSeen });
+  return new Link(p, sealer, storage, key, opts.socket ?? defaultSocket(), opts.callTimeoutMs ?? 12e4).wallet();
+}
+async function clearPairing(opts = {}) {
+  const storage = opts.storage === void 0 ? defaultStorage() : opts.storage ?? memoryStorage();
+  await Promise.resolve(storage.removeItem(opts.storageKey ?? DEFAULT_KEY)).catch(() => {
+  });
+}
+
+// src/signin.ts
+var LOGIN_PROTOCOL = [2, "bwallet sign in"];
+async function connectBwalletX(opts = {}) {
+  const status = (s) => {
+    try {
+      opts.onStatus?.(s);
+    } catch {
+    }
+  };
+  if (opts.wallet) {
+    status("opening");
+    return { wallet: opts.wallet, method: "wallet" };
+  }
+  status("finding");
+  const found = await discoverBwalletX(opts.discoverMs ?? DEFAULT_DISCOVER_MS);
+  if (found) {
+    status("opening");
+    return { wallet: found.wallet, method: found.method };
+  }
+  if (opts.reusePairing !== false) {
+    const restored = await restorePairing(opts.pairing ?? {});
+    if (restored) {
+      status("opening");
+      return { wallet: restored, method: "pairing" };
+    }
+  }
+  if (!opts.pairing) {
+    throw Object.assign(new Error("bWalletX was not found in this browser"), { code: "NOT_FOUND" });
+  }
+  status("pairing");
+  return { wallet: await pairBwalletX(opts.pairing), method: "pairing" };
+}
+async function waitIfLocked(wallet) {
+  let ok = false;
+  try {
+    ok = !!(await wallet.isAuthenticated({}))?.authenticated;
+  } catch {
+  }
+  if (!ok) await Promise.resolve().then(() => wallet.waitForAuthentication({})).catch(() => {
+  });
+}
+function challengeWantsIdentityKey(e) {
+  const msg = e instanceof Error ? e.message : String(e ?? "");
+  return /identityKey/i.test(msg);
+}
+async function signInWithBwalletX(opts) {
+  const { wallet, method } = await connectBwalletX(opts);
+  if (method !== "pairing" && !opts.skipWaitForAuthentication) await waitIfLocked(wallet);
+  const status = () => {
+    try {
+      opts.onStatus?.("signing");
+    } catch {
+    }
+  };
+  const sign = (c2) => wallet.createSignature({
+    protocolID: c2.protocolID ?? LOGIN_PROTOCOL,
+    keyID: c2.keyID,
+    counterparty: "anyone",
+    data: Array.from(new TextEncoder().encode(c2.message))
+  });
+  const keyFirst = async () => {
+    const { publicKey: identityKey2 } = await atStage("identity", () => wallet.getPublicKey({ identityKey: true }));
+    status();
+    const c2 = await atStage("challenge", () => opts.challenge(identityKey2));
+    const { signature: signature2 } = await atStage("signature", () => sign(c2));
+    return { identityKey: identityKey2, signature: Array.from(signature2), nonce: c2.nonce, method, wallet };
+  };
+  if (opts.challengeNeedsIdentityKey && !opts.identityKey) return keyFirst();
+  let c;
+  try {
+    c = await atStage("challenge", () => opts.challenge(opts.identityKey));
+  } catch (e) {
+    if (!opts.identityKey && challengeWantsIdentityKey(e)) return keyFirst();
+    throw e;
+  }
+  status();
+  const [{ publicKey: identityKey }, { signature }] = await Promise.all([
+    opts.identityKey ? Promise.resolve({ publicKey: opts.identityKey }) : atStage("identity", () => wallet.getPublicKey({ identityKey: true })),
+    atStage("signature", () => sign(c))
+  ]);
+  return { identityKey, signature: Array.from(signature), nonce: c.nonce, method, wallet };
+}
+async function signInAndVerify(opts) {
+  const hinted = !opts.identityKey && !!opts.identityKeyHint;
+  const r = await signInWithBwalletX({ ...opts, identityKey: opts.identityKey ?? opts.identityKeyHint });
+  try {
+    return { result: r, verified: await atStage("verify", () => opts.verify(r)) };
+  } catch (e) {
+    const status = e?.status;
+    if (!hinted || status !== 401) throw e;
+    const again = await signInWithBwalletX({ ...opts, wallet: r.wallet, identityKey: void 0, skipWaitForAuthentication: true });
+    return { result: again, verified: await atStage("verify", () => opts.verify(again)) };
+  }
+}
+async function atStage(stage, run) {
+  try {
+    return await run();
+  } catch (e) {
+    const err = e instanceof Error ? e : new Error(String(e));
+    if (!err.stage) Object.assign(err, { stage });
+    throw err;
+  }
+}
+
+// src/wallets.ts
+import { WalletClient as WalletClient2 } from "@bsv/sdk";
+async function brc100Connected(wallet, o, c = {}) {
+  if (c.identity === false) return { wallet, payer: wallet, identityKey: null, optionId: o.id, kind: o.kind };
+  await waitIfLocked(wallet);
+  const { publicKey } = await wallet.getPublicKey({ identityKey: true });
+  return { wallet, payer: wallet, identityKey: publicKey, optionId: o.id, kind: o.kind };
+}
+function brc100Option(wallet, info) {
+  const opt = {
+    id: info.id,
+    name: info.name,
+    icon: info.icon,
+    rdns: info.rdns,
+    kind: "brc100",
+    isBwalletX: info.isBwalletX ?? false,
+    substrate: info.substrate,
+    wallet,
+    connect: (c) => brc100Connected(wallet, opt, c)
+  };
+  return opt;
+}
+function pairingOption(pairing) {
+  const opt = {
+    id: "bwalletx-pairing",
+    name: "bWalletX on your phone",
+    kind: "pairing",
+    isBwalletX: true,
+    substrate: "pairing",
+    async connect(c) {
+      const p = typeof pairing === "function" ? pairing() : pairing;
+      const w = await restorePairing(p) ?? await pairBwalletX(p);
+      return brc100Connected(w, opt, c);
+    }
+  };
+  return opt;
+}
+function handcashAdapter(o) {
+  const opt = {
+    id: "handcash",
+    name: "HandCash",
+    icon: o.icon,
+    kind: "handcash",
+    isBwalletX: false,
+    substrate: "adapter",
+    async connect() {
+      const p = await o.login();
+      return {
+        wallet: null,
+        payer: o.pay ? { pay: o.pay } : null,
+        identityKey: p.identityKey ?? null,
+        handle: p.handle,
+        paymail: p.paymail ?? `${p.handle.replace(/^\$/, "")}@handcash.io`,
+        optionId: opt.id,
+        kind: "handcash",
+        transitional: true
+      };
+    }
+  };
+  return opt;
+}
+var NAMES = { [RDNS_EXTENSION]: "bWalletX", "space.bwallet.mobile": "bWalletX" };
+async function probe(substrate, ms) {
+  try {
+    const w = new WalletClient2(substrate);
+    const ok = await Promise.race([w.isAuthenticated({}).then(() => true), new Promise((r) => setTimeout(() => r(false), ms))]);
+    return ok ? w : null;
+  } catch {
+    return null;
+  }
+}
+function cwiIsAnnounced(cwi, announced) {
+  return announced.some((o) => o.wallet === cwi || o.rdns === RDNS_MOBILE);
+}
+async function discoverWallets(o = {}) {
+  const out = [];
+  const ms = o.ms ?? 300;
+  if (typeof window !== "undefined") {
+    const seen = /* @__PURE__ */ new Map();
+    const onAnnounce = (e) => {
+      const d = e.detail;
+      if (!d?.wallet) return;
+      const rdns = d.info?.rdns ?? d.info?.uuid ?? `wallet-${seen.size}`;
+      if (seen.has(rdns)) return;
+      const isB = BWALLETX_RDNS.includes(rdns);
+      const substrate = rdns === RDNS_EXTENSION ? "extension" : rdns === RDNS_MOBILE ? "in-app" : "injected";
+      seen.set(rdns, brc100Option(d.wallet, { id: rdns, rdns, name: NAMES[rdns] ?? d.info?.name ?? rdns, icon: d.info?.icon, isBwalletX: isB, substrate }));
+    };
+    window.addEventListener("brc100:announceWallet", onAnnounce);
+    window.dispatchEvent(new Event("brc100:requestWallet"));
+    const local = o.probeLocal ? Promise.all([probe("json-api", ms), probe("Cicada", ms)]) : Promise.resolve([null, null]);
+    await new Promise((r) => setTimeout(r, seen.size > 0 || window.CWI ? Math.min(ms, 50) : ms));
+    window.removeEventListener("brc100:announceWallet", onAnnounce);
+    out.push(...seen.values());
+    if (![...seen.values()].some((w) => w.isBwalletX) && isFramed()) {
+      const x = await probeXdm(Math.max(ms, 1200));
+      if (x) out.push(brc100Option(x, { id: "bwalletx-xdm", name: "bWalletX", isBwalletX: true, substrate: "xdm" }));
+    }
+    const cwi = window.CWI;
+    if (cwi && !cwiIsAnnounced(cwi, [...seen.values()])) {
+      out.push(brc100Option(cwi, { id: "window.CWI", name: seen.size ? "Another browser wallet" : "Browser wallet", isBwalletX: false, substrate: "window.CWI" }));
+    }
+    const [json, cicada] = await local;
+    if (json) out.push(brc100Option(json, { id: "localhost:3321", name: "Desktop wallet (localhost:3321)", substrate: "json-api" }));
+    if (cicada) out.push(brc100Option(cicada, { id: "localhost:3301", name: "Desktop wallet (localhost:3301)", substrate: "cicada" }));
+  }
+  if (o.pairing) out.push(pairingOption(o.pairing));
+  out.push(...o.extra ?? []);
+  const rank = (w) => w.isBwalletX ? 0 : w.kind === "handcash" ? 2 : 1;
+  return out.map((w, i) => ({ w, i })).sort((a, b) => rank(a.w) - rank(b.w) || a.i - b.i).map((x) => x.w);
+}
+var DESKTOP_OPTION_ID = "desktop";
+function desktopOption(ms = 1500) {
+  const opt = {
+    id: DESKTOP_OPTION_ID,
+    name: "Desktop wallet",
+    kind: "brc100",
+    isBwalletX: false,
+    substrate: "json-api",
+    async connect(c) {
+      const [json, cicada] = await Promise.all([probe("json-api", ms), probe("Cicada", ms)]);
+      const w = json ?? cicada;
+      if (!w) throw Object.assign(new Error("No desktop wallet answered on this computer"), { code: "NOT_FOUND" });
+      opt.wallet = w;
+      opt.substrate = json ? "json-api" : "cicada";
+      return brc100Connected(w, opt, c);
+    }
+  };
+  return opt;
+}
+function autoChoice(list, force = false) {
+  const auto = list.filter((w) => !isLocalDesktop(w));
+  const detected = auto.filter((w) => w.kind === "brc100");
+  const others = auto.filter((w) => w.kind === "handcash" || w.kind === "custom");
+  const hasLocal = auto.length !== list.length;
+  if (force) return detected[0] ?? auto.find((w) => w.kind !== "pairing") ?? auto[0] ?? null;
+  if (!list.length) return null;
+  if (list.length === 1) return hasLocal ? void 0 : list[0];
+  if (detected.length === 1 && others.length === 0 && !hasLocal) return detected[0];
+  if (detected.length === 0 && others.length === 0) return auto[0] ?? void 0;
+  return void 0;
+}
+function isLocalDesktop(w) {
+  return w.substrate === "json-api" || w.substrate === "cicada" || w.id === "localhost:3321" || w.id === "localhost:3301" || w.id === DESKTOP_OPTION_ID;
+}
+
+// src/account.ts
+var PAYMAIL_LOOKUP_URL = "https://pay.bwallet.space/api/paymail/lookup?key=";
+var BAVATAR_URL = "https://chat.bwalletx.com/api/bavatar/";
+function shortKey(key) {
+  return key.length > 12 ? `${key.slice(0, 6)}\u2026${key.slice(-4)}` : key;
+}
+function accountLabel(a) {
+  if (a.paymail && /@bwalletx\.com$/i.test(a.paymail)) return "$" + a.paymail.split("@")[0];
+  if (a.handle) return a.handle;
+  if (a.paymail) return a.paymail;
+  return a.identityKey ? shortKey(a.identityKey) : "";
+}
+function avatarUrlFor(identityKey) {
+  return identityKey && /^0[23][0-9a-fA-F]{64}$/.test(identityKey) ? `${BAVATAR_URL}${identityKey.toLowerCase()}.png` : null;
+}
+var cache = /* @__PURE__ */ new Map();
+function lookupPaymail(identityKey, url = PAYMAIL_LOOKUP_URL) {
+  if (url === "off" || typeof fetch === "undefined") return Promise.resolve(null);
+  const k = `${url}|${identityKey}`;
+  let p = cache.get(k);
+  if (!p) {
+    p = fetch(url + encodeURIComponent(identityKey)).then((r) => r.ok ? r.json() : null).then((j) => j && typeof j.paymail === "string" ? j.paymail : null).catch(() => null);
+    cache.set(k, p);
+  }
+  return p;
+}
+function isUserRejection(e) {
+  const code = e?.code;
+  if (code === "ERR_PERMISSION_DENIED" || code === 4001) return true;
+  const msg = e instanceof Error ? e.message : String(e ?? "");
+  return /denied|reject|cancel|declin|refused|not now|user closed/i.test(msg);
+}
+function signInErrorText(e) {
+  if (isUserRejection(e)) return "Sign-in cancelled";
+  if (e?.name === "MetanetUnreachableError") return e.message;
+  const code = e?.code;
+  if (code === "NOT_FOUND") return "bWalletX was not found in this browser";
+  const msg = e instanceof Error ? e.message : String(e ?? "");
+  if (/lock/i.test(msg)) return "Your wallet is locked. Unlock it and try again";
+  if (/timeout|timed out|expired/i.test(msg)) return "The wallet did not answer in time";
+  if (/origin/i.test(msg)) return "This page is not on the site\u2019s configured origin";
+  return "Sign-in failed";
+}
+async function copyText(text) {
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var IDENTITY_HINT_KEY = "bwx:identityKey";
+function rememberedIdentity() {
+  try {
+    const k = globalThis.localStorage?.getItem(IDENTITY_HINT_KEY) ?? "";
+    return /^0[23][0-9a-f]{64}$/i.test(k) ? k : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function rememberIdentity(key) {
+  try {
+    if (key) globalThis.localStorage?.setItem(IDENTITY_HINT_KEY, key);
+    else globalThis.localStorage?.removeItem(IDENTITY_HINT_KEY);
+  } catch {
+  }
+}
+
+// src/device.ts
+function isTouchDevice(env = globalThis) {
+  const nav = env.navigator;
+  if (!nav) return false;
+  const ua = nav.userAgent ?? "";
+  if (/Android|iPhone|iPad|iPod|Mobile|Silk|Kindle/i.test(ua)) return true;
+  if (/Macintosh/.test(ua) && (nav.maxTouchPoints ?? 0) > 1) return true;
+  try {
+    return !!env.matchMedia?.("(pointer: coarse)").matches && !env.matchMedia?.("(hover: hover)").matches;
+  } catch {
+    return false;
+  }
+}
+
+// src/metanet.ts
+import { WalletClient as WalletClient3 } from "@bsv/sdk";
+var METANET_TYPE = "metanet";
+var METANET_OPTION_ID = METANET_TYPE;
+var METANET_JSON_API = "http://localhost:3321";
+var METANET_LABEL = "Use Metanet Desktop or another BRC-100 wallet";
+var METANET_NOTE = "Metanet Desktop must be running on this computer";
+var METANET_REMEMBERED_NOTE = "Signs in with Metanet Desktop on this computer.";
+var NOT_YOU_LABEL = "Not you? Use another wallet";
+var METANET_UNREACHABLE = "We couldn\u2019t reach Metanet Desktop. Open it, then try again.";
+var METANET_ANSWER_MS = 4e3;
+var METANET_SILENT_MS = 2e3;
+var MetanetUnreachableError = class extends Error {
+  code = "NOT_FOUND";
+  constructor() {
+    super(METANET_UNREACHABLE);
+    this.name = "MetanetUnreachableError";
+  }
+};
+function inAnyFrame(win = typeof window === "undefined" ? void 0 : window) {
+  if (!win) return false;
+  try {
+    return win.top !== win.self;
+  } catch {
+    return true;
+  }
+}
+function metanetOffered(env = {}) {
+  const win = env.window ?? (typeof window === "undefined" ? void 0 : window);
+  if (!win) return false;
+  const nav = env.navigator ?? (typeof navigator === "undefined" ? void 0 : navigator);
+  const mm = env.matchMedia ?? (typeof matchMedia === "undefined" ? void 0 : (q) => matchMedia(q));
+  return !isTouchDevice({ navigator: nav, matchMedia: mm }) && !inAnyFrame(win);
+}
+function client(o) {
+  if (o.make) return o.make();
+  const originator = o.originator ?? (typeof location !== "undefined" && location.host ? location.host : void 0);
+  return new WalletClient3("json-api", originator);
+}
+async function answers(wallet) {
+  return Promise.resolve().then(() => wallet.getVersion({})).then((v) => typeof v?.version === "string", () => false);
+}
+async function connectMetanetDesktop(o = {}) {
+  let wallet;
+  try {
+    wallet = client(o);
+  } catch {
+    throw new MetanetUnreachableError();
+  }
+  let timer;
+  const ok = await Promise.race([answers(wallet), new Promise((r) => timer = setTimeout(() => r(false), o.timeoutMs ?? METANET_ANSWER_MS))]);
+  clearTimeout(timer);
+  if (!ok) throw new MetanetUnreachableError();
+  return wallet;
+}
+function metanetOption(o = {}) {
+  const opt = {
+    id: METANET_OPTION_ID,
+    name: METANET_LABEL,
+    kind: "brc100",
+    isBwalletX: false,
+    substrate: "json-api",
+    async connect() {
+      const wallet = await connectMetanetDesktop(o);
+      opt.wallet = wallet;
+      await waitIfLocked(wallet);
+      const { publicKey } = await wallet.getPublicKey({ identityKey: true });
+      return { wallet, payer: wallet, identityKey: publicKey, optionId: opt.id, kind: "brc100" };
+    }
+  };
+  return opt;
+}
+var KNOWN_KEYS_KEY = "bwx:known-keys";
+var KEY_RE = /^0[23][0-9a-f]{64}$/;
+var MAX_KNOWN = 8;
+function knownIdentityKeys() {
+  try {
+    const v = JSON.parse(globalThis.localStorage?.getItem(KNOWN_KEYS_KEY) || "[]");
+    return Array.isArray(v) ? v.filter((k) => typeof k === "string" && KEY_RE.test(k)) : [];
+  } catch {
+    return [];
+  }
+}
+function isKnownIdentityKey(key) {
+  if (!key) return false;
+  const k = key.toLowerCase();
+  if (!KEY_RE.test(k)) return false;
+  return knownIdentityKeys().includes(k) || rememberedIdentity()?.toLowerCase() === k;
+}
+function rememberKnownIdentityKey(key) {
+  const k = (key ?? "").toLowerCase();
+  if (!KEY_RE.test(k)) return;
+  try {
+    const list = [k, ...knownIdentityKeys().filter((x) => x !== k)].slice(0, MAX_KNOWN);
+    globalThis.localStorage?.setItem(KNOWN_KEYS_KEY, JSON.stringify(list));
+  } catch {
+  }
+}
+var triedThisLoad = false;
+function silentAttemptUsed() {
+  return triedThisLoad;
+}
+function claimSilentAttempt() {
+  if (triedThisLoad) return false;
+  triedThisLoad = true;
+  return true;
+}
+function resetSilentAttempt() {
+  triedThisLoad = false;
+}
+async function trySilentMetanet(o = {}) {
+  if (!metanetOffered()) return { ok: false, stop: "not-here" };
+  if (!claimSilentAttempt()) return { ok: false, stop: "used" };
+  const run = async () => {
+    let wallet;
+    try {
+      wallet = client(o);
+    } catch {
+      return { ok: false, stop: "unreachable" };
+    }
+    if (!await answers(wallet)) return { ok: false, stop: "unreachable" };
+    const unlocked = await Promise.resolve().then(() => wallet.isAuthenticated({})).then((r2) => r2?.authenticated === true, () => false);
+    if (!unlocked) return { ok: false, stop: "locked" };
+    const identityKey = await Promise.resolve().then(() => wallet.getPublicKey({ identityKey: true })).then((r2) => r2.publicKey, () => null);
+    if (!identityKey) return { ok: false, stop: "unreachable" };
+    if (!isKnownIdentityKey(identityKey)) return { ok: false, stop: "unknown-key" };
+    return { ok: true, wallet, identityKey };
+  };
+  let timer;
+  const r = await Promise.race([
+    run().catch(() => ({ ok: false, stop: "unreachable" })),
+    new Promise((res) => timer = setTimeout(() => res({ ok: false, stop: "slow" }), o.windowMs ?? METANET_SILENT_MS))
+  ]);
+  clearTimeout(timer);
+  return r;
+}
+var warnedLogout = false;
+var isProduction = () => {
+  try {
+    return globalThis.process?.env?.NODE_ENV === "production";
+  } catch {
+    return false;
+  }
+};
+function warnIfNoLogout(o) {
+  if (!o.verifyUrl || o.logoutUrl || warnedLogout || isProduction() || typeof console === "undefined") return false;
+  warnedLogout = true;
+  console.warn(
+    `@bwalletx/connect: ${o.where} has a verify URL but no logout URL. Set it: "Not you? Use another wallet" and Disconnect must be able to end a session the verify route created.`
+  );
+  return true;
+}
+
+// src/choice.ts
+var BWALLETX_TYPE = "bwalletx";
+function substrateOf(o) {
+  if (o.substrate) return o.substrate;
+  if (o.kind === "pairing") return "pairing";
+  if (o.isBwalletX && o.kind === "brc100") return o.rdns === RDNS_MOBILE ? "in-app" : o.id === "bwalletx-xdm" ? "xdm" : "extension";
+  if (o.kind === "handcash" || o.kind === "custom") return "adapter";
+  if (o.rdns === RDNS_EXTENSION) return "extension";
+  if (o.rdns === RDNS_MOBILE) return "in-app";
+  if (o.id === "window.CWI") return "window.CWI";
+  if (o.id === "localhost:3321" || o.id === DESKTOP_OPTION_ID) return "json-api";
+  if (o.id === "localhost:3301") return "cicada";
+  return "injected";
+}
+function walletTypeOf(o) {
+  return o.isBwalletX ? BWALLETX_TYPE : o.rdns ?? o.id;
+}
+var OWN_MARKERS = ["extension", "in-app", "xdm"];
+function isPresentBwalletX(o) {
+  return o.isBwalletX && o.kind === "brc100" && !!o.wallet && OWN_MARKERS.includes(substrateOf(o));
+}
+function hasBwalletX(list) {
+  return list.some(isPresentBwalletX);
+}
+function otherDetected(list) {
+  return list.filter((o) => !o.isBwalletX && o.kind === "brc100" && !!o.wallet);
+}
+function chooserOrder(list) {
+  const rank = (o) => isPresentBwalletX(o) ? 0 : o.isBwalletX ? 1 : o.kind === "brc100" ? 2 : o.kind === "custom" ? 3 : 4;
+  return list.map((o, i) => ({ o, i })).sort((a, b) => rank(a.o) - rank(b.o) || a.i - b.i).map((x) => x.o);
+}
+function decideWallet(list, o = {}) {
+  if (o.walletId) {
+    const w = list.find((x) => x.id === o.walletId);
+    if (w) return { option: w, reason: "requested" };
+  }
+  if (o.chooser) return { option: null, reason: list.length || o.picker !== false ? "chooser" : "none" };
+  if (o.fastPath === false) {
+    const a = autoChoice([...list], o.picker === false);
+    return a === void 0 ? { option: null, reason: "chooser" } : a === null ? { option: null, reason: "none" } : { option: a, reason: "legacy" };
+  }
+  if (o.remembered && !o.preferBwalletX) {
+    const m = matchRemembered(list, o.remembered);
+    if (m) return { option: m, reason: "remembered" };
+  }
+  const b = list.find(isPresentBwalletX);
+  if (b) return { option: b, reason: "bwalletx" };
+  if (o.picker === false) {
+    const phone = list.find((x) => x.isBwalletX);
+    return phone ? { option: phone, reason: "bwalletx-phone" } : { option: null, reason: "none" };
+  }
+  return list.length ? { option: null, reason: "chooser" } : { option: null, reason: "none" };
+}
+function outcomeOf(e) {
+  const err = e;
+  if (err?.code === "NOT_FOUND") return "not-found";
+  if (err?.name === "AbortError" || err?.message === "cancelled") return "cancelled";
+  if (isUserRejection(e)) return "rejected";
+  return "error";
+}
+function attemptFor(option, outcome, startedAt, now = Date.now()) {
+  return {
+    walletType: option ? walletTypeOf(option) : null,
+    substrate: option ? substrateOf(option) : null,
+    outcome,
+    ms: Math.max(0, Math.round(now - startedAt))
+  };
+}
+function reportAttempt(hook, a) {
+  if (!hook) return;
+  try {
+    hook(Object.freeze({ walletType: a.walletType, substrate: a.substrate, outcome: a.outcome, ms: a.ms }));
+  } catch {
+  }
+}
+var WALLET_CHOICE_KEY = "bwx:wallet";
+var SUBSTRATES = ["extension", "in-app", "xdm", "injected", "window.CWI", "json-api", "cicada", "pairing", "adapter"];
+var TYPE_RE = /^[A-Za-z0-9._:-]{1,64}$/;
+var KEY_LIKE = /^(0[23][0-9a-f]{64}|04[0-9a-f]{128}|[13][1-9A-HJ-NP-Za-km-z]{25,34})$/i;
+function isRememberable(o) {
+  const t = walletTypeOf(o);
+  return substrateOf(o) !== "window.CWI" && TYPE_RE.test(t) && !KEY_LIKE.test(t);
+}
+function isExplicitPick(o, reason) {
+  return o.isBwalletX || reason === "chooser" || reason === "requested" || reason === "remembered";
+}
+function rememberWalletChoice(o) {
+  try {
+    if (!o) return void globalThis.localStorage?.removeItem(WALLET_CHOICE_KEY);
+    if (!isRememberable(o)) return;
+    const v = { type: walletTypeOf(o), substrate: substrateOf(o), v: 1 };
+    globalThis.localStorage?.setItem(WALLET_CHOICE_KEY, JSON.stringify(v));
+  } catch {
+  }
+}
+function rememberedWalletChoice() {
+  try {
+    const raw = globalThis.localStorage?.getItem(WALLET_CHOICE_KEY);
+    if (!raw) return null;
+    const j = JSON.parse(raw);
+    if (typeof j.type !== "string" || !TYPE_RE.test(j.type) || KEY_LIKE.test(j.type)) return null;
+    if (!SUBSTRATES.includes(j.substrate) || j.substrate === "window.CWI") return null;
+    return { type: j.type, substrate: j.substrate };
+  } catch {
+    return null;
+  }
+}
+function forgetWalletChoice() {
+  rememberWalletChoice(null);
+}
+function needsBwalletX(type) {
+  return !!type && type !== BWALLETX_TYPE;
+}
+function tapGoesElsewhere(type) {
+  return needsBwalletX(type) && type !== METANET_TYPE && type !== DESKTOP_OPTION_ID;
+}
+function isLocalDesktopType(r) {
+  return r.type === METANET_TYPE || r.type === DESKTOP_OPTION_ID || r.substrate === "json-api" || r.substrate === "cicada";
+}
+function matchRemembered(list, r) {
+  if (isLocalDesktopType(r)) return null;
+  if (r.type === BWALLETX_TYPE) {
+    return (r.substrate === "pairing" ? list.find((o) => o.kind === "pairing") : list.find(isPresentBwalletX)) ?? null;
+  }
+  return list.find((o) => !o.isBwalletX && !isLocalDesktop(o) && isRememberable(o) && walletTypeOf(o) === r.type) ?? null;
+}
+var ATTACHABLE = ["extension", "in-app", "xdm", "injected"];
+function planAutoConnect(o) {
+  const r = o.remembered;
+  if (!r || o.enabled === false) return { action: "none", remembered: r, needsBwalletX: false };
+  if (r.type === METANET_TYPE) {
+    return { action: o.metanetHere ?? metanetOffered() ? "silent-metanet" : "none", remembered: r, needsBwalletX: false };
+  }
+  if (isLocalDesktopType(r)) return { action: "none", remembered: r, needsBwalletX: false };
+  const action = o.signedIn && ATTACHABLE.includes(r.substrate) ? "attach" : "wait-for-tap";
+  return { action, remembered: r, needsBwalletX: needsBwalletX(r.type) };
+}
+async function attachRemembered(r, o = {}) {
+  if (!ATTACHABLE.includes(r.substrate)) return null;
+  const list = await discoverWallets({ ms: o.ms });
+  const m = matchRemembered(list, r);
+  return m && m.kind === "brc100" && m.wallet && ATTACHABLE.includes(substrateOf(m)) ? m : null;
+}
+
+// src/modal.ts
+import qrcode from "qrcode-generator";
+
+// src/access-client.ts
+import { Hash, PublicKey as PublicKey2, Utils } from "@bsv/sdk";
+var ONESAT = [0, "onesat"];
+var LEGACY_ONESAT = [0, "p 1sat"];
+function toAccessError(e) {
+  if (e instanceof AccessError) return e;
+  const err = e;
+  const msg = String(err?.message ?? e ?? "");
+  if (err?.code === "NOT_FOUND") return new AccessError("not_installed", msg);
+  if (/reject|denied|declin|cancel|user/i.test(msg) || err?.code === "ERR_USER_REJECTED" || err?.status === 4001) {
+    return new AccessError("user_rejected", msg);
+  }
+  return new AccessError("bad_request", msg || "access failed");
+}
+function throwIfAccessError(body) {
+  const b = body;
+  if (b && typeof b.error === "string") throw new AccessError(b.error, b.message, { have: b.have, need: b.need });
+}
+function hash160FromP2pkh(script) {
+  const m = /^76a914([0-9a-f]{40})88ac$/i.exec(script.slice(-50));
+  return m ? m[1].toLowerCase() : null;
+}
+async function proveHoldings(wallet, challenge, tokenId, basket = "bsv21") {
+  const bare = tokenId.replace(/^bsv21:/, "");
+  const list = await wallet.listOutputs({ basket, include: "locking scripts", includeCustomInstructions: true, limit: 1e4 });
+  const byKey = /* @__PURE__ */ new Map();
+  const data = challengeBytes(challenge);
+  for (const out of list.outputs) {
+    if (byKey.size >= MAX_HOLDING_PROOFS) break;
+    let ci = {};
+    try {
+      ci = JSON.parse(out.customInstructions ?? "{}");
+    } catch {
+      continue;
+    }
+    if (ci.id !== bare || !ci.keyID) continue;
+    const want = out.lockingScript ? hash160FromP2pkh(out.lockingScript) : null;
+    const counterparty = ci.counterparty ?? "self";
+    for (const protocolID of ci.protocolID ? [ci.protocolID] : [ONESAT, LEGACY_ONESAT]) {
+      const { publicKey } = await wallet.getPublicKey({ protocolID, keyID: ci.keyID, counterparty });
+      const h = Utils.toHex(Hash.hash160(PublicKey2.fromString(publicKey).encode(true)));
+      if (want && h !== want) continue;
+      const existing = byKey.get(publicKey);
+      if (existing) {
+        existing.outpoints.push(out.outpoint.replace(".", "_"));
+        break;
+      }
+      const { signature } = await wallet.createSignature({ protocolID, keyID: ci.keyID, counterparty, data });
+      byKey.set(publicKey, { pubkey: publicKey, signature: Array.from(signature), outpoints: [out.outpoint.replace(".", "_")] });
+      break;
+    }
+  }
+  return [...byKey.values()];
+}
+async function requestAccess(o) {
+  let wallet;
+  try {
+    ({ wallet } = await connectBwalletX({ wallet: o.wallet, pairing: o.pairing, discoverMs: o.discoverMs }));
+  } catch (e) {
+    throw e?.code === "NOT_FOUND" ? new AccessError("not_installed") : toAccessError(e);
+  }
+  try {
+    const { publicKey: identityKey } = await wallet.getPublicKey({ identityKey: true });
+    const { challenge } = await o.challenge(identityKey);
+    const c = parseAccessChallenge(challenge);
+    if (c.sub && c.sub !== identityKey.toLowerCase()) throw new AccessError("wrong_account");
+    if (Date.now() / 1e3 >= c.exp) throw new AccessError("expired");
+    const { signature } = await wallet.createSignature({
+      protocolID: ACCESS_PROTOCOL,
+      keyID: c.nonce,
+      counterparty: "anyone",
+      data: challengeBytes(challenge)
+    });
+    const response = { v: 1, challenge, identityKey, signature: Array.from(signature) };
+    if (c.require.token) response.holdings = await proveHoldings(wallet, challenge, c.require.token.id, o.tokenBasket);
+    let verified;
+    if (o.verify) {
+      verified = await o.verify(response);
+      throwIfAccessError(verified);
+    }
+    return { response, verified, wallet };
+  } catch (e) {
+    throw toAccessError(e);
+  }
+}
+
+// src/connect-flow.ts
+async function runConnect(o) {
+  const started = Date.now();
+  const { list } = o;
+  let choice = null;
+  let reason = "none";
+  try {
+    if (o.metanet) {
+      if (!metanetOffered()) throw Object.assign(new Error("Metanet Desktop runs on a computer, outside any frame."), { code: "NOT_SUPPORTED" });
+      choice = metanetOption(typeof o.metanet === "object" ? o.metanet : {});
+      reason = "requested";
+      return await finish(o, choice, reason, started);
+    }
+    const d = decideWallet(list, {
+      walletId: o.walletId,
+      chooser: o.chooser,
+      picker: o.picker,
+      fastPath: o.fastPath,
+      remembered: o.remembered,
+      preferBwalletX: o.preferBwalletX
+    });
+    choice = d.option;
+    reason = d.reason;
+    if (!choice && d.reason === "chooser") choice = await o.pick(list);
+    if (!choice) {
+      if (d.reason === "none" || !list.length) throw Object.assign(new Error("No wallet found. Get bWalletX at bwalletx.com."), { code: "NOT_FOUND" });
+      reportAttempt(o.onAttempt, attemptFor(null, "cancelled", started));
+      return null;
+    }
+    return await finish(o, choice, reason, started);
+  } catch (e) {
+    reportAttempt(o.onAttempt, attemptFor(choice, outcomeOf(e), started));
+    throw e;
+  }
+}
+async function finish(o, choice, reason, started) {
+  const signIn = !!(o.challengeUrl && o.verifyUrl) && choice.kind !== "handcash";
+  const cw = await choice.connect(signIn ? { identity: false } : void 0);
+  let handle = cw.handle ?? null;
+  let paymail = cw.paymail ?? null;
+  let identityKey = cw.identityKey;
+  let signedIn = false;
+  if (cw.wallet && signIn) {
+    const { result, verified } = await signInAndVerify({
+      wallet: cw.wallet,
+      identityKey: cw.identityKey ?? void 0,
+      // Metanet's connect() just checked the lock: don't ask again (rule 7, the minimum).
+      skipWaitForAuthentication: choice.id === METANET_OPTION_ID,
+      // The key that signed in here last time: a repeat sign-in is then the signature alone.
+      identityKeyHint: rememberedIdentity(),
+      challengeNeedsIdentityKey: o.challengeNeedsIdentityKey,
+      challenge: (key) => o.post(o.challengeUrl, key ? { identityKey: key } : {}),
+      verify: (r) => o.post(o.verifyUrl, { identityKey: r.identityKey, nonce: r.nonce, signature: r.signature })
+    });
+    rememberIdentity(result.identityKey);
+    identityKey = result.identityKey;
+    handle = verified.handle ?? handle;
+    paymail = verified.paymail ?? paymail;
+    signedIn = true;
+  } else if (cw.wallet && !identityKey) {
+    identityKey = (await cw.wallet.getPublicKey({ identityKey: true })).publicKey;
+  }
+  if (o.remember && isExplicitPick(choice, reason)) rememberWalletChoice(choice);
+  if (o.remember && signedIn) rememberKnownIdentityKey(identityKey);
+  reportAttempt(o.onAttempt, attemptFor(choice, signedIn ? "signed-in" : "connected", started));
+  return { connected: cw, identityKey, handle, paymail, signedIn, walletType: walletTypeOf(choice), substrate: substrateOf(choice), reason };
+}
+async function runSilentMetanet(o = {}) {
+  const s = await trySilentMetanet(o);
+  if (!s.ok || o.isAbandoned?.()) return null;
+  const started = Date.now();
+  const opt = metanetOption(o);
+  opt.wallet = s.wallet;
+  const cw = { wallet: s.wallet, payer: s.wallet, identityKey: s.identityKey, optionId: METANET_OPTION_ID, kind: "brc100" };
+  const done = (signedIn, handle = null, paymail = null) => {
+    rememberWalletChoice(opt);
+    if (signedIn) rememberKnownIdentityKey(s.identityKey);
+    reportAttempt(o.onAttempt, attemptFor(opt, signedIn ? "signed-in" : "connected", started));
+    return { connected: cw, identityKey: s.identityKey, handle, paymail, signedIn, walletType: walletTypeOf(opt), substrate: "json-api", reason: "remembered" };
+  };
+  if (o.sessionKey !== void 0 && o.sessionKey !== null) {
+    return o.sessionKey.toLowerCase() === s.identityKey.toLowerCase() ? done(true) : null;
+  }
+  if (!o.challengeUrl || !o.verifyUrl || !o.post) return done(false);
+  if (!isKnownIdentityKey(s.identityKey)) return null;
+  try {
+    o.onSignIn?.();
+    const post = o.post;
+    const { result, verified } = await signInAndVerify({
+      wallet: s.wallet,
+      identityKey: s.identityKey,
+      skipWaitForAuthentication: true,
+      // trySilentMetanet just saw it unlocked
+      challenge: (key) => post(o.challengeUrl, key ? { identityKey: key } : {}),
+      verify: (r) => post(o.verifyUrl, { identityKey: r.identityKey, nonce: r.nonce, signature: r.signature })
+    });
+    if (o.isAbandoned?.()) {
+      await Promise.resolve(o.logout?.()).catch(() => void 0);
+      return null;
+    }
+    rememberIdentity(result.identityKey);
+    return done(true, verified.handle ?? null, verified.paymail ?? null);
+  } catch (e) {
+    reportAttempt(o.onAttempt, attemptFor(opt, outcomeOf(e), started));
+    return null;
+  }
+}
+
+// src/element.ts
+var SIGNIN_TAG = "bwalletx-signin";
+var GET_URL = "https://bwalletx.com/get";
+var WEB_WALLET_URL = "https://web.bwalletx.com";
+var VERBS = { signin: "Sign in with", continue: "Continue with", connect: "Connect", get: "Get", play: "Play with" };
+function signinText(label = "signin", brand = "bWalletX") {
+  return `${VERBS[label] ?? VERBS.signin} ${brand}`;
+}
+var uid = 0;
+function markSvg(px = 20) {
+  const n = ++uid;
+  return `<svg viewBox="23 8 74 100" width="${Math.round(px * 0.74)}" height="${px}" aria-hidden="true" focusable="false"><defs><linearGradient id="bwxg${n}" gradientUnits="userSpaceOnUse" x1="0" y1="12" x2="0" y2="105"><stop offset="0" stop-color="#FFE58A"/><stop offset=".55" stop-color="#FFD24D"/><stop offset="1" stop-color="#C98F00"/></linearGradient><mask id="bwxh${n}"><rect width="140" height="140" fill="#fff"/><circle cx="60" cy="72" r="15" fill="#000"/></mask></defs><g fill="url(#bwxg${n})" mask="url(#bwxh${n})"><polygon points="45,12 45,76 27,76 27,30"/><circle cx="60" cy="72" r="33"/></g></svg>`;
+}
+var SIGNIN_CSS = `
+:host{display:inline-block;vertical-align:middle;font-family:Inter,ui-sans-serif,system-ui,-apple-system,"Segoe UI",Roboto,sans-serif}
+:host([full-width]){display:block;width:100%}
+:host([hidden]){display:none}
+button{all:unset;box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;gap:12px;width:100%;cursor:pointer;
+ padding:16px 20px;border-radius:12px;font-size:16px;font-weight:700;line-height:1.2;text-align:left;
+ background:linear-gradient(180deg,#fcd34d,#f59e0b);color:#000;
+ box-shadow:0 10px 15px -3px rgba(245,158,11,.2),0 4px 6px -4px rgba(245,158,11,.2);
+ transition:background .15s,transform .1s,box-shadow .15s,border-color .15s;-webkit-tap-highlight-color:transparent}
+button:hover{background:linear-gradient(180deg,#fde68a,#fbbf24)}
+button:active{transform:translateY(1px);background:linear-gradient(180deg,#fbbf24,#d97706)}
+button:focus-visible{outline:2px solid #b45309;outline-offset:3px}
+button:disabled{opacity:.6;cursor:not-allowed;transform:none}
+button[aria-busy=true]{cursor:wait}
+.mark{display:inline-flex;align-items:center;justify-content:center;flex:none;width:28px;height:28px;border-radius:50%;background:#000}
+.txt{display:flex;flex-direction:column;align-items:flex-start;min-width:0}
+.txt b{font-weight:700;white-space:nowrap}
+.txt small{font-size:11px;font-weight:500;color:rgba(0,0,0,.65);white-space:nowrap}
+.spin{width:16px;height:16px;border-radius:50%;border:2px solid rgba(255,210,77,.35);border-top-color:#ffd24d;animation:r .8s linear infinite}
+@keyframes r{to{transform:rotate(360deg)}}
+@media (prefers-reduced-motion:reduce){button{transition:none}button:active{transform:none}.spin{animation:none;border-color:#ffd24d;border-right-color:transparent}}
+/* sizes */
+:host([size=md]) button{padding:10px 16px;border-radius:10px;font-size:15px;gap:10px}
+:host([size=md]) .mark{width:24px;height:24px}
+:host([size=md]) .txt small{font-size:10.5px}
+:host([size=sm]) button{padding:6px 12px 6px 6px;border-radius:8px;font-size:13px;gap:8px;min-height:36px}
+:host([size=sm]) .mark{width:22px;height:22px}
+:host([size=icon]) button{width:48px;height:48px;padding:0;border-radius:50%;gap:0}
+:host([size=icon]) .mark{width:34px;height:34px}
+/* themes */
+:host([theme=dark]) button{background:#0a0a0a;color:#fafafa;border:1px solid #3f3f46;box-shadow:none}
+:host([theme=dark]) button:hover{background:#18181b;border-color:rgba(251,191,36,.6)}
+:host([theme=dark]) button:active{background:#000}
+:host([theme=dark]) button:focus-visible{outline-color:#fcd34d}
+:host([theme=dark]) .mark{box-shadow:inset 0 0 0 1px #3f3f46}
+:host([theme=dark]) .txt small{color:rgba(255,255,255,.65)}
+:host([theme=light]) button{background:#fff;color:#09090b;border:1px solid #d4d4d8;box-shadow:0 1px 2px rgba(0,0,0,.06)}
+:host([theme=light]) button:hover{background:#fafafa;border-color:#f59e0b}
+:host([theme=light]) button:active{background:#f4f4f5}
+:host([theme=light]) .txt small{color:#52525b}
+/* not found */
+.nf{margin-top:8px;font-size:12px;line-height:1.4;color:#71717a;text-align:center}
+.nf a{color:inherit;font-weight:600;text-decoration:underline;text-underline-offset:2px}
+.nf a:focus-visible{outline:2px solid #b45309;outline-offset:2px;border-radius:2px}
+:host([theme=dark]) .nf,:host-context(.dark) .nf{color:#a1a1aa}
+.sr{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}
+/* pending: one plain line under the button */
+.note{margin:8px 0 0;width:0;min-width:100%;font-size:12px;line-height:1.4;color:#71717a;text-align:center;overflow-wrap:break-word}
+:host([theme=dark]) .note,:host-context(.dark) .note{color:#a1a1aa}
+/* "Other wallets" (0.5.6): one small link under the button */
+.ow{margin:8px 0 0;width:0;min-width:100%;font-size:12px;line-height:1.4;color:#71717a;text-align:center}
+:host([theme=dark]) .ow,:host-context(.dark) .ow{color:#a1a1aa}
+.sw{margin:8px 0 0;width:0;min-width:100%;font-size:12px;line-height:1.4;color:#a16207;text-align:center}
+:host([theme=dark]) .sw,:host-context(.dark) .sw{color:#fcd34d}
+.mn{margin:8px 0 0;width:0;min-width:100%;font-size:12px;line-height:1.4;color:#71717a;text-align:center}
+.mn small{display:block;font-size:11px;opacity:.85}
+:host([theme=dark]) .mn,:host-context(.dark) .mn{color:#a1a1aa}
+.lnk{all:unset;cursor:pointer;color:inherit;font-weight:600;text-decoration:underline;text-underline-offset:2px}
+.lnk:focus-visible{outline:2px solid #b45309;outline-offset:2px;border-radius:2px}
+/* error: one line plus Retry */
+.err{margin:0 0 8px;width:0;min-width:100%;font-size:13px;font-weight:600;line-height:1.4;color:#b91c1c;text-align:center;overflow-wrap:anywhere}
+:host([theme=dark]) .err,:host-context(.dark) .err{color:#fca5a5}
+/* signed in: the badge */
+button.chip{display:inline-flex;align-items:center;justify-content:flex-start;gap:10px;width:auto;max-width:100%;padding:5px 14px 5px 5px;border-radius:999px;
+ background:#0b0b0c;color:#ffd24d;border:1px solid rgba(255,210,77,.55);box-shadow:none;font-size:15px}
+button.chip:hover{background:#151517;border-color:#ffd24d}
+button.chip:active{background:#000;transform:none}
+button.chip:focus-visible{outline:2px solid #ffd24d;outline-offset:3px}
+:host([theme=light]) button.chip{background:#fff;color:#09090b;border-color:#f59e0b}
+:host([theme=light]) button.chip:hover{background:#fffbeb}
+:host([full-width]) button.chip{width:100%}
+.av{position:relative;flex:none;display:inline-grid;place-items:center;width:30px;height:30px;border-radius:50%;overflow:hidden;
+ background:radial-gradient(circle at 30% 30%,#ffe27a,#f5b800 55%,#b88600);color:#000;font-weight:800;font-size:14px}
+.av img{position:absolute;inset:0;width:100%;height:100%;object-fit:cover}
+.name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0;max-width:min(52vw,260px)}
+.dot{flex:none;width:8px;height:8px;border-radius:50%;background:#ffd24d;box-shadow:0 0 0 3px rgba(255,210,77,.22)}
+:host([size=sm]) button.chip{font-size:13px;padding:3px 12px 3px 3px;gap:8px}
+:host([size=sm]) .av{width:26px;height:26px}
+:host([size=icon]) button.chip{width:48px;height:48px;padding:0;justify-content:center}
+:host([size=icon]) .name,:host([size=icon]) .dot{display:none}
+:host([size=icon]) .av{width:40px;height:40px}
+`;
+var MENU_CSS = `
+:host{all:initial}
+.menu{position:fixed;z-index:2147483600;box-sizing:border-box;min-width:200px;padding:6px;border-radius:14px;background:#0b0b0c;color:#ffd24d;
+ border:1px solid rgba(255,210,77,.55);box-shadow:0 12px 32px rgba(0,0,0,.45);font:600 14px/1.3 Inter,ui-sans-serif,system-ui,-apple-system,"Segoe UI",Roboto,sans-serif}
+.who{padding:8px 10px 10px;font-size:12px;font-weight:500;color:#e7d9a8;overflow-wrap:anywhere;border-bottom:1px solid rgba(255,210,77,.3);margin-bottom:4px}
+.item{all:unset;box-sizing:border-box;display:block;width:100%;padding:11px 10px;border-radius:10px;cursor:pointer;color:#ffd24d}
+.item:hover,.item:focus-visible{background:#ffd24d;color:#000;outline:none}
+.tip{position:fixed;z-index:2147483600;box-sizing:border-box;padding:8px 12px;border-radius:10px;background:#0b0b0c;color:#e7d9a8;
+ border:1px solid rgba(255,210,77,.4);box-shadow:0 8px 24px rgba(0,0,0,.35);font:500 12px/1.4 Inter,ui-sans-serif,system-ui,-apple-system,"Segoe UI",Roboto,sans-serif}
+`;
+var PENDING_NOTE = "Sign in: shares only your public identity key, moves no money";
+var PENDING_LABEL = "Approve in bWalletX\u2026";
+var PENDING_LABEL_OTHER = "Approve in your wallet\u2026";
+var SWITCH_NOTE = "Some features need bWalletX";
+var CONTINUE_OTHER_LABEL = "Continue with your wallet";
+function walletGlyph(px) {
+  return `<svg viewBox="0 0 24 24" width="${px}" height="${px}" aria-hidden="true" focusable="false" fill="none" stroke="#FFD24D" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M19 7V5a1 1 0 0 0-1-1H5a2 2 0 0 0 0 4h15a1 1 0 0 1 1 1v4h-3a2 2 0 0 0 0 4h3a1 1 0 0 0 1-1v-2"/><path d="M3 6v12a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-3"/></svg>`;
+}
+function b64url2(bytes) {
+  let s = "";
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function buildAuthorizeUrl(p) {
+  const rnd = (n) => b64url2(crypto.getRandomValues(new Uint8Array(n)));
+  const verifier = rnd(32);
+  const state = rnd(16);
+  const nonce = rnd(16);
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
+  const u = new URL(p.authorizeUrl, typeof location !== "undefined" ? location.href : void 0);
+  const set = (k, v) => {
+    if (v) u.searchParams.set(k, v);
+  };
+  set("response_type", "code");
+  set("client_id", p.clientId);
+  set("redirect_uri", p.redirectUri);
+  set("scope", p.scope || "openid profile");
+  set("state", state);
+  set("nonce", nonce);
+  set("code_challenge", b64url2(digest));
+  set("code_challenge_method", "S256");
+  try {
+    sessionStorage.setItem("bwalletx:oauth", JSON.stringify({ verifier, state, nonce }));
+  } catch {
+  }
+  return u.toString();
+}
+async function postJson(url, body) {
+  const res = await fetch(url, { method: "POST", credentials: "include", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw Object.assign(new Error(data.error ?? `HTTP ${res.status}`), { status: res.status });
+  return data;
+}
+async function postAccess(url, body) {
+  const res = await fetch(url, { method: "POST", credentials: "include", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+  return res.json().catch(() => ({ error: "bad_request", message: `HTTP ${res.status}` }));
+}
+var OBSERVED = ["size", "theme", "label", "brand", "subtitle", "loading", "disabled", "full-width", "aria-label", "get-url", "web-url", "state", "identity-key", "paymail", "handle", "avatar-url", "error", "other-wallets", "challenge-url", "wallet-type", "switch-note", "remember", "metanet"];
+var STATES = ["signed-out", "restoring", "pending", "signed-in", "error"];
+function createClass() {
+  return class BwalletxSigninElement extends HTMLElement {
+    static get observedAttributes() {
+      return OBSERVED;
+    }
+    #root;
+    #notFound = false;
+    #busy = false;
+    #phase = "signed-out";
+    #account = null;
+    #error = "";
+    #restored = false;
+    #pendingLabel = PENDING_LABEL;
+    /** The wallet type signed in with here (0.6.0), for the Switch note. */
+    #signedType = null;
+    #menu = null;
+    /** (0.7.0) A Metanet sign-in (tapped or silent) is in flight. */
+    #viaMetanet = false;
+    /** (0.7.0) Bumped by "Not you?": a Metanet sign-in started before it lands nobody. */
+    #run = 0;
+    constructor() {
+      super();
+      this.#root = this.attachShadow({ mode: "open" });
+    }
+    connectedCallback() {
+      if (!this.#controlled && this.#stateful) warnIfNoLogout({ verifyUrl: this.#attr("verify-url"), logoutUrl: this.#attr("logout-url"), where: "<bwalletx-signin>" });
+      this.#render();
+      void this.#restore().then(() => this.#silentMetanet());
+    }
+    disconnectedCallback() {
+      this.#menu?.close(false);
+      this.#hideTip();
+    }
+    attributeChangedCallback() {
+      if (this.isConnected) this.#render();
+    }
+    /** The inner <button>, for focus() and tests. */
+    get button() {
+      return this.#root.querySelector("button");
+    }
+    get notFound() {
+      return this.#notFound;
+    }
+    /** The state shown now (the `state` attribute when set, else the element's own). */
+    get state() {
+      const a = this.#attr("state");
+      return a && STATES.includes(a) ? a : this.#phase;
+    }
+    /** The signed-in account, or null. */
+    get account() {
+      if (!this.#controlled) return this.#account;
+      const identityKey = this.#attr("identity-key");
+      return identityKey ? { identityKey, paymail: this.#attr("paymail"), handle: this.#attr("handle"), avatarUrl: this.#attr("avatar-url") } : null;
+    }
+    /** True while the menu is open (tests). */
+    get menuOpen() {
+      return !!this.#menu;
+    }
+    focus(opts) {
+      this.button?.focus(opts);
+    }
+    get #controlled() {
+      return this.hasAttribute("state");
+    }
+    get #stateful() {
+      return !this.hasAttribute("stateless");
+    }
+    #attr(name) {
+      return this.getAttribute(name);
+    }
+    /** Restore the badge from session-url once, with no wallet call. */
+    async #restore() {
+      const url = this.#attr("session-url");
+      if (this.#restored || !url || this.#controlled || !this.#stateful) return;
+      this.#restored = true;
+      this.#set("restoring");
+      try {
+        const r = await fetch(url, { credentials: "include", headers: { accept: "application/json" } });
+        const j = await r.json().catch(() => ({}));
+        if (this.#phase !== "restoring") return;
+        if (j.identityKey) this.#signedIn({ identityKey: j.identityKey, handle: j.handle ?? null, paymail: j.paymail ?? null });
+        else this.#set("signed-out");
+      } catch {
+        if (this.#phase === "restoring") this.#set("signed-out");
+      }
+    }
+    #set(p) {
+      this.#phase = p;
+      if (p !== "signed-in") this.#menu?.close(false);
+      this.#render();
+    }
+    #signedIn(a) {
+      this.#account = a;
+      this.#error = "";
+      this.#set("signed-in");
+      const lookup = this.#attr("lookup-url");
+      if (!a.paymail && lookup !== "off") {
+        void lookupPaymail(a.identityKey, lookup ?? void 0).then((pm) => {
+          if (pm && this.#account?.identityKey === a.identityKey && !this.#account.paymail) {
+            this.#account = { ...this.#account, paymail: pm };
+            this.#render();
+          }
+        });
+      }
+    }
+    #render() {
+      const size = this.#attr("size") ?? "lg";
+      const brand = this.#attr("brand") === "bWallet" ? "bWallet" : "bWalletX";
+      const esc = (s) => s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+      const state = this.state;
+      const acct = this.account;
+      if (state === "signed-in" && acct) {
+        this.#hideTip();
+        const name = accountLabel(acct);
+        const avatar = acct.avatarUrl ?? avatarUrlFor(acct.identityKey);
+        const initial = (name.replace(/^\$/, "").charAt(0) || "b").toUpperCase();
+        this.#root.innerHTML = `<style>${SIGNIN_CSS}</style><button type="button" class="chip" part="button chip" aria-haspopup="menu" aria-expanded="${this.#menu ? "true" : "false"}" aria-label="Signed in with bWalletX as ${esc(name)}. Account menu" title="Signed in as ${esc(name)}"><span class="av" part="avatar" aria-hidden="true">${esc(initial)}${avatar ? `<img alt="" src="${esc(avatar)}" referrerpolicy="no-referrer">` : ""}</span><span class="name" part="label">${esc(name)}</span><span class="dot" part="dot" aria-hidden="true"></span></button>`;
+        const img = this.#root.querySelector("img");
+        if (img) img.addEventListener("error", () => img.remove(), { once: true });
+        const chip = this.button;
+        chip.addEventListener("click", () => this.#menu ? this.#menu.close(true) : this.#openMenu());
+        chip.addEventListener("keydown", (e) => {
+          if ((e.key === "ArrowDown" || e.key === "Enter" || e.key === " ") && !this.#menu) {
+            e.preventDefault();
+            this.#openMenu();
+          }
+        });
+        return;
+      }
+      const pending = state === "pending";
+      const restoring = state === "restoring";
+      const error = state === "error";
+      const pendingLabel = this.#controlled ? PENDING_LABEL : this.#pendingLabel;
+      const elsewhere = state === "signed-out" && tapGoesElsewhere(this.#walletType());
+      const text = pending ? pendingLabel : error ? "Retry" : elsewhere ? CONTINUE_OTHER_LABEL : signinText(this.#attr("label") ?? "signin", brand);
+      const subAttr = this.#attr("subtitle");
+      const subDefault = brand === "bWalletX" && (size === "lg" || size === "md") ? "also works with bWallet" : null;
+      const subtitle = pending || error || elsewhere ? null : subAttr === null || subAttr === "" || subAttr === "on" ? subAttr === "on" ? "also works with bWallet" : subDefault : subAttr === "off" ? null : subAttr;
+      const loading = this.hasAttribute("loading") || this.#busy || pending || restoring;
+      const disabled = this.hasAttribute("disabled");
+      const markPx = size === "icon" ? 24 : size === "sm" ? 15 : size === "md" ? 17 : 20;
+      const aria = pending ? pendingLabel : this.#attr("aria-label") ?? (subtitle && size !== "icon" ? `${text}, ${subtitle}` : text);
+      const getUrl = this.#attr("get-url") ?? GET_URL;
+      const webUrl = this.#attr("web-url") ?? WEB_WALLET_URL;
+      const errText = error ? (this.#controlled ? this.#attr("error") : this.#error) || "Sign-in failed" : "";
+      const label = size === "icon" ? "" : `<span class="txt" part="text"><b part="label">${esc(text)}</b>${subtitle ? `<small part="subtitle">${esc(subtitle)}</small>` : ""}</span>`;
+      const mark = loading ? '<span class="spin" aria-hidden="true"></span>' : elsewhere ? walletGlyph(markPx - 4) : markSvg(markPx);
+      const otherOff = this.#attr("other-wallets") === "off";
+      const otherLink = '<button type="button" class="lnk" data-act="other" part="other-wallets-link">Other wallets</button>';
+      const nf = this.#notFound ? `<p class="nf" part="not-found" role="status">bWalletX wasn't found in this browser. <a href="${esc(getUrl)}" target="_blank" rel="noopener">Get ${brand}</a> or <a href="${esc(webUrl)}" target="_blank" rel="noopener">use the web wallet</a>.${otherOff ? "" : ` ${otherLink}`}</p>` : "";
+      const ow = !this.#notFound && !pending && !restoring && this.#otherWalletsShown(size) ? `<p class="ow" part="other-wallets">${otherLink}</p>` : "";
+      const sw = !pending && !restoring && this.#switchNoteShown(size) ? `<p class="sw" part="switch-note">${esc(SWITCH_NOTE)} \xB7 <button type="button" class="lnk" data-act="switch" part="switch-link">Switch</button></p>` : "";
+      const err = error ? `<p class="err" part="error" role="alert">${esc(errText)}</p>` : "";
+      const mnHere = this.#metanetShown(size);
+      const mnRemembered = mnHere && (pending ? this.#metanetPending() : !restoring && this.#walletType() === METANET_TYPE);
+      const notYou = `<button type="button" class="lnk" data-act="not-you" part="not-you-link">${esc(NOT_YOU_LABEL)}</button>`;
+      const mn = !mnHere ? "" : pending ? mnRemembered ? `<p class="mn" part="metanet">${esc(METANET_REMEMBERED_NOTE)} ${notYou}</p>` : "" : restoring ? "" : `<p class="mn" part="metanet"><button type="button" class="lnk" data-act="metanet" part="metanet-link" title="Connects to Metanet Desktop on this computer, never to a browser extension.">${esc(METANET_LABEL)}</button><small>${esc(METANET_NOTE)}</small>${mnRemembered ? `<small>${esc(METANET_REMEMBERED_NOTE)} ${notYou}</small>` : ""}</p>`;
+      const compact = size === "sm" || size === "icon";
+      const note = pending && !compact ? `<p class="note" part="note">${esc(PENDING_NOTE)}</p>` : "";
+      const status = pending ? `<span class="sr" role="status">${esc(pendingLabel)}</span>` : loading ? '<span class="sr" role="status">Connecting to bWalletX\u2026</span>' : "";
+      this.#root.innerHTML = `<style>${SIGNIN_CSS}</style>${err}<button type="button" part="button" aria-label="${esc(aria)}" title="${esc(subtitle ? `${text} (${subtitle})` : text)}"${disabled ? " disabled" : ""}${loading ? ' aria-busy="true"' : ""}><span class="mark" part="mark">${mark}</span>${label}</button>${status}${note}${sw}${mn}${ow}${nf}`;
+      this.button.addEventListener("click", () => void this.#click());
+      for (const l of Array.from(this.#root.querySelectorAll("[data-act=other]"))) l.addEventListener("click", () => void this.otherWallets());
+      this.#root.querySelector("[data-act=switch]")?.addEventListener("click", () => void this.switchToBwalletX());
+      this.#root.querySelector("[data-act=metanet]")?.addEventListener("click", () => void this.useMetanet());
+      this.#root.querySelector("[data-act=not-you]")?.addEventListener("click", () => this.notYou());
+      bindPrewarm(this.button);
+      if (pending && compact) this.#showTip(PENDING_NOTE);
+      else this.#hideTip();
+    }
+    #tip = null;
+    #showTip(text) {
+      const b = this.button;
+      if (!b || typeof document === "undefined") return;
+      if (!this.#tip) {
+        const host = document.createElement("div");
+        host.setAttribute("data-bwalletx-tip", "");
+        const root = host.attachShadow({ mode: "open" });
+        root.innerHTML = `<style>${MENU_CSS}</style><div class="tip" role="note"></div>`;
+        document.body.appendChild(host);
+        this.#tip = host;
+      }
+      const tip = this.#tip.shadowRoot.querySelector(".tip");
+      tip.textContent = text;
+      const r = b.getBoundingClientRect();
+      const vw = window.innerWidth || document.documentElement.clientWidth || 360;
+      const width = Math.min(280, vw - 32);
+      tip.style.width = `${width}px`;
+      tip.style.left = `${Math.max(16, Math.min(r.right - width, vw - width - 16))}px`;
+      tip.style.top = `${r.bottom + 8}px`;
+    }
+    #hideTip() {
+      this.#tip?.remove();
+      this.#tip = null;
+    }
+    #openMenu() {
+      const acct = this.account;
+      const chip = this.button;
+      if (!acct || !chip || typeof document === "undefined") return;
+      const name = accountLabel(acct);
+      const host = document.createElement("div");
+      host.setAttribute("data-bwalletx-menu", "");
+      const root = host.attachShadow({ mode: "open" });
+      const style = document.createElement("style");
+      style.textContent = MENU_CSS;
+      const menu = document.createElement("div");
+      menu.className = "menu";
+      menu.setAttribute("role", "menu");
+      menu.setAttribute("aria-label", "bWalletX account");
+      const who = document.createElement("div");
+      who.className = "who";
+      who.textContent = `Signed in as ${acct.paymail || name}`;
+      const item = (text, run) => {
+        const b = document.createElement("button");
+        b.type = "button";
+        b.className = "item";
+        b.setAttribute("role", "menuitem");
+        b.tabIndex = -1;
+        b.textContent = text;
+        b.addEventListener("click", () => run(b));
+        return b;
+      };
+      const copyWhat = acct.paymail ? "paymail" : "key";
+      const copy = item(`Copy ${copyWhat}`, (b) => {
+        void copyText(acct.paymail || acct.identityKey).then((ok) => {
+          b.textContent = ok ? "Copied" : `Copy ${copyWhat}`;
+          setTimeout(() => close(true), ok ? 600 : 0);
+        });
+      });
+      const out = item("Disconnect", () => {
+        close(false);
+        void this.signOut();
+      });
+      const items = [copy, out];
+      menu.append(who);
+      if (needsBwalletX(this.#walletType())) {
+        const sw = item("Switch to bWalletX", () => {
+          close(false);
+          void this.switchToBwalletX();
+        });
+        const line = document.createElement("div");
+        line.className = "who";
+        line.textContent = SWITCH_NOTE;
+        menu.append(line, sw);
+        items.unshift(sw);
+      }
+      menu.append(copy, out);
+      root.append(style, menu);
+      document.body.appendChild(host);
+      const place = () => {
+        const r = chip.getBoundingClientRect();
+        const vw = window.innerWidth || document.documentElement.clientWidth || 360;
+        const vh = window.innerHeight || document.documentElement.clientHeight || 640;
+        const width = Math.min(260, vw - 32);
+        menu.style.width = `${width}px`;
+        const left = Math.max(16, Math.min(r.right - width, vw - width - 16));
+        menu.style.left = `${left}px`;
+        const h = menu.offsetHeight || 150;
+        const below = r.bottom + 8;
+        menu.style.top = `${below + h > vh && r.top - 8 - h > 0 ? r.top - 8 - h : below}px`;
+      };
+      place();
+      const focusAt = (i) => items[(i + items.length) % items.length].focus();
+      const onKey = (e) => {
+        const i = items.indexOf(root.activeElement);
+        if (e.key === "Escape") {
+          e.preventDefault();
+          close(true);
+        } else if (e.key === "ArrowDown") {
+          e.preventDefault();
+          focusAt(i + 1);
+        } else if (e.key === "ArrowUp") {
+          e.preventDefault();
+          focusAt(i - 1);
+        } else if (e.key === "Home") {
+          e.preventDefault();
+          focusAt(0);
+        } else if (e.key === "End") {
+          e.preventDefault();
+          focusAt(items.length - 1);
+        } else if (e.key === "Tab") close(false);
+      };
+      const onDown = (e) => {
+        const path = e.composedPath?.() ?? [];
+        if (!path.includes(host) && !path.includes(this)) close(false);
+      };
+      const onMove = () => close(false);
+      menu.addEventListener("keydown", onKey);
+      document.addEventListener("pointerdown", onDown, true);
+      window.addEventListener("resize", onMove);
+      window.addEventListener("scroll", place, true);
+      const close = (focusChip = false) => {
+        if (this.#menu?.host !== host) return;
+        this.#menu = null;
+        menu.removeEventListener("keydown", onKey);
+        document.removeEventListener("pointerdown", onDown, true);
+        window.removeEventListener("resize", onMove);
+        window.removeEventListener("scroll", place, true);
+        host.remove();
+        this.button?.setAttribute("aria-expanded", "false");
+        if (focusChip) this.button?.focus();
+      };
+      this.#menu = { host, close };
+      chip.setAttribute("aria-expanded", "true");
+      focusAt(0);
+    }
+    /**
+     * Disconnect: emits bwalletx-disconnect (cancelable). Unless a listener cancels it (BwalletXProvider signs out
+     * itself) or the element is driven by `state`, posts logout-url and shows signed out.
+     */
+    async signOut() {
+      this.#menu?.close(false);
+      if (!this.#emit("bwalletx-disconnect", { element: this, account: this.account }, true)) return;
+      if (this.#controlled) return;
+      const url = this.#attr("logout-url");
+      if (url) await fetch(url, { method: "POST", credentials: "include", headers: { "content-type": "application/json" }, body: "{}" }).catch(() => void 0);
+      if (this.#remember) forgetWalletChoice();
+      this.#signedType = null;
+      this.#account = null;
+      this.#set("signed-out");
+      this.#emit("bwalletx-signed-out");
+      this.button?.focus();
+    }
+    #emit(type, detail, cancelable = false) {
+      return this.dispatchEvent(new CustomEvent(type, { detail, bubbles: true, composed: true, cancelable }));
+    }
+    /** "Other wallets" is offered under the button: other-wallets on, or auto at lg/md when this element signs in. */
+    #otherWalletsShown(size) {
+      const a = this.#attr("other-wallets");
+      if (a === "off") return false;
+      if (a === "on") return true;
+      return (size === "lg" || size === "md") && (this.#controlled || !!this.#attr("challenge-url"));
+    }
+    /** Open the wallet chooser (the "Other wallets" link): phone QR, other browser wallets, desktop wallets. */
+    otherWallets() {
+      return this.#click("chooser");
+    }
+    /** (0.6.0) "Switch": sign in with bWalletX (its sheet when here, else the chooser with Get bWalletX first). */
+    switchToBwalletX() {
+      return this.#click("bwalletx");
+    }
+    get #remember() {
+      return this.#attr("remember") !== "off";
+    }
+    /**
+     * (0.7.0) "Use Metanet Desktop or another BRC-100 wallet" is offered: metanet on, or auto at lg/md when this
+     * element signs in or follows a provider. Never on a phone or inside a frame.
+     */
+    #metanetShown(size) {
+      const a = this.#attr("metanet");
+      if (a === "off" || !metanetOffered()) return false;
+      if (a === "on") return true;
+      return (size === "lg" || size === "md") && (this.#controlled || !!this.#attr("challenge-url"));
+    }
+    /** A Metanet sign-in is on screen: our own, or (driven) the provider's with Metanet remembered. */
+    #metanetPending() {
+      return this.#controlled ? this.#attr("wallet-type") === METANET_TYPE : this.#viaMetanet;
+    }
+    /** (0.7.0) The Metanet link: connect to Metanet Desktop on localhost:3321 (after this tap, never before). */
+    useMetanet() {
+      return this.#click("metanet");
+    }
+    /**
+     * (0.7.0) "Not you? Use another wallet": forget the remembered wallet here, and drop a Metanet sign-in in flight
+     * (if its verify already set a session, logout-url ends it). Emits bwalletx-not-you (cancelable).
+     */
+    notYou() {
+      if (!this.#emit("bwalletx-not-you", { element: this }, true)) return;
+      this.#run++;
+      if (this.#remember) forgetWalletChoice();
+      this.#signedType = null;
+      if (this.#viaMetanet && !this.#controlled) {
+        this.#viaMetanet = false;
+        this.#busy = false;
+        if (this.#phase === "pending") this.#phase = "signed-out";
+      }
+      this.#render();
+    }
+    /**
+     * (0.7.0) Rule 4: back with Metanet remembered and no session, ONE silent attempt per page load (2 s, a known
+     * identity key only), then the signature alone. Any stop or failure is silent: the normal button stays.
+     */
+    async #silentMetanet() {
+      if (this.#controlled || !this.#stateful || !this.#remember || this.#attr("require-token")) return;
+      if (!this.#metanetShown(this.#attr("size") ?? "lg")) return;
+      const challengeUrl = this.#attr("challenge-url");
+      const verifyUrl = this.#attr("verify-url");
+      if (!challengeUrl || !verifyUrl || this.#phase !== "signed-out" || this.#busy || silentAttemptUsed()) return;
+      if (rememberedWalletChoice()?.type !== METANET_TYPE || !metanetOffered()) return;
+      const run = ++this.#run;
+      const live = () => run === this.#run;
+      const started = Date.now();
+      const r = await runSilentMetanet({
+        challengeUrl,
+        verifyUrl,
+        post: (url, body) => postJson(url, body),
+        isAbandoned: () => !live(),
+        logout: async () => {
+          const out = this.#attr("logout-url");
+          if (out) await fetch(out, { method: "POST", credentials: "include", headers: { "content-type": "application/json" }, body: "{}" }).catch(() => void 0);
+        },
+        onSignIn: () => {
+          if (!live() || this.#phase !== "signed-out" || this.#busy) return;
+          this.#viaMetanet = true;
+          this.#busy = true;
+          this.#pendingLabel = PENDING_LABEL_OTHER;
+          this.#set("pending");
+        },
+        onAttempt: (a) => this.#emit("bwalletx-attempt", a)
+      });
+      if (!live()) return;
+      this.#viaMetanet = false;
+      this.#busy = false;
+      if (!r) {
+        if (this.#phase === "pending") this.#set("signed-out");
+        return;
+      }
+      this.#signedType = r.walletType;
+      this.#signedIn({ identityKey: r.identityKey, handle: r.handle, paymail: r.paymail });
+      this.#emit("bwalletx-signed-in", { identityKey: r.identityKey, method: "wallet", nonce: null, signature: null, response: { handle: r.handle, paymail: r.paymail }, silent: true, ms: Date.now() - started });
+    }
+    /** The wallet type the Switch note judges: the provider's, else what signed in here, else the remembered one. */
+    #walletType() {
+      if (this.#controlled) return this.#attr("wallet-type");
+      return this.#signedType ?? (this.#remember ? rememberedWalletChoice()?.type ?? null : null);
+    }
+    #switchNoteShown(size) {
+      const a = this.#attr("switch-note");
+      if (a === "off" || !tapGoesElsewhere(this.#walletType())) return false;
+      return a === "on" || size === "lg" || size === "md";
+    }
+    /**
+     * Signed in: note the wallet type, and remember it for this origin when the user picked it (0.6.0), plus the
+     * identity key as known here (0.7.0, public keys only: Metanet's silent attempt goes on only for these). Pass a key
+     * only after the site's verify route accepted it.
+     */
+    #picked(option, reason, identityKey) {
+      this.#signedType = walletTypeOf(option);
+      if (this.#remember && isExplicitPick(option, reason)) rememberWalletChoice(option);
+      if (this.#remember) rememberKnownIdentityKey(identityKey);
+    }
+    #attempt(option, outcome, started) {
+      this.#emit("bwalletx-attempt", attemptFor(option, outcome, started));
+    }
+    /**
+     * Which wallet: bWalletX by its own marker goes straight to its sheet; otherwise the chooser ("Get bWalletX" first)
+     * when another wallet is here or the user asked; otherwise 'not-found'. null: the chooser was closed.
+     */
+    async #choose(mode, ms, pairing) {
+      if (mode === "metanet") return { option: metanetOption(), reason: "requested" };
+      const r = mode === "signin" && this.#remember ? rememberedWalletChoice() : null;
+      if (r && r.type !== METANET_TYPE && !(r.type === BWALLETX_TYPE && r.substrate !== "pairing")) {
+        const m = matchRemembered(await discoverWallets({ ms, pairing: () => pairing }), r);
+        if (m) return { option: m, reason: "remembered" };
+      }
+      if (mode !== "chooser") {
+        const f = await discoverBwalletX(ms);
+        if (f) {
+          const substrate = f.rdns === RDNS_EXTENSION ? "extension" : f.rdns === RDNS_MOBILE ? "in-app" : "xdm";
+          const option = brc100Option(f.wallet, { id: f.rdns ?? "bwalletx-xdm", rdns: f.rdns ?? void 0, name: "bWalletX", isBwalletX: true, substrate });
+          return { option, reason: "bwalletx" };
+        }
+      }
+      const list = await discoverWallets({ ms: 50, pairing: () => pairing });
+      if (mode !== "chooser" && !hasBwalletX(list) && !otherDetected(list).length) return "not-found";
+      const picked = await chooseWallet(list, { getUrl: this.#attr("get-url") ?? void 0 });
+      return picked ? { option: picked, reason: "chooser" } : null;
+    }
+    async #click(mode = "signin") {
+      if (this.hasAttribute("disabled") || this.hasAttribute("loading") || this.#busy || this.state === "pending") return;
+      if (!this.#emit("bwalletx-signin", { element: this, mode }, true)) return;
+      if (mode === "signin") {
+        const href = this.#attr("href");
+        const authorizeUrl = this.#attr("authorize-url");
+        if (authorizeUrl) {
+          location.assign(await buildAuthorizeUrl({ authorizeUrl, clientId: this.#attr("client-id"), redirectUri: this.#attr("redirect-uri"), scope: this.#attr("scope") }));
+          return;
+        }
+        if (href) {
+          location.assign(href);
+          return;
+        }
+      }
+      const challengeUrl = this.#attr("challenge-url");
+      if (!challengeUrl) return;
+      const own = this.#stateful && !this.#controlled;
+      const prev = this.#phase === "signed-in" ? "signed-in" : "signed-out";
+      const started = Date.now();
+      const pairing = pairingModal();
+      let option = null;
+      const run = ++this.#run;
+      const live = () => run === this.#run;
+      this.#notFound = false;
+      this.#busy = true;
+      this.#viaMetanet = mode === "metanet";
+      this.#pendingLabel = mode === "metanet" ? PENDING_LABEL_OTHER : PENDING_LABEL;
+      if (own) this.#set("pending");
+      else this.#render();
+      try {
+        const ms = Number(this.#attr("discover-ms")) || DEFAULT_DISCOVER_MS;
+        const picked = await this.#choose(mode, ms, pairing);
+        if (picked === "not-found") {
+          this.#notFound = true;
+          if (own) this.#phase = "signed-out";
+          this.#attempt(null, "not-found", started);
+          this.#emit("bwalletx-not-found");
+          if (this.#attr("require-token")) this.#emit("bwalletx-access-denied", { code: "not_installed", message: "No wallet found" });
+          return;
+        }
+        if (!picked) {
+          if (own) this.#phase = prev;
+          this.#attempt(null, "cancelled", started);
+          return;
+        }
+        option = picked.option;
+        const reason = picked.reason;
+        if (!option.isBwalletX) {
+          this.#pendingLabel = PENDING_LABEL_OTHER;
+          if (own) this.#render();
+        }
+        const cw = await option.connect({ identity: false });
+        if (!live()) return;
+        const wallet = cw.wallet;
+        if (!wallet) throw Object.assign(new Error("This wallet cannot sign in here"), { code: "NOT_SUPPORTED" });
+        const sub = substrateOf(option);
+        const method = sub === "extension" ? "extension" : sub === "in-app" || sub === "xdm" ? "in-app" : sub === "pairing" ? "pairing" : "wallet";
+        const requireToken = this.#attr("require-token");
+        if (requireToken) {
+          if (own) this.#phase = "signed-out";
+          const verifyUrl2 = this.#attr("verify-url");
+          const min = this.#attr("min");
+          const minBps = this.#attr("min-bps");
+          const hint = { token: { id: requireToken, ...minBps ? { minBps: Number(minBps) } : { min: min ?? "1" } } };
+          try {
+            const a = await requestAccess({
+              wallet,
+              challenge: (identityKey) => postJson(challengeUrl, { identityKey, require: hint }),
+              verify: verifyUrl2 ? (response2) => postAccess(verifyUrl2, response2) : void 0
+            });
+            this.#picked(option, reason, verifyUrl2 ? a.response.identityKey : null);
+            this.#attempt(option, "signed-in", started);
+            this.#emit("bwalletx-access-granted", { identityKey: a.response.identityKey, response: a.verified });
+          } catch (e) {
+            const err = e instanceof AccessError ? e : new AccessError("bad_request", String(e));
+            this.#attempt(option, outcomeOf(e), started);
+            this.#emit("bwalletx-access-denied", { code: err.code, message: err.message, have: err.have, need: err.need });
+          }
+          return;
+        }
+        const verifyUrl = this.#attr("verify-url");
+        const { result: r, verified } = await signInAndVerify({
+          wallet,
+          // Metanet hands over its key on connect (one request at a time), so its sign-in is the signature alone.
+          identityKey: cw.identityKey ?? void 0,
+          skipWaitForAuthentication: option.id === METANET_OPTION_ID,
+          // its connect() just checked the lock
+          identityKeyHint: verifyUrl ? rememberedIdentity() : void 0,
+          challenge: (identityKey) => postJson(challengeUrl, identityKey ? { identityKey } : {}),
+          verify: async (res) => verifyUrl ? await postJson(verifyUrl, { identityKey: res.identityKey, nonce: res.nonce, signature: res.signature }) : {}
+        });
+        if (!live()) {
+          const out = this.#attr("logout-url");
+          if (verifyUrl && out) await fetch(out, { method: "POST", credentials: "include", headers: { "content-type": "application/json" }, body: "{}" }).catch(() => void 0);
+          return;
+        }
+        if (verifyUrl) rememberIdentity(r.identityKey);
+        const response = verifyUrl ? verified : null;
+        this.#picked(option, reason, verifyUrl ? r.identityKey : null);
+        if (own) this.#signedIn({ identityKey: r.identityKey, handle: response?.handle ?? null, paymail: response?.paymail ?? null });
+        this.#attempt(option, "signed-in", started);
+        this.#emit("bwalletx-signed-in", { identityKey: r.identityKey, method, nonce: r.nonce, signature: r.signature, response });
+      } catch (error) {
+        const outcome = outcomeOf(error);
+        this.#attempt(option, outcome, started);
+        if (!live()) return;
+        const closedQr = outcome === "cancelled" && option?.kind === "pairing";
+        if (own) {
+          if (closedQr) this.#phase = prev;
+          else {
+            this.#error = signInErrorText(error);
+            this.#phase = "error";
+          }
+        }
+        if (!closedQr) this.#emit("bwalletx-error", { error });
+      } finally {
+        try {
+          pairing.close();
+        } catch {
+        }
+        if (live()) {
+          this.#busy = false;
+          this.#viaMetanet = false;
+          this.#render();
+        }
+      }
+    }
+  };
+}
+function defineBwalletxSignin(tag = SIGNIN_TAG) {
+  if (typeof window === "undefined" || typeof customElements === "undefined") return void 0;
+  const existing = customElements.get(tag);
+  if (existing) return existing;
+  const C = createClass();
+  customElements.define(tag, C);
+  return C;
+}
+
+// src/modal.ts
+var CSS = `
+.bwx-ov{position:fixed;inset:0;z-index:2147483000;background:rgba(0,0,0,.6);display:flex;align-items:center;justify-content:center;padding:16px;font:15px/1.4 system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+.bwx-box{background:#0b0b0b;color:#f4f1e8;border:1px solid #3a3220;border-radius:16px;width:min(360px,100%);padding:20px;box-shadow:0 20px 60px rgba(0,0,0,.5)}
+.bwx-box h2{margin:0 0 6px;font-size:18px;color:#e8c766}
+.bwx-box p{margin:0 0 14px;color:#bdb6a3;font-size:14px}
+.bwx-qr{background:#fff;border-radius:12px;padding:12px;display:flex;justify-content:center}
+.bwx-qr svg{width:100%;height:auto;max-width:260px}
+.bwx-code{margin:14px 0 0;text-align:center;font-size:28px;letter-spacing:.3em;color:#e8c766;font-variant-numeric:tabular-nums}
+.bwx-row{display:flex;gap:8px;margin-top:14px}
+.bwx-btn{flex:1;border:1px solid #3a3220;background:#15130e;color:#f4f1e8;border-radius:10px;padding:10px 12px;font:inherit;cursor:pointer}
+.bwx-btn:hover{border-color:#e8c766}
+a.bwx-btn{display:block;text-align:center;text-decoration:none;box-sizing:border-box}
+.bwx-primary{background:linear-gradient(180deg,#fcd34d,#f59e0b);color:#000;border:0;font-weight:700;min-height:48px;padding:13px 12px}
+.bwx-stack{display:flex;flex-direction:column;gap:8px}
+.bwx-list{display:flex;flex-direction:column;gap:8px}
+.bwx-opt{display:flex;align-items:center;gap:10px;text-align:left}
+.bwx-opt img{width:24px;height:24px;border-radius:6px}
+.bwx-tag{margin-left:auto;font-size:11px;color:#8d866f;white-space:nowrap}
+.bwx-opt{min-height:48px;box-sizing:border-box}
+a.bwx-btn.bwx-opt{display:flex;text-align:left}
+.bwx-btn:focus{outline:none}
+.bwx-btn:focus-visible{outline:2px solid #e8c766;outline-offset:2px}
+.bwx-mk{display:inline-flex;align-items:center;justify-content:center;flex:none;width:28px;height:28px;border-radius:50%;background:#000}
+.bwx-ico{display:inline-grid;place-items:center;flex:none;width:28px;height:28px;border-radius:8px;background:#2a2518;color:#e8c766;font-weight:700;font-size:13px}
+.bwx-opt img{width:28px;height:28px;border-radius:8px;flex:none}
+.bwx-txt{display:flex;flex-direction:column;min-width:0;gap:1px}
+.bwx-txt b{font-weight:600}
+.bwx-txt small{font-size:12px;color:#8d866f;font-weight:400}
+.bwx-primary .bwx-txt small{color:rgba(0,0,0,.68)}
+.bwx-primary .bwx-tag{color:rgba(0,0,0,.6)}
+.bwx-sep{font-size:12px;color:#8d866f;margin:6px 2px 0}
+.bwx-foot{font-size:12px;color:#8d866f;margin:12px 0 0}
+`;
+function mount() {
+  const root = document.createElement("div");
+  root.className = "bwx-ov";
+  root.setAttribute("role", "dialog");
+  root.setAttribute("aria-modal", "true");
+  const style = document.createElement("style");
+  style.textContent = CSS;
+  const box = document.createElement("div");
+  box.className = "bwx-box";
+  root.append(style, box);
+  document.body.appendChild(root);
+  return { root, box, close: () => root.remove() };
+}
+function el(tag, cls, text) {
+  const e = document.createElement(tag);
+  if (cls) e.className = cls;
+  if (text != null) e.textContent = text;
+  return e;
+}
+function qrSvg(text) {
+  const q = qrcode(0, "M");
+  q.addData(text);
+  q.make();
+  return q.createSvgTag({ cellSize: 4, margin: 2, scalable: true });
+}
+function pairingModal(o = {}) {
+  const ac = new AbortController();
+  let ui = null;
+  let codeEl = null;
+  const close = () => {
+    ui?.close();
+    ui = null;
+  };
+  ac.signal.addEventListener("abort", close);
+  return {
+    signal: ac.signal,
+    close,
+    onLink(link) {
+      if (typeof document === "undefined") return;
+      close();
+      ui = mount();
+      const app = o.mode === "app" || (o.mode ?? "auto") === "auto" && isTouchDevice();
+      const h = el("h2", "", o.title ?? "Connect bWalletX");
+      const cancel = el("button", "bwx-btn", "Cancel");
+      cancel.onclick = () => {
+        o.onCancel?.();
+        ac.abort();
+      };
+      codeEl = el("div", "bwx-code", "");
+      codeEl.setAttribute("aria-live", "polite");
+      if (app) {
+        const p2 = el("p", "", "Open bWalletX, approve, then come back to this page.");
+        const stack = el("div", "bwx-stack");
+        const open = el("a", "bwx-btn bwx-primary", "Open bWalletX");
+        open.href = link;
+        open.rel = "noopener";
+        const web = el("button", "bwx-btn", "Use web.bwalletx.com instead");
+        web.onclick = () => {
+          void navigator.clipboard?.writeText(link).catch(() => void 0);
+          window.open(WEB_WALLET_URL, "_blank", "noopener");
+          p2.textContent = "Link copied. In web.bwalletx.com tap Connect and paste it, then come back here.";
+        };
+        stack.append(open, web, cancel);
+        ui.box.append(h, p2, codeEl, stack);
+        return;
+      }
+      const p = el("p", "", "Scan with bWalletX on your phone, or paste the link into web.bwalletx.com.");
+      const qr = el("div", "bwx-qr");
+      qr.innerHTML = qrSvg(link);
+      const row = el("div", "bwx-row");
+      const copy = el("button", "bwx-btn", "Copy link");
+      copy.onclick = () => void navigator.clipboard?.writeText(link).then(() => copy.textContent = "Copied");
+      row.append(copy, cancel);
+      ui.box.append(h, p, qr, codeEl, row);
+    },
+    onCode(code) {
+      if (codeEl) {
+        codeEl.textContent = code;
+        const p = ui?.box.querySelector("p");
+        if (p) p.textContent = "Check bWalletX shows the same code, then tap Connect.";
+      }
+    }
+  };
+}
+function pickWallet(options, o = {}) {
+  if (typeof document === "undefined") return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const ui = mount();
+    const done = (w) => {
+      ui.close();
+      resolve(w);
+    };
+    ui.box.append(el("h2", "", o.title ?? "Choose a wallet"));
+    if (!options.length) ui.box.append(el("p", "", "No wallet found. Get bWalletX at bwalletx.com."));
+    const list = el("div", "bwx-list");
+    for (const w of options) {
+      const b = el("button", "bwx-btn bwx-opt");
+      if (w.icon) {
+        const img = el("img");
+        img.src = w.icon;
+        img.alt = "";
+        b.append(img);
+      }
+      b.append(el("span", "", w.name));
+      if (w.kind === "handcash") b.append(el("span", "bwx-tag", "until BRC-100"));
+      b.onclick = () => done(w);
+      list.append(b);
+    }
+    const cancel = el("button", "bwx-btn", "Cancel");
+    cancel.onclick = () => done(null);
+    ui.root.onclick = (e) => e.target === ui.root && done(null);
+    ui.box.append(list, el("div", "bwx-row"));
+    ui.box.lastChild.append(cancel);
+  });
+}
+function optionRow(w, primary, sub, tag) {
+  const b = el("button", `bwx-btn bwx-opt${primary ? " bwx-primary" : ""}`);
+  b.type = "button";
+  b.dataset.wallet = w.id;
+  if (w.isBwalletX) {
+    const mk = el("span", "bwx-mk");
+    mk.innerHTML = markSvg(18);
+    b.append(mk);
+  } else if (w.icon) {
+    const img = el("img");
+    img.src = w.icon;
+    img.alt = "";
+    b.append(img);
+  } else {
+    b.append(el("span", "bwx-ico", (w.name.trim().charAt(0) || "W").toUpperCase()));
+  }
+  const t = el("span", "bwx-txt");
+  t.append(el("b", "", w.name));
+  if (sub) t.append(el("small", "", sub));
+  b.append(t);
+  if (tag) b.append(el("span", "bwx-tag", tag));
+  return b;
+}
+function chooseWallet(options, o = {}) {
+  if (typeof document === "undefined") return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const ui = mount();
+    ui.root.dataset.bwxChooser = "";
+    const done = (w) => {
+      document.removeEventListener("keydown", onKey, true);
+      ui.close();
+      resolve(w);
+    };
+    const onKey = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        done(null);
+      }
+    };
+    document.addEventListener("keydown", onKey, true);
+    ui.box.append(el("h2", "", o.title ?? "Choose a wallet"));
+    const list = el("div", "bwx-list");
+    const here = hasBwalletX(options);
+    if (!here) {
+      const get = el("a", "bwx-btn bwx-opt bwx-primary");
+      get.href = o.getUrl ?? GET_URL;
+      get.target = "_blank";
+      get.rel = "noopener";
+      get.dataset.wallet = "get-bwalletx";
+      const mk = el("span", "bwx-mk");
+      mk.innerHTML = markSvg(18);
+      const t = el("span", "bwx-txt");
+      t.append(el("b", "", "Get bWalletX"), el("small", "", "Free. Every feature on this site"));
+      get.append(mk, t);
+      list.append(get);
+    }
+    const ordered = chooserOrder(options);
+    const touch = isTouchDevice();
+    let sep = false;
+    for (const w of ordered) {
+      if (!here && !sep) {
+        list.append(el("p", "bwx-sep", "Or use"));
+        sep = true;
+      }
+      const sub = isPresentBwalletX(w) ? "Recommended" : w.kind === "pairing" ? touch ? "Open the bWalletX app" : "Scan a QR with your phone" : void 0;
+      const tag = w.kind === "handcash" ? "until BRC-100" : !w.isBwalletX && w.kind === "brc100" ? "Fewer features" : void 0;
+      const row2 = optionRow(w, isPresentBwalletX(w), sub, tag);
+      row2.onclick = () => done(w);
+      list.append(row2);
+    }
+    if (o.desktop !== false && metanetOffered() && !options.some((w) => w.substrate === "json-api" || w.substrate === "cicada")) {
+      if (!here && !sep) list.append(el("p", "bwx-sep", "Or use"));
+      const d = metanetOption();
+      const row2 = optionRow(d, false, METANET_NOTE);
+      row2.title = "Connects to Metanet Desktop on this computer, never to a browser extension.";
+      row2.onclick = () => done(d);
+      list.append(row2);
+    }
+    ui.box.append(list);
+    if (otherDetected(options).length || !here) ui.box.append(el("p", "bwx-foot", "Some features need bWalletX."));
+    const row = el("div", "bwx-row");
+    const cancel = el("button", "bwx-btn", "Cancel");
+    cancel.type = "button";
+    cancel.onclick = () => done(null);
+    row.append(cancel);
+    ui.box.append(row);
+    ui.root.onclick = (e) => e.target === ui.root && done(null);
+    list.querySelector("a,button")?.focus();
+  });
+}
+
+export {
+  RDNS_EXTENSION,
+  RDNS_MOBILE,
+  BWALLETX_RDNS,
+  DEFAULT_DISCOVER_MS,
+  discoverBwalletX,
+  findBwalletX,
+  isFramed,
+  prewarmBwalletX,
+  bindPrewarm,
+  inOrder,
+  pairBwalletX,
+  restorePairing,
+  clearPairing,
+  LOGIN_PROTOCOL,
+  connectBwalletX,
+  waitIfLocked,
+  challengeWantsIdentityKey,
+  signInWithBwalletX,
+  signInAndVerify,
+  brc100Option,
+  pairingOption,
+  handcashAdapter,
+  cwiIsAnnounced,
+  discoverWallets,
+  DESKTOP_OPTION_ID,
+  desktopOption,
+  autoChoice,
+  isLocalDesktop,
+  PAYMAIL_LOOKUP_URL,
+  BAVATAR_URL,
+  shortKey,
+  accountLabel,
+  avatarUrlFor,
+  lookupPaymail,
+  isUserRejection,
+  signInErrorText,
+  IDENTITY_HINT_KEY,
+  rememberedIdentity,
+  rememberIdentity,
+  isTouchDevice,
+  METANET_TYPE,
+  METANET_OPTION_ID,
+  METANET_JSON_API,
+  METANET_LABEL,
+  METANET_NOTE,
+  METANET_REMEMBERED_NOTE,
+  NOT_YOU_LABEL,
+  METANET_UNREACHABLE,
+  METANET_ANSWER_MS,
+  METANET_SILENT_MS,
+  MetanetUnreachableError,
+  inAnyFrame,
+  metanetOffered,
+  connectMetanetDesktop,
+  metanetOption,
+  KNOWN_KEYS_KEY,
+  knownIdentityKeys,
+  isKnownIdentityKey,
+  rememberKnownIdentityKey,
+  silentAttemptUsed,
+  claimSilentAttempt,
+  resetSilentAttempt,
+  trySilentMetanet,
+  warnIfNoLogout,
+  BWALLETX_TYPE,
+  substrateOf,
+  walletTypeOf,
+  isPresentBwalletX,
+  hasBwalletX,
+  otherDetected,
+  chooserOrder,
+  decideWallet,
+  outcomeOf,
+  attemptFor,
+  reportAttempt,
+  WALLET_CHOICE_KEY,
+  isRememberable,
+  isExplicitPick,
+  rememberWalletChoice,
+  rememberedWalletChoice,
+  forgetWalletChoice,
+  needsBwalletX,
+  tapGoesElsewhere,
+  isLocalDesktopType,
+  matchRemembered,
+  planAutoConnect,
+  attachRemembered,
+  qrSvg,
+  pairingModal,
+  pickWallet,
+  chooseWallet,
+  toAccessError,
+  throwIfAccessError,
+  proveHoldings,
+  requestAccess,
+  runConnect,
+  runSilentMetanet,
+  SIGNIN_TAG,
+  GET_URL,
+  WEB_WALLET_URL,
+  signinText,
+  markSvg,
+  SIGNIN_CSS,
+  MENU_CSS,
+  PENDING_NOTE,
+  PENDING_LABEL,
+  PENDING_LABEL_OTHER,
+  SWITCH_NOTE,
+  CONTINUE_OTHER_LABEL,
+  buildAuthorizeUrl,
+  defineBwalletxSignin
+};
+//# sourceMappingURL=chunk-6EFFOIHK.js.map