@anywalletkit/extension-kit 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,2282 @@
+// src/errors.ts
+var VaultError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "VaultError";
+    this.code = code;
+  }
+};
+
+// src/vault.ts
+import { zeroize } from "@anywalletkit/core";
+import { scryptAsync } from "@noble/hashes/scrypt.js";
+
+// src/codec.ts
+function toBase64(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i += 32768) s += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(s);
+}
+function fromBase64(text) {
+  const s = atob(text);
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i);
+  return out;
+}
+var utf8 = {
+  encode: (text) => new TextEncoder().encode(text),
+  decode: (bytes) => new TextDecoder().decode(bytes)
+};
+function toArrayBuffer(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+
+// src/vault.ts
+var VAULT_MIN_ITERATIONS = 6e5;
+var VAULT_DEFAULT_ITERATIONS = 6e5;
+var VAULT_SCRYPT = { N: 1 << 17, r: 8, p: 1 };
+var VAULT_MIN_SCRYPT = { N: 1 << 14, r: 8, p: 1 };
+var VAULT_MIN_PASSWORD_LENGTH = 8;
+var SALT_BYTES = 32;
+var IV_BYTES = 12;
+var DEK_BYTES = 32;
+var PRF_BYTES = 32;
+var aadDekV1 = (kdf) => `forgewallet-vault/1/dek/${kdf.name}/${kdf.iterations}/${kdf.salt}`;
+var aadDekV2 = (kdf) => `forgewallet-vault/2/dek/scrypt/${kdf.N}/${kdf.r}/${kdf.p}/${kdf.salt}`;
+var aadPasskey = (id) => `forgewallet-vault/2/passkey/${id}`;
+var aadSecret = (id) => `forgewallet-vault/secret/${id}`;
+var HKDF_INFO = "forgewallet-vault/2/passkey";
+var Vault = class {
+  _storage;
+  _kdf;
+  _iterations;
+  _scrypt;
+  _onProgress;
+  _crypto;
+  constructor(options) {
+    this._storage = options.storage;
+    this._kdf = options.kdf ?? "scrypt";
+    this._iterations = options.iterations ?? VAULT_DEFAULT_ITERATIONS;
+    this._scrypt = options.scrypt ?? VAULT_SCRYPT;
+    this._onProgress = options.onProgress;
+    this._crypto = options.crypto ?? globalThis.crypto;
+    if (!Number.isInteger(this._iterations) || this._iterations < VAULT_MIN_ITERATIONS) {
+      throw new VaultError(`PBKDF2 iterations must be an integer \u2265 ${VAULT_MIN_ITERATIONS}`, "invalid-input");
+    }
+    if (!isStrongScrypt(this._scrypt)) throw new VaultError(`scrypt cost must be at least N=${VAULT_MIN_SCRYPT.N} r=${VAULT_MIN_SCRYPT.r} p=${VAULT_MIN_SCRYPT.p} (N a power of two)`, "invalid-input");
+  }
+  async exists() {
+    return await this._storage.get() !== null;
+  }
+  /** What protects the DEK right now (UI). `null` without a vault. */
+  async kdfInfo() {
+    const e = await this._storage.get();
+    if (!e) return null;
+    if (isEnvelopeV1(e)) return { version: 1, name: "PBKDF2-SHA256", summary: `PBKDF2-SHA256 ${e.kdf.iterations.toLocaleString("en-US")} iterations` };
+    if (isEnvelopeV2(e)) return { version: 2, name: "scrypt", summary: `scrypt N=2^${Math.log2(e.kdf.N)} r=${e.kdf.r} p=${e.kdf.p}` };
+    return null;
+  }
+  /**
+   * Create an empty vault protected by `password`. Returns the DEK — hand it to the
+   * session, then `setSecret` the first seed. Refuses when a vault exists.
+   */
+  async create(password) {
+    requirePassword(password, VAULT_MIN_PASSWORD_LENGTH);
+    if (await this.exists()) throw new VaultError("A vault already exists; unlock it or reset explicitly.", "exists");
+    const dek = this._random(DEK_BYTES);
+    await this._storage.set(await this._sealEnvelope(password, dek, {}, [], Date.now()));
+    return dek;
+  }
+  /**
+   * Derive the KEK from `password`, unseal and return the DEK. `wrong-password` on
+   * failure. A v1 (PBKDF2) envelope that opens is re-sealed as v2 (scrypt) on the
+   * way out, secrets untouched.
+   */
+  async unlock(password) {
+    requirePassword(password);
+    const envelope = await this._load();
+    if (isEnvelopeV1(envelope)) {
+      if (envelope.kdf.iterations < VAULT_MIN_ITERATIONS) throw new VaultError(`The vault's KDF (${envelope.kdf.iterations} iterations) is below the floor this build accepts.`, "weak-kdf");
+      const kek2 = await this._derivePbkdf2(password, fromBase64(envelope.kdf.salt), envelope.kdf.iterations);
+      const dek = await this._open(kek2, envelope.dek, aadDekV1(envelope.kdf), "wrong-password");
+      if (this._kdf === "scrypt") {
+        const next = await this._sealEnvelope(password, dek, envelope.secrets, [], envelope.createdAt);
+        await this._storage.set(isEnvelopeV2(next) ? { ...next, upgradedAt: Date.now() } : next);
+      }
+      return dek;
+    }
+    if (!isStrongScrypt(envelope.kdf)) throw new VaultError(`The vault's scrypt cost (N=${envelope.kdf.N} r=${envelope.kdf.r} p=${envelope.kdf.p}) is below the floor this build accepts.`, "weak-kdf");
+    const kek = await this._deriveScrypt(password, fromBase64(envelope.kdf.salt), envelope.kdf);
+    return this._open(kek, envelope.dek, aadDekV2(envelope.kdf), "wrong-password");
+  }
+  /** Re-wrap the DEK under a new password (fresh salt, current KDF). Secrets and passkeys are untouched. */
+  async changePassword(oldPassword, newPassword) {
+    requirePassword(newPassword, VAULT_MIN_PASSWORD_LENGTH);
+    const dek = await this.unlock(oldPassword);
+    try {
+      const envelope = await this._load();
+      const passkeys = isEnvelopeV2(envelope) ? envelope.passkeys : [];
+      const next = await this._sealEnvelope(newPassword, dek, envelope.secrets, passkeys, envelope.createdAt);
+      await this._storage.set(isEnvelopeV2(envelope) && envelope.upgradedAt !== void 0 && isEnvelopeV2(next) ? { ...next, upgradedAt: envelope.upgradedAt } : next);
+    } finally {
+      zeroize(dek);
+    }
+  }
+  // ---- passkeys (v2) ----
+  /** Public view of the registered passkeys (ids, labels; whether each can verify assertions). */
+  async listPasskeys() {
+    const e = await this._storage.get();
+    if (!e || !isEnvelopeV2(e)) return [];
+    return e.passkeys.map((p) => ({ id: p.id, label: p.label, createdAt: p.createdAt, canVerify: typeof p.publicKey === "string" && p.alg === -7 }));
+  }
+  /** The SPKI public key (base64) of one passkey, for assertion verification; `null` when unknown. */
+  async passkeyPublicKey(id) {
+    const e = await this._storage.get();
+    if (!e || !isEnvelopeV2(e)) return null;
+    const p = e.passkeys.find((k) => k.id === id);
+    return p?.publicKey && p.alg !== void 0 ? { publicKey: p.publicKey, alg: p.alg } : null;
+  }
+  /**
+   * Register a passkey as a second unlock path: the DEK (from the unlocked session)
+   * is sealed under HKDF-SHA256(`prf`, salt = credential id). The password stays
+   * the recovery path; `prf` is zeroized here. A v1 envelope must be unlocked (and
+   * thereby upgraded) first.
+   */
+  async addPasskey(dek, passkey) {
+    try {
+      requireId(passkey.id);
+      if (passkey.prf.length !== PRF_BYTES) throw new VaultError(`A PRF output is ${PRF_BYTES} bytes.`, "invalid-input");
+      const envelope = await this._load();
+      if (!isEnvelopeV2(envelope)) throw new VaultError("Unlock with the password once so the vault is upgraded before adding a passkey.", "unsupported-envelope");
+      if (envelope.passkeys.some((p) => p.id === passkey.id)) throw new VaultError("This passkey is already registered.", "exists");
+      await this._requireDek(dek, envelope);
+      const key = await this._derivePasskeyKek(passkey.prf, passkey.id);
+      const entry = { id: passkey.id, label: passkey.label.slice(0, 64), createdAt: Date.now(), dek: await this._seal(key, dek, aadPasskey(passkey.id)) };
+      if (passkey.publicKey && passkey.alg !== void 0) {
+        entry.publicKey = passkey.publicKey;
+        entry.alg = passkey.alg;
+      }
+      await this._storage.set({ ...envelope, passkeys: [...envelope.passkeys, entry] });
+    } finally {
+      zeroize(passkey.prf);
+    }
+  }
+  /** Unseal the DEK with a passkey's PRF output. `wrong-password` when the box does not open, `missing` when the id is unknown. */
+  async unlockWithPasskey(id, prf) {
+    try {
+      requireId(id);
+      if (prf.length !== PRF_BYTES) throw new VaultError(`A PRF output is ${PRF_BYTES} bytes.`, "invalid-input");
+      const envelope = await this._load();
+      if (!isEnvelopeV2(envelope)) throw new VaultError("This vault has no passkeys; unlock with the password.", "missing");
+      const entry = envelope.passkeys.find((p) => p.id === id);
+      if (!entry) throw new VaultError("No such passkey on this vault.", "missing");
+      const key = await this._derivePasskeyKek(prf, id);
+      return await this._open(key, entry.dek, aadPasskey(id), "wrong-password");
+    } finally {
+      zeroize(prf);
+    }
+  }
+  async removePasskey(id) {
+    requireId(id);
+    const envelope = await this._load();
+    if (!isEnvelopeV2(envelope)) return;
+    await this._storage.set({ ...envelope, passkeys: envelope.passkeys.filter((p) => p.id !== id) });
+  }
+  // ---- secrets ----
+  async listSecretIds() {
+    const envelope = await this._storage.get();
+    return envelope ? Object.keys(envelope.secrets) : [];
+  }
+  /** Seal `secret` under the DEK as `sourceId` (overwrites an entry with the same id). */
+  async setSecret(dek, sourceId, secret) {
+    requireId(sourceId);
+    const envelope = await this._load();
+    const key = await this._importDek(dek);
+    const box = await this._seal(key, secret, aadSecret(sourceId));
+    await this._storage.set({ ...envelope, secrets: { ...envelope.secrets, [sourceId]: box } });
+  }
+  /** Unseal one secret. `null` when the id is unknown; the caller zeroizes the result after use. */
+  async getSecret(dek, sourceId) {
+    requireId(sourceId);
+    const envelope = await this._load();
+    const box = envelope.secrets[sourceId];
+    if (!box) return null;
+    const key = await this._importDek(dek);
+    return this._open(key, box, aadSecret(sourceId), "locked");
+  }
+  async deleteSecret(sourceId) {
+    requireId(sourceId);
+    const envelope = await this._load();
+    if (!(sourceId in envelope.secrets)) return;
+    const secrets = { ...envelope.secrets };
+    delete secrets[sourceId];
+    await this._storage.set({ ...envelope, secrets });
+  }
+  /** Remove the whole vault. The explicit destructive flow only (back up → wipe → create). */
+  async destroy() {
+    await this._storage.clear();
+  }
+  // ---- crypto ----
+  _random(n) {
+    return this._crypto.getRandomValues(new Uint8Array(n));
+  }
+  /** A fresh envelope (v2 by default, v1 with `kdf: 'pbkdf2'`) wrapping `dek` under `password`. */
+  async _sealEnvelope(password, dek, secrets, passkeys, createdAt) {
+    const salt = this._random(SALT_BYTES);
+    if (this._kdf === "pbkdf2") {
+      const kdf2 = { name: "PBKDF2-SHA256", iterations: this._iterations, salt: toBase64(salt) };
+      const kek2 = await this._derivePbkdf2(password, salt, this._iterations);
+      return { v: 1, kdf: kdf2, dek: await this._seal(kek2, dek, aadDekV1(kdf2)), secrets, createdAt };
+    }
+    const kdf = { name: "scrypt", ...this._scrypt, salt: toBase64(salt) };
+    const kek = await this._deriveScrypt(password, salt, kdf);
+    return { v: 2, kdf, dek: await this._seal(kek, dek, aadDekV2(kdf)), secrets, passkeys, createdAt };
+  }
+  /** The caller's DEK must open this envelope's secrets — it is the key the password protects, not any 32 bytes. */
+  async _requireDek(dek, envelope) {
+    const ids = Object.keys(envelope.secrets);
+    const key = await this._importDek(dek);
+    if (ids.length === 0) return;
+    const probe = await this._open(key, envelope.secrets[ids[0]], aadSecret(ids[0]), "locked");
+    zeroize(probe);
+  }
+  async _derivePbkdf2(password, salt, iterations) {
+    const subtle = this._crypto.subtle;
+    const material = await subtle.importKey("raw", toArrayBuffer(new TextEncoder().encode(password.normalize("NFKC"))), "PBKDF2", false, ["deriveKey"]);
+    return subtle.deriveKey({ name: "PBKDF2", hash: "SHA-256", salt: toArrayBuffer(salt), iterations }, material, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+  }
+  async _deriveScrypt(password, salt, cost) {
+    const pw = new TextEncoder().encode(password.normalize("NFKC"));
+    let raw;
+    try {
+      raw = await scryptAsync(pw, salt, { N: cost.N, r: cost.r, p: cost.p, dkLen: 32, maxmem: 2 * 128 * cost.N * cost.r + 1024 * 1024, ...this._onProgress ? { onProgress: this._onProgress } : {} });
+    } finally {
+      zeroize(pw);
+    }
+    try {
+      return await this._crypto.subtle.importKey("raw", toArrayBuffer(raw), { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+    } finally {
+      zeroize(raw);
+    }
+  }
+  /** HKDF-SHA256(ikm = PRF output, salt = credential id bytes, info) → AES-256-GCM key. */
+  async _derivePasskeyKek(prf, credentialId) {
+    const subtle = this._crypto.subtle;
+    const ikm = await subtle.importKey("raw", toArrayBuffer(prf), "HKDF", false, ["deriveKey"]);
+    return subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt: toArrayBuffer(fromBase64Url(credentialId)), info: toArrayBuffer(new TextEncoder().encode(HKDF_INFO)) }, ikm, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+  }
+  async _importDek(dek) {
+    if (dek.length !== DEK_BYTES) throw new VaultError("Vault key must be 32 bytes.", "invalid-input");
+    return this._crypto.subtle.importKey("raw", toArrayBuffer(dek), { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+  }
+  async _seal(key, plaintext, aad) {
+    const iv = this._random(IV_BYTES);
+    const ct = await this._crypto.subtle.encrypt({ name: "AES-GCM", iv: toArrayBuffer(iv), additionalData: toArrayBuffer(new TextEncoder().encode(aad)) }, key, toArrayBuffer(plaintext));
+    return { iv: toBase64(iv), data: toBase64(new Uint8Array(ct)) };
+  }
+  async _open(key, box, aad, onFail) {
+    try {
+      const pt = await this._crypto.subtle.decrypt(
+        { name: "AES-GCM", iv: toArrayBuffer(fromBase64(box.iv)), additionalData: toArrayBuffer(new TextEncoder().encode(aad)) },
+        key,
+        toArrayBuffer(fromBase64(box.data))
+      );
+      return new Uint8Array(pt);
+    } catch {
+      throw new VaultError(onFail === "wrong-password" ? "Wrong password." : "The vault key does not open this entry; lock and unlock again.", onFail);
+    }
+  }
+  async _load() {
+    const envelope = await this._storage.get();
+    if (!envelope) throw new VaultError("No vault in this storage area.", "missing");
+    if (!isEnvelopeV1(envelope) && !isEnvelopeV2(envelope)) throw new VaultError("Unsupported vault envelope.", "unsupported-envelope");
+    return envelope;
+  }
+};
+function isEnvelopeV1(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const e = x;
+  const kdf = e.kdf;
+  return e.v === 1 && typeof kdf === "object" && kdf !== null && kdf.name === "PBKDF2-SHA256" && Number.isInteger(kdf.iterations) && typeof kdf.salt === "string" && isBox(e.dek) && typeof e.secrets === "object" && e.secrets !== null && Object.values(e.secrets).every(isBox);
+}
+function isEnvelopeV2(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const e = x;
+  const kdf = e.kdf;
+  return e.v === 2 && typeof kdf === "object" && kdf !== null && kdf.name === "scrypt" && Number.isInteger(kdf.N) && Number.isInteger(kdf.r) && Number.isInteger(kdf.p) && typeof kdf.salt === "string" && isBox(e.dek) && typeof e.secrets === "object" && e.secrets !== null && Object.values(e.secrets).every(isBox) && Array.isArray(e.passkeys) && e.passkeys.every((p) => typeof p === "object" && p !== null && typeof p.id === "string" && typeof p.label === "string" && isBox(p.dek));
+}
+function isBox(x) {
+  return typeof x === "object" && x !== null && typeof x.iv === "string" && typeof x.data === "string";
+}
+function isStrongScrypt(c) {
+  return Number.isInteger(c.N) && c.N >= VAULT_MIN_SCRYPT.N && (c.N & c.N - 1) === 0 && Number.isInteger(c.r) && c.r >= VAULT_MIN_SCRYPT.r && Number.isInteger(c.p) && c.p >= VAULT_MIN_SCRYPT.p;
+}
+function requirePassword(password, minLength = 1) {
+  if (typeof password !== "string" || password.length === 0) throw new VaultError("Password must not be empty.", "invalid-input");
+  if ([...password].length < minLength) throw new VaultError(`Password must be at least ${minLength} characters.`, "invalid-input");
+}
+function requireId(id) {
+  if (typeof id !== "string" || id.length === 0 || id.length > 128) throw new VaultError("Bad source id.", "invalid-input");
+}
+function fromBase64Url(text) {
+  const b64 = text.replace(/-/g, "+").replace(/_/g, "/");
+  return fromBase64(b64 + "=".repeat((4 - b64.length % 4) % 4));
+}
+function toBase64Url(bytes) {
+  return toBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function memoryVaultStorage(initial = null) {
+  const s = {
+    envelope: initial,
+    async get() {
+      return s.envelope ? structuredClone(s.envelope) : null;
+    },
+    async set(envelope) {
+      s.envelope = structuredClone(envelope);
+    },
+    async clear() {
+      s.envelope = null;
+    }
+  };
+  return s;
+}
+
+// src/session.ts
+import { zeroize as zeroize2 } from "@anywalletkit/core";
+var SESSION_DEFAULT_AUTOLOCK_MS = 15 * 6e4;
+var Session = class {
+  _storage;
+  _alarms;
+  _autoLockMs;
+  _key;
+  _alarm;
+  _now;
+  _onLock = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this._storage = options.storage;
+    this._alarms = options.alarms;
+    this._autoLockMs = options.autoLockMs ?? SESSION_DEFAULT_AUTOLOCK_MS;
+    const name = options.name ?? "anywalletkit-session";
+    this._key = name;
+    this._alarm = `${name}/autolock`;
+    this._now = options.now ?? Date.now;
+    this._alarms.onFire((fired) => {
+      if (fired === this._alarm) void this.lock();
+    });
+  }
+  /** Store the DEK and arm the auto-lock. The caller's copy is zeroized. */
+  async unlock(dek) {
+    if (dek.length !== 32) throw new VaultError("Vault key must be 32 bytes.", "invalid-input");
+    const expiresAt = this._expiry();
+    await this._storage.set(this._key, { key: toBase64(dek), expiresAt });
+    zeroize2(dek);
+    await this._arm(expiresAt);
+  }
+  /** Forget the DEK and cancel the alarm. Safe to call when already locked. */
+  async lock() {
+    const was = await this._storage.get(this._key);
+    await this._storage.remove(this._key);
+    await this._alarms.clear(this._alarm);
+    if (was !== void 0 && was !== null) for (const cb of this._onLock) cb();
+  }
+  async isUnlocked() {
+    return await this._read() !== null;
+  }
+  /**
+   * The DEK for one operation (zeroize it after). `locked` when there is none or the
+   * timer ran out while the worker was asleep — the record is then removed as well, so
+   * a missed alarm cannot keep the key alive.
+   */
+  async getKey() {
+    const record = await this._read();
+    if (!record) throw new VaultError("Wallet is locked.", "locked");
+    return fromBase64(record.key);
+  }
+  /** User activity: push the auto-lock out again. No-op when locked. */
+  async touch() {
+    const record = await this._read();
+    if (!record) return;
+    const expiresAt = this._expiry();
+    await this._storage.set(this._key, { ...record, expiresAt });
+    await this._arm(expiresAt);
+  }
+  get autoLockMs() {
+    return this._autoLockMs;
+  }
+  /** Change the timer (options page); re-arms from now when unlocked. 0 disables. */
+  async setAutoLockMs(ms) {
+    if (!Number.isFinite(ms) || ms < 0) throw new VaultError("Auto-lock must be a non-negative number of milliseconds.", "invalid-input");
+    this._autoLockMs = ms;
+    await this.touch();
+  }
+  onLock(callback) {
+    this._onLock.add(callback);
+    return () => this._onLock.delete(callback);
+  }
+  _expiry() {
+    return this._autoLockMs > 0 ? this._now() + this._autoLockMs : Number.POSITIVE_INFINITY;
+  }
+  async _arm(expiresAt) {
+    if (Number.isFinite(expiresAt)) await this._alarms.schedule(this._alarm, expiresAt);
+    else await this._alarms.clear(this._alarm);
+  }
+  async _read() {
+    const raw = await this._storage.get(this._key);
+    if (!raw || typeof raw.key !== "string" || typeof raw.expiresAt !== "number") return null;
+    if (raw.expiresAt <= this._now()) {
+      await this.lock();
+      return null;
+    }
+    return raw;
+  }
+};
+function memorySessionStorage() {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    data,
+    async get(key) {
+      return data.get(key);
+    },
+    async set(key, value) {
+      data.set(key, structuredClone(value));
+    },
+    async remove(key) {
+      data.delete(key);
+    }
+  };
+}
+function memoryAlarms() {
+  const pending = /* @__PURE__ */ new Map();
+  const handlers = /* @__PURE__ */ new Set();
+  return {
+    pending,
+    schedule(name, when) {
+      pending.set(name, when);
+    },
+    clear(name) {
+      pending.delete(name);
+    },
+    onFire(handler) {
+      handlers.add(handler);
+    },
+    fire(name) {
+      pending.delete(name);
+      for (const h of handlers) h(name);
+    }
+  };
+}
+
+// src/relay.ts
+var PORT_NAME = "anywalletkit/relay/1";
+var PAGE_TARGET = { toContent: "anywalletkit/content", toPage: "anywalletkit/page" };
+var RELAY_ERRORS = {
+  userRejected: 4001,
+  unauthorized: 4100,
+  unsupportedMethod: 4200,
+  disconnected: 4900,
+  chainDisconnected: 4901,
+  /** EIP-3326/3085: the chain is not in the wallet (`wallet_switchEthereumChain` → suggest `wallet_addEthereumChain`). */
+  chainNotAdded: 4902,
+  internal: -32603,
+  invalidRequest: -32600,
+  invalidParams: -32602,
+  /** EIP-1474: a request of the same kind from this origin is already waiting (MetaMask's "already pending"). */
+  resourceUnavailable: -32002,
+  /** EIP-1474: this origin has too many requests waiting. */
+  limitExceeded: -32005
+};
+var CHAINS = /* @__PURE__ */ new Set(["eip155", "solana", "ton", "tron", "bip122", "near"]);
+var isRecord = (x) => typeof x === "object" && x !== null;
+var isId = (x) => typeof x === "string" && x.length > 0 && x.length <= 64;
+function isPageRequest(x) {
+  return isRecord(x) && x.target === PAGE_TARGET.toContent && isId(x.id) && CHAINS.has(x.chain) && typeof x.method === "string";
+}
+function isPageResponse(x) {
+  return isRecord(x) && x.target === PAGE_TARGET.toPage && isId(x.id);
+}
+function isPageEvent(x) {
+  return isRecord(x) && x.target === PAGE_TARGET.toPage && !("id" in x) && CHAINS.has(x.chain) && typeof x.event === "string";
+}
+function isRelayRequest(x) {
+  return isRecord(x) && x.kind === "request" && isId(x.id) && typeof x.origin === "string" && CHAINS.has(x.chain) && typeof x.method === "string";
+}
+function isRelayToContent(x) {
+  return isRecord(x) && (x.kind === "response" && isId(x.id) || x.kind === "event" && typeof x.event === "string");
+}
+function newRequestId() {
+  return crypto.randomUUID();
+}
+function stampOrigin(request, origin) {
+  const { id, chain, method } = request;
+  return "params" in request ? { kind: "request", id, origin, chain, method, params: request.params } : { kind: "request", id, origin, chain, method };
+}
+function checkSenderOrigin(sender, stamped) {
+  const fromSender = sender?.origin ?? (sender?.url ? safeOrigin(sender.url) : void 0);
+  if (!fromSender || fromSender === "null") return null;
+  return fromSender === stamped ? fromSender : null;
+}
+function safeOrigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return void 0;
+  }
+}
+var relayError = (code, message, data) => data === void 0 ? { code, message } : { code, message, data };
+
+// src/chrome.ts
+var VAULT_STORAGE_KEY = "forgewallet.vault.v1";
+function chromeLocalVaultStorage(area, key = VAULT_STORAGE_KEY) {
+  return {
+    async get() {
+      const r = await area.get(key);
+      return r[key] ?? null;
+    },
+    async set(envelope) {
+      await area.set({ [key]: envelope });
+    },
+    async clear() {
+      await area.remove(key);
+    }
+  };
+}
+function chromeSessionStorage(area) {
+  const ready = area.setAccessLevel ? area.setAccessLevel({ accessLevel: "TRUSTED_CONTEXTS" }) : Promise.resolve();
+  return {
+    async get(key) {
+      await ready;
+      return (await area.get(key))[key];
+    },
+    async set(key, value) {
+      await ready;
+      await area.set({ [key]: value });
+    },
+    async remove(key) {
+      await ready;
+      await area.remove(key);
+    }
+  };
+}
+function chromeAlarms(alarms) {
+  return {
+    async schedule(name, when) {
+      await alarms.create(name, { when });
+    },
+    async clear(name) {
+      await alarms.clear(name);
+    },
+    onFire(handler) {
+      alarms.onAlarm.addListener((alarm) => handler(alarm.name));
+    }
+  };
+}
+
+// src/keyring.ts
+import { zeroize as zeroize3 } from "@anywalletkit/core";
+var KEYRING_STORAGE_KEY = "forgewallet.keyring.v1";
+function chromeKeyringStorage(area, key = KEYRING_STORAGE_KEY) {
+  return {
+    async load() {
+      const r = await area.get(key);
+      return r[key] ?? null;
+    },
+    async save(state) {
+      await area.set({ [key]: state });
+    }
+  };
+}
+function vaultSecretStorage(vault, session) {
+  const withKey = async (fn) => {
+    const dek = await session.getKey();
+    try {
+      return await fn(dek);
+    } finally {
+      zeroize3(dek);
+    }
+  };
+  return {
+    async get(sourceId) {
+      return withKey(async (dek) => {
+        const bytes = await vault.getSecret(dek, sourceId);
+        if (!bytes) return null;
+        try {
+          return utf8.decode(bytes);
+        } finally {
+          zeroize3(bytes);
+        }
+      });
+    },
+    async set(sourceId, secret) {
+      const bytes = utf8.encode(secret);
+      try {
+        await withKey((dek) => vault.setSecret(dek, sourceId, bytes));
+      } finally {
+        zeroize3(bytes);
+      }
+    },
+    async delete(sourceId) {
+      await vault.deleteSecret(sourceId);
+    }
+  };
+}
+
+// src/networks.ts
+import { ccChain } from "@anywalletkit/swap2-assets";
+var DEFAULT_CHAIN = "eip155:1";
+var net = (chainId, name, symbol, rpcs, explorer) => explorer === void 0 ? { caip2: `eip155:${chainId}`, chainId, name, symbol, rpcs } : { caip2: `eip155:${chainId}`, chainId, name, symbol, rpcs, explorer };
+var DEFAULT_NETWORKS = Object.freeze([
+  net(1, "Ethereum", "ETH", ["https://ethereum-rpc.publicnode.com", "https://eth.drpc.org"], "https://etherscan.io"),
+  net(8453, "Base", "ETH", ["https://base-rpc.publicnode.com", "https://mainnet.base.org", "https://base.drpc.org"], "https://basescan.org"),
+  net(56, "BNB Chain", "BNB", ["https://bsc-rpc.publicnode.com", "https://bsc-dataseed.bnbchain.org", "https://bsc.drpc.org"], "https://bscscan.com"),
+  net(42161, "Arbitrum", "ETH", ["https://arbitrum-one-rpc.publicnode.com", "https://arb1.arbitrum.io/rpc", "https://arbitrum.drpc.org"], "https://arbiscan.io"),
+  net(10, "Optimism", "ETH", ["https://optimism-rpc.publicnode.com", "https://mainnet.optimism.io", "https://optimism.drpc.org"], "https://optimistic.etherscan.io"),
+  net(137, "Polygon", "POL", ["https://polygon-bor-rpc.publicnode.com", "https://polygon.drpc.org"], "https://polygonscan.com"),
+  net(43114, "Avalanche", "AVAX", ["https://avalanche-c-chain-rpc.publicnode.com", "https://api.avax.network/ext/bc/C/rpc", "https://avalanche.drpc.org"], "https://snowtrace.io"),
+  net(999, "HyperEVM", "HYPE", ["https://rpc.hyperliquid.xyz/evm", "https://hyperliquid.drpc.org", "https://hyperliquid-json-rpc.stakely.io"]),
+  net(4663, "Robinhood Chain", "ETH", ["https://rpc.mainnet.chain.robinhood.com", "https://robinhood.drpc.org"], "https://robinhoodchain.blockscout.com"),
+  net(324, "zkSync Era", "ETH", ["https://mainnet.era.zksync.io", "https://zksync.drpc.org"], "https://era.zksync.network"),
+  net(42220, "Celo", "CELO", ["https://forno.celo.org", "https://celo.drpc.org"], "https://celoscan.io"),
+  net(4326, "MegaETH", "ETH", ["https://mainnet.megaeth.com/rpc"]),
+  net(130, "Unichain", "ETH", ["https://mainnet.unichain.org", "https://unichain-rpc.publicnode.com"], "https://uniscan.xyz"),
+  net(143, "Monad", "MON", ["https://rpc.monad.xyz"]),
+  net(9745, "Plasma", "XPL", ["https://rpc.plasma.to"]),
+  net(59144, "Linea", "ETH", ["https://rpc.linea.build", "https://linea-rpc.publicnode.com"], "https://lineascan.build"),
+  net(100, "Gnosis", "xDAI", ["https://rpc.gnosischain.com", "https://gnosis-rpc.publicnode.com"], "https://gnosisscan.io"),
+  net(146, "Sonic", "S", ["https://rpc.soniclabs.com", "https://sonic-rpc.publicnode.com"], "https://sonicscan.org"),
+  net(480, "World Chain", "ETH", ["https://worldchain-mainnet.g.alchemy.com/public", "https://worldchain-mainnet.gateway.tenderly.co"], "https://worldscan.org"),
+  net(1329, "Sei", "SEI", ["https://evm-rpc.sei-apis.com"], "https://seitrace.com"),
+  net(57073, "Ink", "ETH", ["https://rpc-gel.inkonchain.com"], "https://explorer.inkonchain.com"),
+  net(98866, "Plume", "PLUME", ["https://rpc.plume.org"], "https://explorer.plume.org"),
+  net(196, "X Layer", "OKB", ["https://rpc.xlayer.tech", "https://xlayerrpc.okx.com"], "https://www.okx.com/web3/explorer/xlayer"),
+  net(534352, "Scroll", "ETH", ["https://rpc.scroll.io", "https://scroll-rpc.publicnode.com"], "https://scrollscan.com"),
+  net(80094, "Berachain", "BERA", ["https://rpc.berachain.com", "https://berachain-rpc.publicnode.com"], "https://berascan.com"),
+  // Arc (Circle's L1): the gas token is USDC. eth_getBalance / msg.value / gas are accounted in 18-decimal units (the
+  // `symbol` here names that native view); the ERC-20 interface at 0x3600…0000 reads the SAME balance in 6 decimals
+  // and is what the catalog, LI.FI and CCTP address (see swap2-assets). Balances must show one view, not both.
+  net(5042, "Arc", "USDC", ["https://rpc.mainnet.arc.io"], "https://explorer.arc.io"),
+  net(5e3, "Mantle", "MNT", ["https://rpc.mantle.xyz", "https://mantle-rpc.publicnode.com"], "https://mantlescan.xyz"),
+  net(747474, "Katana", "ETH", ["https://rpc.katana.network"], "https://explorer.katanarpc.com"),
+  net(2818, "Morph", "ETH", ["https://rpc.morphl2.io", "https://rpc-quicknode.morphl2.io"], "https://explorer.morphl2.io"),
+  net(14, "Flare", "FLR", ["https://flare-api.flare.network/ext/C/rpc", "https://flare.rpc.thirdweb.com"], "https://flare-explorer.flare.network")
+]);
+var chainHex = (caip2) => `0x${Number(caip2.split(":")[1]).toString(16)}`;
+function caip2FromChainId(value) {
+  let n;
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (/^0x[0-9a-f]+$/i.test(s)) n = Number.parseInt(s, 16);
+    else if (/^[0-9]+$/.test(s)) n = Number.parseInt(s, 10);
+    else return null;
+  } else if (typeof value === "number") n = value;
+  else return null;
+  return Number.isSafeInteger(n) && n > 0 ? `eip155:${n}` : null;
+}
+function isCatalogChain(caip2) {
+  return ccChain(caip2) !== void 0;
+}
+var NetworksTable = class {
+  constructor(storage, defaults = DEFAULT_NETWORKS) {
+    this.storage = storage;
+    this.defaults = defaults;
+  }
+  storage;
+  defaults;
+  _custom = null;
+  _loading = null;
+  /** add/remove run one after another (scan F22, as PermissionStore). */
+  _queue = Promise.resolve();
+  async list() {
+    return [...this.defaults, ...await this.custom()];
+  }
+  async get(caip2) {
+    return this.defaults.find((n) => n.caip2 === caip2) ?? (await this.custom()).find((n) => n.caip2 === caip2) ?? null;
+  }
+  add(network) {
+    return this.serialize(async () => {
+      if (this.defaults.some((n) => n.caip2 === network.caip2)) return;
+      const custom = (await this.custom()).filter((n) => n.caip2 !== network.caip2);
+      custom.push(network);
+      await this.write(custom);
+    });
+  }
+  remove(caip2) {
+    return this.serialize(async () => {
+      const current = await this.custom();
+      if (!current.some((n) => n.caip2 === caip2)) return;
+      await this.write(current.filter((n) => n.caip2 !== caip2));
+    });
+  }
+  serialize(fn) {
+    const run = this._queue.then(fn, fn);
+    this._queue = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  /** Cache first (readers see it at once), rolled back when storage refuses. */
+  async write(custom) {
+    const prev = await this.custom();
+    this._custom = custom;
+    try {
+      await this.storage.set(custom);
+    } catch (e) {
+      if (this._custom === custom) this._custom = prev;
+      throw e;
+    }
+  }
+  async custom() {
+    if (this._custom) return this._custom;
+    this._loading ??= this.storage.get().then(
+      (s) => this._custom ??= s ?? [],
+      (e) => {
+        this._loading = null;
+        throw e;
+      }
+    );
+    return this._loading;
+  }
+};
+function parseAddChainParams(params, known = isCatalogChain) {
+  const p = Array.isArray(params) ? params[0] : params;
+  if (!p || typeof p !== "object") return relayError(RELAY_ERRORS.invalidParams, "wallet_addEthereumChain expects one object parameter.");
+  const caip2 = caip2FromChainId(p.chainId);
+  if (!caip2) return relayError(RELAY_ERRORS.invalidParams, "chainId must be a 0x-prefixed hex string.");
+  if (!known(caip2)) return relayError(RELAY_ERRORS.chainNotAdded, `Chain ${String(p.chainId)} is not in this wallet's catalog.`);
+  const rpcs = Array.isArray(p.rpcUrls) ? p.rpcUrls.filter((u) => typeof u === "string" && /^https:\/\/[^\s/?#]+/i.test(u)) : [];
+  if (rpcs.length === 0) return relayError(RELAY_ERRORS.invalidParams, "rpcUrls must contain at least one https URL.");
+  const name = typeof p.chainName === "string" && p.chainName.trim() ? p.chainName.trim().slice(0, 64) : caip2;
+  const currency = p.nativeCurrency;
+  if (currency && currency.decimals !== void 0 && currency.decimals !== 18) return relayError(RELAY_ERRORS.invalidParams, "nativeCurrency.decimals must be 18.");
+  const symbol = typeof currency?.symbol === "string" && /^[A-Za-z0-9]{1,12}$/.test(currency.symbol) ? currency.symbol : "ETH";
+  const explorers = Array.isArray(p.blockExplorerUrls) ? p.blockExplorerUrls.filter((u) => typeof u === "string" && /^https:\/\//i.test(u)) : [];
+  const network = { caip2, chainId: Number(caip2.split(":")[1]), name, symbol, rpcs };
+  return explorers[0] ? { ...network, explorer: explorers[0] } : network;
+}
+var SOLANA_CHAIN = "solana:mainnet";
+var SOLANA_RPCS = Object.freeze(["https://solana-rpc.publicnode.com", "https://api.mainnet-beta.solana.com"]);
+var TON_CHAIN = "ton:-239";
+var TON_ENDPOINTS = Object.freeze(["https://ton.access.orbs.network/1/mainnet/toncenter-api-v2/jsonRPC", "https://toncenter.com/api/v2/jsonRPC"]);
+var TRON_CHAIN = "tron:728126428";
+var TRON_PROVIDERS = Object.freeze(["https://api.trongrid.io"]);
+var BTC_CHAIN = "bitcoin:mainnet";
+var BTC_ESPLORA = Object.freeze(["https://mempool.space/api", "https://blockstream.info/api"]);
+var NEAR_CHAIN = "near:mainnet";
+var NEAR_PROVIDERS = Object.freeze(["https://free.rpc.fastnear.com", "https://rpc.mainnet.near.org"]);
+var ZCASH_CHAIN = "zcash:mainnet";
+var ZCASH_BLOCKCHAIR = "https://api.blockchair.com/zcash";
+var NON_EVM_CHAINS = Object.freeze([
+  { caip2: SOLANA_CHAIN, key: "solana", name: "Solana", symbol: "SOL", decimals: 9, explorerTx: "https://solscan.io/tx/", explorerAddress: "https://solscan.io/account/" },
+  { caip2: TON_CHAIN, key: "ton", name: "TON", symbol: "GRAM", decimals: 9, explorerTx: "https://tonviewer.com/transaction/", explorerAddress: "https://tonviewer.com/" },
+  { caip2: TRON_CHAIN, key: "tron", name: "Tron", symbol: "TRX", decimals: 6, explorerTx: "https://tronscan.org/#/transaction/", explorerAddress: "https://tronscan.org/#/address/" },
+  { caip2: BTC_CHAIN, key: "btc", name: "Bitcoin", symbol: "BTC", decimals: 8, explorerTx: "https://mempool.space/tx/", explorerAddress: "https://mempool.space/address/" },
+  { caip2: NEAR_CHAIN, key: "near", name: "NEAR", symbol: "NEAR", decimals: 24, explorerTx: "https://nearblocks.io/txns/", explorerAddress: "https://nearblocks.io/address/" },
+  { caip2: ZCASH_CHAIN, key: "zcash", name: "Zcash", symbol: "ZEC", decimals: 8, explorerTx: "https://blockchair.com/zcash/transaction/", explorerAddress: "https://blockchair.com/zcash/address/" }
+]);
+var nonEvmChain = (caip2) => NON_EVM_CHAINS.find((c) => c.caip2 === caip2);
+
+// src/storage.ts
+function chromeJsonStorage(area, key) {
+  return {
+    async get() {
+      return (await area.get(key))[key] ?? null;
+    },
+    async set(value) {
+      await area.set({ [key]: value });
+    }
+  };
+}
+function memoryJsonStorage(initial = null) {
+  const s = {
+    value: initial,
+    async get() {
+      return s.value === null ? null : structuredClone(s.value);
+    },
+    async set(value) {
+      s.value = structuredClone(value);
+    }
+  };
+  return s;
+}
+
+// src/permissions.ts
+var CHAIN_ACCOUNT_KEYS = ["solanaAccounts", "tonAccounts", "tronAccounts", "btcAccounts", "nearAccounts"];
+var PermissionStore = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  _state = null;
+  _loading = null;
+  /** Every mutation runs here, one after another (scan F22): a read-modify-write never starts from a snapshot another one is about to replace. */
+  _queue = Promise.resolve();
+  _listeners = /* @__PURE__ */ new Set();
+  async state() {
+    if (this._state) return this._state;
+    this._loading ??= this.storage.get().then(
+      (s) => this._state ??= s ?? {},
+      (e) => {
+        this._loading = null;
+        throw e;
+      }
+    );
+    return this._loading;
+  }
+  /**
+   * Run `fn` after every earlier mutation settled. Public mutators wrap their WHOLE read-modify-write
+   * in this; `write` itself is unlocked (setAccountsEverywhere calls it in a loop — a lock there too
+   * would deadlock). Nothing awaited inside may wait on the user: routers await the approval sheet
+   * first and only then call the store.
+   */
+  serialize(fn) {
+    const run = this._queue.then(fn, fn);
+    this._queue = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async get(origin) {
+    return (await this.state())[origin] ?? null;
+  }
+  async list() {
+    return Object.values(await this.state());
+  }
+  connect(origin, accounts, chain) {
+    return this.serialize(async () => {
+      if (accounts.length === 0) throw new Error("Connect at least one account.");
+      const current = await this.get(origin);
+      const permission = { ...current ?? {}, origin, accounts: [...accounts], chain, connectedAt: current?.connectedAt ?? Date.now() };
+      await this.write(origin, permission);
+      return permission;
+    });
+  }
+  /** Connect another chain's accounts to the same origin (one "connected sites" list). */
+  connectChain(origin, key, accounts, defaultChain) {
+    return this.serialize(async () => {
+      if (accounts.length === 0) throw new Error("Connect at least one account.");
+      const current = await this.get(origin);
+      const permission = { origin, accounts: current?.accounts ?? [], chain: current?.chain ?? defaultChain, ...current ?? {}, [key]: [...accounts], connectedAt: current?.connectedAt ?? Date.now() };
+      await this.write(origin, permission);
+      return permission;
+    });
+  }
+  /** Drop one chain's accounts; the origin stays connected while any chain remains. A no-op (no write) when there is nothing to drop. */
+  disconnectChain(origin, key) {
+    return this.serialize(async () => {
+      const current = await this.get(origin);
+      if (!current) return;
+      if (key === "accounts" ? current.accounts.length === 0 : current[key] === void 0) return;
+      const next = { ...current, [key]: key === "accounts" ? [] : void 0 };
+      if (key !== "accounts") delete next[key];
+      const anything = next.accounts.length > 0 || CHAIN_ACCOUNT_KEYS.some((k) => (next[k]?.length ?? 0) > 0);
+      await this.write(origin, anything ? next : null);
+    });
+  }
+  setChain(origin, chain) {
+    return this.serialize(async () => {
+      const current = await this.get(origin);
+      if (!current) return null;
+      const next = { ...current, chain };
+      await this.write(origin, next);
+      return next;
+    });
+  }
+  /**
+   * The active EVM account changed: every origin holding an EVM grant now sees `accounts` (MetaMask behaviour).
+   * An origin connected only on another chain (`accounts: []` — Solana/TON/Tron/BTC/NEAR providers, a WalletConnect
+   * session without eip155) is skipped: it never passed an EVM connect and must not learn the EVM address (scan F6/F8).
+   * Lock never writes `[]` here, so the skip cannot strip a real EVM grant.
+   */
+  setAccountsEverywhere(accounts) {
+    return this.serialize(async () => {
+      const changed = [];
+      for (const p of await this.list()) {
+        if (p.accounts.length === 0 || sameList(p.accounts, accounts)) continue;
+        const next = { ...p, accounts: [...accounts] };
+        await this.write(p.origin, next);
+        changed.push(next);
+      }
+      return changed;
+    });
+  }
+  disconnect(origin) {
+    return this.serialize(async () => {
+      if (!await this.get(origin)) return;
+      await this.write(origin, null);
+    });
+  }
+  onChange(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  /** Unlocked: callers hold the queue. The cache changes before the await (readers see it at once) and is rolled back when storage refuses. */
+  async write(origin, permission) {
+    const prev = await this.state();
+    const state = { ...prev };
+    if (permission) state[origin] = permission;
+    else delete state[origin];
+    this._state = state;
+    try {
+      await this.storage.set(state);
+    } catch (e) {
+      if (this._state === state) this._state = prev;
+      throw e;
+    }
+    for (const l of this._listeners) l(origin, permission);
+  }
+};
+var sameList = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+
+// src/approvals.ts
+var ReviewDeclined = class extends Error {
+  code = RELAY_ERRORS.userRejected;
+  constructor(message = "You declined \u2014 nothing was signed.") {
+    super(message);
+    this.name = "ReviewDeclined";
+  }
+};
+var QueueLimitError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "QueueLimitError";
+  }
+  code;
+};
+var APPROVALS_MAX_PENDING_PER_ORIGIN = 3;
+var ApprovalQueue = class {
+  constructor(window, newId = () => crypto.randomUUID(), options = {}) {
+    this.window = window;
+    this.newId = newId;
+    this.options = options;
+    window.onClosed((id) => {
+      if (this._current?.request.id === id) this.decline(id);
+    });
+  }
+  window;
+  newId;
+  options;
+  _current = null;
+  _waiting = [];
+  _listeners = /* @__PURE__ */ new Set();
+  _via = /* @__PURE__ */ new Map();
+  /** Enqueue and wait for the user's answer. Refuses (never queues) past the per-origin limits. */
+  request(input) {
+    const sameOrigin = [...this._current ? [this._current] : [], ...this._waiting].filter((p) => p.request.origin === input.origin);
+    if (input.kind === "connect" && sameOrigin.some((p) => p.request.kind === "connect")) {
+      return Promise.reject(new QueueLimitError(RELAY_ERRORS.resourceUnavailable, "A connect request from this site is already waiting for your answer."));
+    }
+    const max = this.options.maxPendingPerOrigin ?? APPROVALS_MAX_PENDING_PER_ORIGIN;
+    if (sameOrigin.length >= max) {
+      return Promise.reject(new QueueLimitError(RELAY_ERRORS.limitExceeded, `This site already has ${max} requests waiting for you; answer or close them first.`));
+    }
+    return new Promise((resolve, reject) => {
+      const warnings = this.options.annotate?.(input.origin) ?? [];
+      const via = this._via.get(input.origin);
+      const pending = { request: { ...input, id: this.newId(), createdAt: Date.now(), ...warnings.length ? { originWarnings: warnings } : {}, ...via ? { via } : {} }, resolve, reject };
+      this._waiting.push(pending);
+      void this.next();
+    });
+  }
+  /** Attach (or clear) the transport note every later request from `origin` carries. */
+  setVia(origin, via) {
+    if (via) this._via.set(origin, via);
+    else this._via.delete(origin);
+  }
+  /** The transport note later requests from `origin` carry (WalletConnect Verify's verdict for `wc:<topic>`), if any. */
+  viaFor(origin) {
+    return this._via.get(origin);
+  }
+  /** Requests waiting for `origin` (current + queued). */
+  pendingFor(origin) {
+    return [...this._current ? [this._current] : [], ...this._waiting].filter((p) => p.request.origin === origin).length;
+  }
+  /** The request currently shown (the window asks for it by id on load). */
+  get current() {
+    return this._current?.request ?? null;
+  }
+  get queued() {
+    return this._waiting.length;
+  }
+  resolve(requestId, value) {
+    return this.settle(requestId, (p) => p.resolve(value));
+  }
+  decline(requestId, error = new ReviewDeclined()) {
+    return this.settle(requestId, (p) => p.reject(error));
+  }
+  /** Lock, disconnect, shutdown: everything pending is declined. */
+  declineAll(error = new ReviewDeclined("The wallet was locked.")) {
+    const all = [...this._current ? [this._current] : [], ...this._waiting.splice(0)];
+    for (const p of all) p.reject(error);
+    if (this._current) void this.window.close(this._current.request.id);
+    this._current = null;
+    this.emit();
+  }
+  onChange(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  settle(requestId, fn) {
+    if (this._current?.request.id === requestId) {
+      const p = this._current;
+      this._current = null;
+      fn(p);
+      void this.window.close(requestId).catch(() => void 0);
+      this.emit();
+      void this.next();
+      return true;
+    }
+    const i = this._waiting.findIndex((p) => p.request.id === requestId);
+    if (i < 0) return false;
+    fn(this._waiting.splice(i, 1)[0]);
+    this.emit();
+    return true;
+  }
+  async next() {
+    if (this._current || this._waiting.length === 0) return;
+    const p = this._waiting.shift();
+    this._current = p;
+    this.emit();
+    try {
+      await this.window.open(p.request);
+    } catch (e) {
+      if (this._current === p) {
+        this._current = null;
+        p.reject(e instanceof Error ? e : new Error(String(e)));
+        this.emit();
+        void this.next();
+      }
+    }
+  }
+  emit() {
+    for (const l of this._listeners) l();
+  }
+};
+function memoryApprovalWindow() {
+  let handler = () => void 0;
+  const w = {
+    opened: [],
+    openIds: /* @__PURE__ */ new Set(),
+    async open(request) {
+      w.opened.push(request);
+      w.openIds.add(request.id);
+    },
+    async close(id) {
+      w.openIds.delete(id);
+    },
+    onClosed(h) {
+      handler = h;
+    },
+    userClose(id) {
+      w.openIds.delete(id);
+      handler(id);
+    }
+  };
+  return w;
+}
+
+// src/router.ts
+var RouterError = class _RouterError extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "RouterError";
+    this.code = code;
+    this.data = data;
+  }
+  static from(e) {
+    return new _RouterError(e.code, e.message, e.data);
+  }
+};
+function toRelayError(e) {
+  if (e instanceof RouterError) return e.data === void 0 ? { code: e.code, message: e.message } : { code: e.code, message: e.message, data: e.data };
+  if (e instanceof ReviewDeclined) return { code: e.code, message: e.message };
+  const code = typeof e?.code === "number" ? e.code : RELAY_ERRORS.internal;
+  return { code, message: e instanceof Error ? e.message : String(e) };
+}
+var READ_METHODS = /* @__PURE__ */ new Set([
+  "eth_blockNumber",
+  "eth_call",
+  "eth_estimateGas",
+  "eth_feeHistory",
+  "eth_gasPrice",
+  "eth_getBalance",
+  "eth_getBlockByHash",
+  "eth_getBlockByNumber",
+  "eth_getCode",
+  "eth_getLogs",
+  "eth_getStorageAt",
+  "eth_getTransactionByHash",
+  "eth_getTransactionCount",
+  "eth_getTransactionReceipt",
+  "eth_maxPriorityFeePerGas"
+]);
+var SIGNING_METHODS = /* @__PURE__ */ new Set(["personal_sign", "eth_signTypedData_v4", "eth_signTypedData_v3", "eth_signTypedData", "eth_sendTransaction"]);
+var RequestRouter = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  /** The chain an origin currently sees (its permission's, else the default). */
+  async chainFor(origin) {
+    const permission = await this.deps.permissions.get(origin);
+    const wanted = permission?.chain ?? this.deps.defaultChain ?? DEFAULT_CHAIN;
+    return await this.deps.networks.get(wanted) ?? await this.deps.networks.get(DEFAULT_CHAIN);
+  }
+  async handle(origin, chain, method, rawParams) {
+    if (chain !== "eip155") throw new RouterError(RELAY_ERRORS.unsupportedMethod, `${chain} providers are not available yet.`);
+    const params = Array.isArray(rawParams) ? rawParams : rawParams === void 0 ? [] : [rawParams];
+    const network = await this.chainFor(origin);
+    const permission = await this.deps.permissions.get(origin);
+    switch (method) {
+      case "eth_chainId":
+        return chainHex(network.caip2);
+      case "net_version":
+        return String(network.chainId);
+      case "eth_accounts":
+        return this.visibleAccounts(permission);
+      case "eth_requestAccounts":
+        return this.connect(origin, network);
+      case "wallet_getPermissions":
+        return permission && permission.accounts.length > 0 ? [permissionDescriptor(origin, permission.accounts)] : [];
+      case "wallet_requestPermissions": {
+        const accounts = await this.connect(origin, network);
+        return [permissionDescriptor(origin, accounts)];
+      }
+      case "wallet_revokePermissions":
+        await this.disconnect(origin);
+        return null;
+      case "wallet_switchEthereumChain": {
+        const target = caip2FromChainId(params[0]?.chainId);
+        if (!target) throw new RouterError(RELAY_ERRORS.invalidParams, "wallet_switchEthereumChain expects [{ chainId }].");
+        const to = await this.deps.networks.get(target);
+        if (!to) throw new RouterError(RELAY_ERRORS.chainNotAdded, `Chain ${chainHex(target)} is not in this wallet; add it with wallet_addEthereumChain.`);
+        await this.switchChain(origin, network, to);
+        return null;
+      }
+      case "wallet_addEthereumChain": {
+        const parsed = parseAddChainParams(params);
+        if ("code" in parsed) throw RouterError.from(parsed);
+        const existing = await this.deps.networks.get(parsed.caip2);
+        if (existing) {
+          await this.switchChain(origin, network, existing);
+          return null;
+        }
+        await this.deps.approvals.request({ origin, chain: network.caip2, kind: "add-chain", payload: { network: parsed } });
+        let answered;
+        try {
+          answered = await this.deps.rpc(parsed, "eth_chainId", []);
+        } catch (e) {
+          throw new RouterError(RELAY_ERRORS.invalidParams, `The RPC for ${parsed.name} did not answer eth_chainId (${e instanceof Error ? e.message : String(e)}); the network was not added.`);
+        }
+        const got = caip2FromChainId(answered);
+        if (got !== parsed.caip2) throw new RouterError(RELAY_ERRORS.invalidParams, `The RPC for ${parsed.name} answers chain ${String(answered)}, not ${chainHex(parsed.caip2)}; the network was not added.`);
+        await this.deps.networks.add({ ...parsed, custom: { origin, addedAt: Date.now() } });
+        if (permission) await this.switchChain(origin, network, parsed, true);
+        return null;
+      }
+      case "eth_sign":
+      case "eth_signTransaction":
+        throw new RouterError(RELAY_ERRORS.unsupportedMethod, `${method} (blind signing) is never offered by this wallet.`);
+    }
+    if (READ_METHODS.has(method)) return this.deps.rpc(network, method, params);
+    if (SIGNING_METHODS.has(method)) {
+      if (!this.deps.sign) throw new RouterError(RELAY_ERRORS.unsupportedMethod, `${method} is not available yet.`);
+      if (!permission) throw new RouterError(RELAY_ERRORS.unauthorized, "Connect the wallet first (eth_requestAccounts).");
+      return this.deps.sign({ origin, network, method, params, accounts: permission.accounts });
+    }
+    throw new RouterError(RELAY_ERRORS.unsupportedMethod, `This wallet does not support ${method}.`);
+  }
+  /** What a connected origin sees right now: its permitted accounts that the wallet can expose (none while locked). */
+  async visibleAccounts(permission) {
+    if (!permission) return [];
+    const available = await this.deps.accounts();
+    return permission.accounts.filter((a) => available.includes(a));
+  }
+  /**
+   * Connected and unlocked → the accounts; otherwise the approval window (which
+   * unlocks first when needed) picks them. Emits `connect` + `accountsChanged`.
+   */
+  async connect(origin, network) {
+    const existing = await this.visibleAccounts(await this.deps.permissions.get(origin));
+    if (existing.length) return existing;
+    const chosen = await this.deps.approvals.request({ origin, chain: network.caip2, kind: "connect", payload: { accounts: await this.deps.accounts() } });
+    const available = await this.deps.accounts();
+    const accounts = Array.isArray(chosen) ? chosen.filter((a) => typeof a === "string" && available.includes(a)) : [];
+    if (accounts.length === 0) throw new ReviewDeclined("No account was selected.");
+    await this.deps.permissions.connect(origin, accounts, network.caip2);
+    this.deps.emit(origin, "connect", { chainId: chainHex(network.caip2) });
+    this.deps.emit(origin, "accountsChanged", accounts);
+    return accounts;
+  }
+  async disconnect(origin) {
+    if (!await this.deps.permissions.get(origin)) return;
+    await this.deps.permissions.disconnect(origin);
+    this.deps.emit(origin, "accountsChanged", []);
+    this.deps.emit(origin, "disconnect", { code: RELAY_ERRORS.disconnected, message: "The wallet disconnected this site." });
+  }
+  async switchChain(origin, from, to, approved = false) {
+    if (from.caip2 === to.caip2) return;
+    const permission = await this.deps.permissions.get(origin);
+    if (!permission) throw new RouterError(RELAY_ERRORS.unauthorized, "Connect the wallet first (eth_requestAccounts).");
+    if (!approved) await this.deps.approvals.request({ origin, chain: from.caip2, kind: "switch-chain", payload: { from, to } });
+    await this.deps.permissions.setChain(origin, to.caip2);
+    this.deps.emit(origin, "chainChanged", chainHex(to.caip2));
+  }
+};
+var permissionDescriptor = (origin, accounts) => ({
+  id: crypto.randomUUID(),
+  parentCapability: "eth_accounts",
+  invoker: origin,
+  caveats: [{ type: "restrictReturnedAccounts", value: [...accounts] }],
+  date: Date.now()
+});
+
+// src/siwe.ts
+var HEADER_LINE = /^(?<domain>[^\n]+?) wants you to sign in with your Ethereum account:(?:\n|$)/;
+var ADDRESS_LINE = /^0x[0-9a-fA-F]{40}$/;
+var FIELD = /^([A-Za-z ]+): (.*)$/;
+function parseLoose(text) {
+  const head = HEADER_LINE.exec(text);
+  if (!head?.groups) return null;
+  const lines = text.slice(head[0].length).split("\n");
+  const missing = [];
+  const addressLine = lines.shift() ?? "";
+  const address = ADDRESS_LINE.test(addressLine) ? addressLine : "";
+  if (!address) missing.push("address");
+  const uriAt = lines.findIndex((l) => l.startsWith("URI: "));
+  const between = (uriAt < 0 ? lines : lines.slice(0, uriAt)).filter((l) => l !== "");
+  let statement;
+  if (uriAt >= 0) {
+    if (between.length === 1 && !FIELD.test(between[0])) statement = between[0];
+    else if (between.length > 0) missing.push("statement layout");
+  }
+  const fields = {};
+  const resources = [];
+  for (const line of uriAt < 0 ? [] : lines.slice(uriAt)) {
+    if (line.startsWith("- ")) {
+      resources.push(line.slice(2));
+      continue;
+    }
+    const m = FIELD.exec(line);
+    if (m && !(m[1] in fields)) fields[m[1]] = m[2];
+  }
+  const chainId = Number(fields["Chain ID"]);
+  if (!fields.URI) missing.push("URI");
+  if (!fields.Version) missing.push("Version");
+  if (fields["Chain ID"] === void 0 || !Number.isInteger(chainId)) missing.push("Chain ID");
+  if (!fields.Nonce) missing.push("Nonce");
+  if (!fields["Issued At"]) missing.push("Issued At");
+  const message = { domain: head.groups.domain, address, uri: fields.URI ?? "", version: fields.Version ?? "", chainId: Number.isInteger(chainId) ? chainId : NaN, nonce: fields.Nonce ?? "", issuedAt: fields["Issued At"] ?? "", resources };
+  if (statement) message.statement = statement;
+  if (fields["Expiration Time"]) message.expirationTime = fields["Expiration Time"];
+  if (fields["Not Before"]) message.notBefore = fields["Not Before"];
+  if (fields["Request ID"]) message.requestId = fields["Request ID"];
+  return { message, missing };
+}
+function parseSiwe(text) {
+  const p = parseLoose(text);
+  return p && p.missing.length === 0 ? p.message : null;
+}
+function whereOf(s) {
+  try {
+    if (!s.includes("://")) {
+      const host = new URL(`https://${s}`).host.toLowerCase();
+      return host ? { scheme: "https", host } : null;
+    }
+    const u = new URL(s);
+    return u.host ? { scheme: u.protocol.replace(/:$/, "").toLowerCase(), host: u.host.toLowerCase() } : null;
+  } catch {
+    return null;
+  }
+}
+function originWhere(origin) {
+  try {
+    const u = new URL(origin);
+    return (u.protocol === "https:" || u.protocol === "http:") && u.host ? { scheme: u.protocol.slice(0, -1), host: u.host.toLowerCase() } : null;
+  } catch {
+    return null;
+  }
+}
+function isLocalHost(host) {
+  const h = host.toLowerCase().replace(/:\d+$/, "");
+  return h === "localhost" || h === "127.0.0.1" || h === "[::1]" || h.endsWith(".localhost");
+}
+function siweProblems(m, ctx) {
+  const out = [];
+  const domain = whereOf(m.domain);
+  let site = originWhere(ctx.origin);
+  if (!site) {
+    const claimed = ctx.via?.verify === "VALID" && !ctx.via.scam ? whereOf(ctx.via.url) : null;
+    if (claimed && domain && claimed.host === domain.host) site = claimed;
+    else out.push(`The wallet cannot verify which site is asking; this sign-in for ${m.domain} may be replayed there.`);
+  }
+  if (site) {
+    const local = isLocalHost(site.host);
+    if (site.scheme === "http" && !local) out.push(`This sign-in is requested by an insecure page (${site.scheme}://${site.host}); anyone on the network can read or change it and replay the signature on the https site.`);
+    if (!domain || domain.host !== site.host) out.push(`The sign-in names ${m.domain} but the request comes from ${site.host} \u2014 a sign-in meant for another site would be replayable there.`);
+    else if (!local && domain.scheme !== site.scheme) out.push(`The sign-in is for ${domain.scheme}://${domain.host} but the request comes from ${site.scheme}://${site.host}.`);
+    const uri = m.uri ? whereOf(m.uri) : null;
+    if (uri && uri.host !== site.host) out.push(`The URI ${m.uri} is not on ${site.host}.`);
+    else if (uri && !local && (uri.scheme === "http" || uri.scheme === "https") && uri.scheme !== site.scheme) out.push(`The URI ${m.uri} uses ${uri.scheme}:// but the request comes from ${site.scheme}://${site.host}.`);
+  }
+  if (m.address && m.address.toLowerCase() !== ctx.account.toLowerCase()) out.push(`The sign-in is for ${m.address}, not the account that would sign (${ctx.account}).`);
+  if (Number.isInteger(m.chainId) && m.chainId !== ctx.chainId) out.push(`The sign-in is for chain ${m.chainId}; this site is on chain ${ctx.chainId}.`);
+  if (m.version && m.version !== "1") out.push(`Unknown SIWE version ${m.version}.`);
+  if (m.nonce && (m.nonce.length < 8 || !/^[A-Za-z0-9]+$/.test(m.nonce))) out.push("The nonce is too short to protect against replay.");
+  const now = ctx.now ?? Date.now();
+  const exp = m.expirationTime ? Date.parse(m.expirationTime) : NaN;
+  if (m.expirationTime && (Number.isNaN(exp) || exp <= now)) out.push("The sign-in has already expired.");
+  const nbf = m.notBefore ? Date.parse(m.notBefore) : NaN;
+  if (m.notBefore && (Number.isNaN(nbf) || nbf > now)) out.push("The sign-in is not valid yet (Not Before is in the future).");
+  if (m.issuedAt) {
+    const iat = Date.parse(m.issuedAt);
+    if (Number.isNaN(iat)) out.push("Issued At is not a date.");
+    else if (iat > now + 5 * 6e4) out.push("Issued At is in the future.");
+  }
+  return out;
+}
+function describeSiwe(text, ctx) {
+  const p = parseLoose(text);
+  if (!p) return null;
+  const problems = siweProblems(p.message, ctx);
+  if (p.missing.length === 0) return { message: p.message, problems };
+  return { message: p.message, problems: [`This is a malformed sign-in message (EIP-4361): ${p.missing.join(", ")} missing or unreadable \u2014 check the site before signing.`, ...problems], malformed: true };
+}
+
+// src/signing.ts
+var ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+var HEX = /^0x([0-9a-fA-F]{2})*$/;
+var lc = (s) => s.toLowerCase();
+function messageText(value) {
+  if (typeof value !== "string") return "";
+  if (!HEX.test(value)) return value;
+  try {
+    const bytes = Uint8Array.from(value.slice(2).match(/../g) ?? [], (b) => Number.parseInt(b, 16));
+    const s = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return /^[\x09\x0a\x0d\x20-\x7e -￿]*$/.test(s) ? s : value;
+  } catch {
+    return value;
+  }
+}
+function decodedMessage(value) {
+  if (typeof value !== "string") return null;
+  if (!HEX.test(value)) return value;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(value.slice(2).match(/../g) ?? [], (b) => Number.parseInt(b, 16)));
+  } catch {
+    return null;
+  }
+}
+var HIDDEN_CONTROL = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/;
+var err = (code, message) => ({ code, message });
+function classifySignRequest(input) {
+  const { method, params } = input;
+  const owned = new Set(input.accounts.map(lc));
+  const ours = (a) => typeof a === "string" && ADDRESS.test(a) && owned.has(lc(a));
+  const checksum = (a) => input.accounts.find((x) => lc(x) === lc(a)) ?? a;
+  if (method === "personal_sign") {
+    let [msg, addr] = params;
+    if (ours(msg) && !ours(addr)) [msg, addr] = [addr, msg];
+    if (!ours(addr)) return err(RELAY_ERRORS.unauthorized, "personal_sign for an address this wallet does not hold.");
+    if (typeof msg !== "string") return err(RELAY_ERRORS.invalidParams, "personal_sign expects a message string.");
+    const text = messageText(msg);
+    const signed = decodedMessage(msg) ?? text;
+    const siwe = input.origin ? describeSiwe(signed, { origin: input.origin, account: checksum(addr), chainId: input.network.chainId, ...input.via ? { via: input.via } : {}, ...input.now !== void 0 ? { now: input.now } : {} }) : null;
+    if (siwe && HIDDEN_CONTROL.test(signed)) return err(RELAY_ERRORS.invalidParams, "This sign-in message contains hidden control characters \u2014 refused.");
+    return { kind: "sign-message", method, account: checksum(addr), text, raw: msg, ...siwe ? { siwe } : {} };
+  }
+  if (method === "eth_signTypedData_v4" || method === "eth_signTypedData_v3" || method === "eth_signTypedData") {
+    const [addr, data] = params;
+    if (!ours(addr)) return err(RELAY_ERRORS.unauthorized, "signTypedData for an address this wallet does not hold.");
+    let parsed;
+    try {
+      parsed = typeof data === "string" ? JSON.parse(data) : data;
+    } catch {
+      return err(RELAY_ERRORS.invalidParams, "Typed data is not valid JSON.");
+    }
+    if (!parsed || typeof parsed !== "object" || typeof parsed.domain !== "object" || typeof parsed.types !== "object" || typeof parsed.message !== "object") {
+      return err(RELAY_ERRORS.invalidParams, "Typed data needs domain, types and message.");
+    }
+    const cid = parsed.domain.chainId;
+    if (cid !== void 0 && cid !== null && Number(cid) !== input.network.chainId) {
+      return err(RELAY_ERRORS.chainDisconnected, `Typed data is for chain ${String(cid)}; this site is on ${input.network.name} (${input.network.chainId}).`);
+    }
+    return { kind: "sign-typed-data", method, account: checksum(addr), text: JSON.stringify(parsed, bigintSafe, 2), typedData: parsed };
+  }
+  if (method === "eth_sendTransaction") {
+    const tx = params[0] ?? {};
+    if (!ours(tx.from)) return err(RELAY_ERRORS.unauthorized, "Transaction from an address this wallet does not hold.");
+    if (Array.isArray(tx.authorizationList) && tx.authorizationList.length > 0 || tx.type === "0x4" || tx.type === 4) return err(RELAY_ERRORS.unsupportedMethod, "EIP-7702 delegations (authorizationList / type 4) are never signed for a site by this wallet.");
+    if (typeof tx.to !== "string" || !ADDRESS.test(tx.to)) return err(RELAY_ERRORS.invalidParams, "Contract deployment is not supported (a transaction needs a valid `to`).");
+    if (tx.chainId !== void 0 && tx.chainId !== null && Number(tx.chainId) !== input.network.chainId) return err(RELAY_ERRORS.chainDisconnected, "Transaction chainId differs from the selected chain.");
+    let value;
+    try {
+      value = BigInt(tx.value ?? 0).toString();
+    } catch {
+      return err(RELAY_ERRORS.invalidParams, "Bad transaction value.");
+    }
+    const data = typeof tx.data === "string" && tx.data !== "0x" ? tx.data : null;
+    if (data !== null && !HEX.test(data)) return err(RELAY_ERRORS.invalidParams, "Transaction data is not hex.");
+    const gasRaw = tx.gas ?? tx.gasLimit;
+    const gas = typeof gasRaw === "string" && /^0x[0-9a-fA-F]+$/.test(gasRaw) ? gasRaw : null;
+    return { kind: "send-transaction", method, account: checksum(tx.from), tx: { to: tx.to, value, data, gas } };
+  }
+  return err(RELAY_ERRORS.unsupportedMethod, `This wallet does not support ${method}.`);
+}
+var bigintSafe = (_k, v) => typeof v === "bigint" ? v.toString() : v;
+var hex = (n) => `0x${n.toString(16)}`;
+var big = (v) => BigInt(v);
+var MIN_TIP_WEI = 100000000n;
+async function prepareTransaction(deps, network, from, tx) {
+  const call = { from, to: tx.to, value: hex(BigInt(tx.value)), ...tx.data ? { data: tx.data } : {} };
+  const [nonceHex, block, gasHex] = await Promise.all([
+    deps.rpc(network, "eth_getTransactionCount", [from, "pending"]),
+    deps.rpc(network, "eth_getBlockByNumber", ["latest", false]),
+    tx.gas ? Promise.resolve(tx.gas) : deps.rpc(network, "eth_estimateGas", [call])
+  ]);
+  const estimated = big(gasHex);
+  const gasLimit = tx.gas ? estimated : (estimated * 120n + 99n) / 100n;
+  const base = block?.baseFeePerGas != null ? big(block.baseFeePerGas) : null;
+  if (base === null) {
+    const gasPrice = big(await deps.rpc(network, "eth_gasPrice", []));
+    return { chainId: network.chainId, nonce: Number(big(nonceHex)), gasLimit: hex(gasLimit), gasPrice: hex(gasPrice), maxFee: (gasLimit * gasPrice).toString() };
+  }
+  const floor = deps.tipFloor?.(network.chainId) ?? MIN_TIP_WEI;
+  const nodeTip = await deps.rpc(network, "eth_maxPriorityFeePerGas", []).then(big).catch(() => 0n);
+  const tip = nodeTip > floor ? nodeTip : floor;
+  const maxFeePerGas = base * 2n + tip;
+  return { chainId: network.chainId, nonce: Number(big(nonceHex)), gasLimit: hex(gasLimit), maxFeePerGas: hex(maxFeePerGas), maxPriorityFeePerGas: hex(tip), maxFee: (gasLimit * maxFeePerGas).toString() };
+}
+function createSignHandler(deps) {
+  return async ({ origin, network, method, params, accounts }) => {
+    const via = deps.approvals.viaFor(origin);
+    const info = classifySignRequest({ network, method, params, accounts, origin, ...via ? { via } : {} });
+    if ("code" in info) throw RouterError.from(info);
+    const prepared = info.kind === "send-transaction" ? await prepareTransaction(deps, network, info.account, info.tx) : void 0;
+    const preview = deps.preview ? await deps.preview({ network, request: info, accounts }).catch(() => null) : null;
+    const payload = { request: info, network, ...prepared ? { prepared } : {}, preview };
+    await deps.approvals.request({ origin, chain: network.caip2, kind: info.kind, payload });
+    const handle = await deps.signerFor(info.account, network);
+    try {
+      switch (info.kind) {
+        case "sign-message":
+          return await handle.signer.signMessage(HEX.test(info.raw) ? Uint8Array.from(info.raw.slice(2).match(/../g) ?? [], (b) => Number.parseInt(b, 16)) : info.raw);
+        case "sign-typed-data":
+          return await handle.signer.signTypedData(info.typedData);
+        case "send-transaction": {
+          const p = prepared;
+          const raw = await handle.signer.signTransaction({
+            chainId: p.chainId,
+            nonce: p.nonce,
+            to: info.tx.to,
+            value: BigInt(info.tx.value),
+            data: info.tx.data ?? "0x",
+            gasLimit: BigInt(p.gasLimit),
+            ...p.gasPrice !== void 0 ? { gasPrice: BigInt(p.gasPrice) } : { maxFeePerGas: BigInt(p.maxFeePerGas), maxPriorityFeePerGas: BigInt(p.maxPriorityFeePerGas) }
+          });
+          return await deps.rpc(network, "eth_sendRawTransaction", [raw]);
+        }
+      }
+    } finally {
+      handle.dispose();
+    }
+  };
+}
+
+// src/gate.ts
+var ReviewGate = class {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  now;
+  approved = [];
+  /** Each matcher passes ONE operation, within `ttlMs` (default 10 min). */
+  preApprove(matchers, ttlMs = 10 * 6e4) {
+    const until = this.now() + ttlMs;
+    this.approved.push(...matchers.map((match) => ({ match, until })));
+  }
+  /** True (and the matcher is spent) when a pre-approval covers `op`. */
+  consume(op) {
+    const now = this.now();
+    this.approved = this.approved.filter((a) => a.until > now);
+    const i = this.approved.findIndex((a) => a.match(op));
+    if (i < 0) return false;
+    this.approved.splice(i, 1);
+    return true;
+  }
+  get pending() {
+    return this.approved.length;
+  }
+  clear() {
+    this.approved = [];
+  }
+};
+var lc2 = (s) => s.toLowerCase();
+function evmCallMatcher(expected) {
+  const data = expected.data && expected.data !== "0x" ? lc2(expected.data) : void 0;
+  return (op) => op.kind === "evm-tx" && op.caip2 === expected.caip2 && lc2(op.to) === lc2(expected.to) && (op.data && op.data !== "0x" ? lc2(op.data) : void 0) === data && op.value === expected.value;
+}
+function chainTxMatcher(expected) {
+  return (op) => op.kind === "chain-tx" && op.chain === expected.chain && op.to === expected.to && op.amount === expected.amount && (op.token ?? "") === (expected.token ?? "") && (op.memo ?? "") === (expected.memo ?? "");
+}
+
+// src/swap.ts
+import { validQuote } from "@anywalletkit/protocol-swap2-core";
+async function quoteRoutes(providers, params, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 2e4;
+  const from = { chain: params.sourceChain, token: params.sourceToken };
+  const to = { chain: params.destChain, token: params.destToken };
+  const refusals = {};
+  const quotes = {};
+  const candidates = [];
+  for (const p of providers) {
+    let enabled = false;
+    try {
+      enabled = p.enabled();
+    } catch {
+    }
+    if (!enabled) continue;
+    if (params.sourceChain === params.destChain && !p.supportsSameChain) {
+      refusals[p.name] = "does not do same-chain swaps";
+      continue;
+    }
+    let serves = false;
+    try {
+      serves = p.supportsRoute(from, to);
+    } catch (e) {
+      refusals[p.name] = e instanceof Error ? e.message : String(e);
+      continue;
+    }
+    if (!serves) {
+      refusals[p.name] = "does not serve this pair";
+      continue;
+    }
+    candidates.push(p);
+  }
+  const pending = new Set(candidates.map((p) => p.name));
+  const view = () => ({ routes: rank(Object.values(quotes)), pending: [...pending], refusals: { ...refusals }, quotes: { ...quotes } });
+  const emit = () => options.onUpdate?.(view());
+  emit();
+  await Promise.all(
+    candidates.map(async (p) => {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(new Error(`no answer within ${Math.round(timeoutMs / 1e3)} s`)), timeoutMs);
+      const onAbort = () => ctrl.abort(options.signal?.reason);
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      let refusal;
+      try {
+        const aborted = new Promise((_, reject) => ctrl.signal.addEventListener("abort", () => reject(ctrl.signal.reason instanceof Error ? ctrl.signal.reason : new Error(String(ctrl.signal.reason ?? "cancelled"))), { once: true }));
+        const q = await Promise.race([p.getQuote({ ...params, dry: true, onRefusal: (r) => {
+          refusal = r;
+        } }, ctrl.signal), aborted]);
+        if (q && validQuote(q, { ...params, dry: true }, p.name)) quotes[p.name] = q;
+        else refusals[p.name] = refusal ?? (q ? "returned an invalid quote" : "no route for this pair right now");
+      } catch (e) {
+        refusals[p.name] = ctrl.signal.aborted ? String(ctrl.signal.reason instanceof Error ? ctrl.signal.reason.message : ctrl.signal.reason ?? "cancelled") : e instanceof Error ? e.message : String(e);
+      } finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+        pending.delete(p.name);
+        emit();
+      }
+    })
+  );
+  return view();
+}
+function rank(quotes) {
+  const sorted = [...quotes].sort((a, b) => BigInt(b.destAmount) > BigInt(a.destAmount) ? 1 : BigInt(b.destAmount) < BigInt(a.destAmount) ? -1 : a.feeUsd - b.feeUsd || a.etaSeconds - b.etaSeconds);
+  const fastest = sorted.length ? sorted.reduce((f, q) => q.etaSeconds < f.etaSeconds ? q : f) : null;
+  return sorted.map((q, i) => {
+    const poolFee = q.providerData?.poolFee;
+    const feeNote = typeof poolFee === "string" && poolFee && q.feeUsd === 0 ? poolFee === "pools" ? "pool fees in price" : `pool ${poolFee} in price` : void 0;
+    const tags = [];
+    if (i === 0) tags.push("best");
+    if (fastest && q.provider === fastest.provider) tags.push("fastest");
+    return { provider: q.provider, destAmount: q.destAmount, minDestAmount: q.minDestAmount, feeUsd: q.feeUsd, etaSeconds: q.etaSeconds, validUntilMs: q.validUntilMs, tags, ...feeNote ? { feeNote } : {} };
+  });
+}
+var FLOOR_TOLERANCE_BPS = 50n;
+function executionFloor(minDestAmount) {
+  const floor = minDestAmount * (10000n - FLOOR_TOLERANCE_BPS) / 10000n;
+  return floor > 0n ? floor : minDestAmount;
+}
+var APPROVE_SELECTOR = "0x095ea7b3";
+var TRANSFER_SELECTOR = "0xa9059cbb";
+var pad = (hexNoPrefix) => hexNoPrefix.toLowerCase().padStart(64, "0");
+var encodeApproveCalldata = (spender, amount) => `${APPROVE_SELECTOR}${pad(spender.slice(2))}${pad(amount.toString(16))}`;
+var lc3 = (s) => s.toLowerCase();
+function depositOf(s, approvals) {
+  if (approvals > 0) return void 0;
+  if (!s.data || s.data === "0x") return s.to;
+  if (!s.data.startsWith(TRANSFER_SELECTOR) || s.data.length < 10 + 64) return void 0;
+  return `0x${s.data.slice(10 + 24, 10 + 64)}`;
+}
+function swapApprovalPayload(plan, meta) {
+  const isOwn = meta.own.some((a) => lc3(a) === lc3(plan.recipient));
+  const checks = [{ status: "ok", label: `Built by the ${meta.providerLabel} module` }];
+  const s = plan.source;
+  let source;
+  if (s.kind === "call") {
+    const deposit = depositOf(s, plan.approvals.length);
+    source = { kind: "call", to: s.to, ...s.data ? { data: s.data } : {}, value: s.value.toString(), ...deposit ? { deposit } : {} };
+    checks.push(deposit ? { status: "ok", label: `Deposit address from the ${meta.providerLabel} quote` } : { status: "ok", label: `Calls the ${meta.providerLabel} contract` });
+  } else if (s.kind === "token-transfer") {
+    source = { kind: "token-transfer", token: s.token, recipient: s.recipient, amount: s.amount.toString(), ...s.memo ? { memo: s.memo } : {} };
+    checks.push({ status: "ok", label: `Deposit address from the ${meta.providerLabel} quote` });
+  } else if (s.kind === "serialized") {
+    source = { kind: "serialized" };
+    checks.push({ status: "ok", label: "Balance changes are proven before signing (SDK guard)" });
+  } else {
+    source = { kind: "typed-order" };
+    checks.push({ status: "ok", label: "Signed order \u2014 no transaction is sent from your wallet" });
+  }
+  for (const a of plan.approvals) checks.push(a.amount > plan.sourceAmount ? { status: "warn", label: "Approval is larger than this swap needs" } : { status: "ok", label: "Approval is exactly the amount needed" });
+  if (plan.approvals.length > 1) checks.push({ status: "ok", label: `${plan.approvals.length} approvals (reset to 0 first)` });
+  checks.push(isOwn ? { status: "ok", label: "Funds arrive at your address" } : { status: "warn", label: `Funds arrive at ${plan.recipient.slice(0, 6)}\u2026${plan.recipient.slice(-4)}, not your address` });
+  return {
+    provider: plan.provider,
+    providerLabel: meta.providerLabel,
+    fromChain: plan.fromChain,
+    toChain: plan.destChain,
+    fromChainName: meta.fromChainName,
+    toChainName: meta.toChainName,
+    send: { symbol: meta.fromSymbol, decimals: meta.fromDecimals, amount: plan.sourceAmount.toString() },
+    receive: { symbol: meta.toSymbol, decimals: meta.toDecimals, amount: plan.destAmount.toString(), min: plan.minDestAmount.toString() },
+    recipient: { address: plan.recipient, isOwn },
+    refundAddress: plan.refundAddress,
+    feeUsd: plan.feeUsd,
+    etaSeconds: plan.etaSeconds,
+    validUntilMs: plan.validUntilMs,
+    approvals: plan.approvals.map((a) => ({ token: a.token, spender: a.spender, amount: a.amount.toString() })),
+    source,
+    checks
+  };
+}
+function planMatchers(plan) {
+  const m = plan.approvals.map((a) => evmCallMatcher({ caip2: plan.fromChain, to: a.token, data: encodeApproveCalldata(a.spender, a.amount), value: 0n }));
+  const s = plan.source;
+  if (s.kind === "call") {
+    if (plan.fromChain.startsWith("eip155:")) m.push(evmCallMatcher({ caip2: plan.fromChain, to: s.to, data: s.data, value: s.value }));
+    else if (plan.fromChain.startsWith("solana:")) m.push((op) => op.kind === "solana-tx" && op.to === s.to && op.value === s.value);
+    else m.push(chainTxMatcher({ chain: plan.fromChain, to: s.to, amount: s.value, memo: s.memo }));
+  } else if (s.kind === "token-transfer") {
+    if (plan.fromChain.startsWith("eip155:")) m.push(evmCallMatcher({ caip2: plan.fromChain, to: s.token, data: `${TRANSFER_SELECTOR}${pad(s.recipient.slice(2))}${pad(s.amount.toString(16))}`, value: 0n }));
+    else if (plan.fromChain.startsWith("solana:")) m.push((op) => op.kind === "solana-transfer" && op.to === s.recipient && op.amount === s.amount && (op.token ?? "") === s.token);
+    else m.push(chainTxMatcher({ chain: plan.fromChain, to: s.recipient, amount: s.amount, token: s.token, memo: s.memo }));
+  } else if (s.kind === "serialized") {
+    m.push((op) => op.kind === "solana-serialized" && op.serializedTx === s.serializedTx);
+  } else {
+    m.push((op) => op.kind === "evm-typed-data" && op.caip2 === plan.fromChain);
+  }
+  return m;
+}
+function reviewSwapPlan(approvals, gate, meta) {
+  return async (plan) => {
+    const payload = swapApprovalPayload(plan, meta);
+    await approvals.request({ origin: meta.origin, chain: plan.fromChain, kind: "swap", payload });
+    gate.clear();
+    gate.preApprove(planMatchers(plan), Math.max(6e4, plan.validUntilMs - Date.now() + 5 * 6e4));
+  };
+}
+
+// src/swaps.ts
+import { SWAP2_ID_PREFIX } from "@anywalletkit/protocol-swap2-core";
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["pending", "action-required", "refund-pending", "partial", "claiming"]);
+function parseSwapId(id) {
+  if (!id.startsWith(`${SWAP2_ID_PREFIX}.`)) return null;
+  const parts = id.slice(SWAP2_ID_PREFIX.length + 1).split(".");
+  if (parts.length < 2 || parts.length > 3 || !parts[0] || !parts[1]) return null;
+  const provider = decodeURIComponent(parts[0]);
+  const intentId = decodeURIComponent(parts[1]);
+  const sourceTxHash = parts[2] ? decodeURIComponent(parts[2]) : void 0;
+  return sourceTxHash ? { provider, intentId, sourceTxHash } : { provider, intentId };
+}
+var SwapsStore = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  _records = null;
+  _listeners = /* @__PURE__ */ new Set();
+  async list() {
+    this._records ??= await this.storage.get() ?? [];
+    return [...this._records].sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async get(id) {
+    return (await this.list()).find((r) => r.id === id) ?? null;
+  }
+  async active() {
+    return (await this.list()).filter((r) => ACTIVE_STATUSES.has(r.status));
+  }
+  async add(record) {
+    const all = (await this.list()).filter((r) => r.id !== record.id);
+    await this.write([...all, record]);
+  }
+  async update(id, patch) {
+    const all = await this.list();
+    const i = all.findIndex((r) => r.id === id);
+    if (i < 0) return null;
+    const next = { ...all[i], ...patch, updatedAt: patch.updatedAt ?? Date.now() };
+    all[i] = next;
+    await this.write(all);
+    return next;
+  }
+  async remove(id) {
+    await this.write((await this.list()).filter((r) => r.id !== id));
+  }
+  onChange(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  async write(records) {
+    await this.storage.set(records);
+    this._records = records;
+    for (const l of this._listeners) l();
+  }
+};
+var SwapTracker = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? Date.now;
+  }
+  deps;
+  now;
+  ticking = null;
+  /** Record a just-executed swap and make sure the alarm runs. */
+  async track(input) {
+    const t = this.now();
+    const record = { ...input, status: input.status ?? "pending", destTxHash: null, createdAt: t, updatedAt: t, checks: 0 };
+    await this.deps.store.add(record);
+    await this.deps.alarm.start();
+    return record;
+  }
+  /** After the user's claim transaction went out: keep polling until the provider sees the mint. */
+  async claimed(id, destTxHash) {
+    await this.deps.store.update(id, { status: "claiming", destTxHash, claim: void 0 });
+    await this.deps.alarm.start();
+  }
+  /** One alarm tick: check every active record once; stop the alarm when nothing is active. Concurrent ticks coalesce. */
+  tick() {
+    this.ticking ??= this.run().finally(() => {
+      this.ticking = null;
+    });
+    return this.ticking;
+  }
+  async run() {
+    const active = await this.deps.store.active();
+    if (active.length === 0) {
+      await this.deps.alarm.stop();
+      return;
+    }
+    const giveUp = this.deps.giveUpAfterMs ?? 48 * 60 * 6e4;
+    for (const record of active) {
+      const patch = { checks: record.checks + 1, updatedAt: this.now() };
+      try {
+        const s = await this.deps.status(record);
+        patch.lastError = void 0;
+        if (s.depositReceived !== void 0) patch.depositReceived = s.depositReceived;
+        if (s.destTxHash) patch.destTxHash = s.destTxHash;
+        if (s.claim) patch.claim = s.claim;
+        patch.status = record.status === "claiming" && (s.state === "action-required" || s.state === "pending") ? "claiming" : s.state;
+      } catch (e) {
+        patch.lastError = e instanceof Error ? e.message : String(e);
+        if (this.now() - record.createdAt > giveUp) patch.status = "expired";
+      }
+      await this.deps.store.update(record.id, patch);
+    }
+    if ((await this.deps.store.active()).length === 0) await this.deps.alarm.stop();
+  }
+};
+
+// src/earn.ts
+var APPROVE_SELECTOR2 = "0x095ea7b3";
+function earnPlanMatchers(network, plan) {
+  return [...plan.approvals, plan.tx].map((t) => evmCallMatcher({ caip2: network.caip2, to: t.to, data: t.data, value: BigInt(t.value) }));
+}
+function earnApprovalPayload(plan, meta) {
+  const checks = [{ status: "ok", label: `Built by the ${meta.module} module` }, ...meta.checks ?? []];
+  for (const a of plan.approvals) {
+    if (!a.data?.startsWith(APPROVE_SELECTOR2)) checks.push({ status: "warn", label: `Unexpected pre-call to ${a.to.slice(0, 8)}\u2026` });
+  }
+  if (plan.approvals.length > 1) checks.push({ status: "ok", label: `${plan.approvals.length} approvals (reset to 0 first)` });
+  return { module: meta.module, action: meta.action, network: meta.network, facts: meta.facts, approvals: plan.approvals, tx: plan.tx, checks, preview: meta.preview ?? null };
+}
+async function reviewEarnPlan(approvals, gate, meta, plan) {
+  await approvals.request({ origin: meta.origin, chain: meta.network.caip2, kind: "earn", payload: earnApprovalPayload(plan, meta) });
+  gate.preApprove(earnPlanMatchers(meta.network, plan), 10 * 6e4);
+}
+
+// src/tonconnect.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+var TONCONNECT_ERRORS = { unknown: 0, badRequest: 1, manifestNotFound: 2, manifestContent: 3, unknownApp: 100, userDeclined: 300, methodNotSupported: 400 };
+var TonConnectError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TonConnectError";
+  }
+  code;
+};
+function parseConnectRequest(message) {
+  const m = message;
+  if (!m || typeof m.manifestUrl !== "string" || !/^https:\/\//.test(m.manifestUrl)) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "ConnectRequest needs an https manifestUrl.");
+  const items = Array.isArray(m.items) ? m.items : [];
+  if (!items.some((i) => i?.name === "ton_addr")) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "ConnectRequest must ask for ton_addr.");
+  const proof = items.find((i) => i?.name === "ton_proof");
+  if (proof && typeof proof.payload !== "string") throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "ton_proof needs a string payload.");
+  for (const i of items) if (i?.name !== "ton_addr" && i?.name !== "ton_proof") throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `Unknown connect item ${String(i?.name)}.`);
+  return { manifestUrl: m.manifestUrl, ...proof ? { proofPayload: proof.payload } : {} };
+}
+var TONCONNECT_MAX_MESSAGES = 4;
+function parseSendTransaction(param, options = {}) {
+  let o;
+  try {
+    o = typeof param === "string" ? JSON.parse(param) : param;
+  } catch {
+    throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "sendTransaction params[0] is not valid JSON.");
+  }
+  if (!o || typeof o !== "object") throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "sendTransaction needs a request object.");
+  const network = options.network ?? "-239";
+  if (o.network !== void 0 && String(o.network) !== network) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `This wallet is on network ${network}; the request names ${String(o.network)}.`);
+  const raw = Array.isArray(o.messages) ? o.messages : [];
+  if (raw.length === 0) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "sendTransaction has no messages.");
+  if (raw.length > (options.maxMessages ?? TONCONNECT_MAX_MESSAGES)) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `At most ${options.maxMessages ?? TONCONNECT_MAX_MESSAGES} messages per transaction.`);
+  const messages = raw.map((m, i) => {
+    if (typeof m.address !== "string" || !m.address) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `Message ${i + 1} has no address.`);
+    if (typeof m.amount !== "string" || !/^[0-9]+$/.test(m.amount)) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `Message ${i + 1} amount must be a decimal string of nanotons.`);
+    if (m.payload !== void 0 && typeof m.payload !== "string") throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `Message ${i + 1} payload must be a base64 BoC.`);
+    if (m.stateInit !== void 0 && typeof m.stateInit !== "string") throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `Message ${i + 1} stateInit must be a base64 BoC.`);
+    return { address: m.address, amount: m.amount, ...m.payload ? { payload: m.payload } : {}, ...m.stateInit ? { stateInit: m.stateInit } : {} };
+  });
+  const validUntil = typeof o.valid_until === "number" ? o.valid_until : typeof o.validUntil === "number" ? o.validUntil : void 0;
+  if (validUntil !== void 0 && validUntil * 1e3 < Date.now()) throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "The request has expired (valid_until is in the past).");
+  return { messages, ...validUntil !== void 0 ? { validUntil } : {}, ...o.network !== void 0 ? { network: String(o.network) } : {}, ...typeof o.from === "string" ? { from: o.from } : {} };
+}
+function parseSignData(param) {
+  let o;
+  try {
+    o = typeof param === "string" ? JSON.parse(param) : param;
+  } catch {
+    throw new TonConnectError(TONCONNECT_ERRORS.badRequest, "signData params[0] is not valid JSON.");
+  }
+  if (o?.type === "text" && typeof o.text === "string") return { type: "text", text: o.text };
+  if (o?.type === "binary" && typeof o.bytes === "string") return { type: "binary", bytes: o.bytes };
+  if (o?.type === "cell") throw new TonConnectError(TONCONNECT_ERRORS.methodNotSupported, "signData with a cell payload is not supported by this wallet.");
+  throw new TonConnectError(TONCONNECT_ERRORS.badRequest, 'signData payload must be { type: "text", text } or { type: "binary", bytes }.');
+}
+var utf82 = (s) => new TextEncoder().encode(s);
+var int32BE = (n) => {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setInt32(0, n, false);
+  return b;
+};
+var uint32LE = (n) => {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, n, true);
+  return b;
+};
+var uint32BE = (n) => {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, n, false);
+  return b;
+};
+var uint64LE = (n) => {
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setBigUint64(0, BigInt(n), true);
+  return b;
+};
+var uint64BE = (n) => {
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setBigUint64(0, BigInt(n), false);
+  return b;
+};
+var concat = (...parts) => {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+};
+function tonProofMessage(input) {
+  if (input.address.hash.length !== 32) throw new TonConnectError(TONCONNECT_ERRORS.unknown, "address hash must be 32 bytes");
+  const domain = utf82(input.domain);
+  const inner = concat(utf82("ton-proof-item-v2/"), int32BE(input.address.workchain), input.address.hash, uint32LE(domain.length), domain, uint64LE(input.timestamp), utf82(input.payload));
+  return sha256(concat(new Uint8Array([255, 255]), utf82("ton-connect"), sha256(inner)));
+}
+function tonSignDataMessage(input) {
+  if (input.address.hash.length !== 32) throw new TonConnectError(TONCONNECT_ERRORS.unknown, "address hash must be 32 bytes");
+  const domain = utf82(input.domain);
+  const payload = input.payload.type === "text" ? utf82(input.payload.text) : Uint8Array.from(atob(input.payload.bytes), (c) => c.charCodeAt(0));
+  const prefix = utf82(input.payload.type === "text" ? "txt" : "bin");
+  return sha256(concat(new Uint8Array([255, 255]), utf82("ton-connect/sign-data/"), int32BE(input.address.workchain), input.address.hash, uint32BE(domain.length), domain, uint64BE(input.timestamp), prefix, uint32BE(payload.length), payload));
+}
+function parseRawAddress(raw) {
+  const m = /^(-?\d+):([0-9a-fA-F]{64})$/.exec(raw);
+  if (!m) throw new TonConnectError(TONCONNECT_ERRORS.unknown, `not a raw TON address: ${raw}`);
+  return { workchain: Number(m[1]), hash: Uint8Array.from(m[2].match(/../g), (h) => Number.parseInt(h, 16)) };
+}
+function proofDomain(origin) {
+  try {
+    return new URL(origin).host;
+  } catch {
+    throw new TonConnectError(TONCONNECT_ERRORS.badRequest, `bad origin ${origin}`);
+  }
+}
+function tonConnectErrorCode(e) {
+  if (e instanceof TonConnectError) return e.code;
+  const code = e?.code;
+  if (code === 4001) return TONCONNECT_ERRORS.userDeclined;
+  if (code === 4100) return TONCONNECT_ERRORS.unknownApp;
+  if (code === 4200) return TONCONNECT_ERRORS.methodNotSupported;
+  if (code === -32602) return TONCONNECT_ERRORS.badRequest;
+  return TONCONNECT_ERRORS.unknown;
+}
+
+// src/phishing.ts
+var PhishingDetector = class {
+  black;
+  white;
+  fuzzy;
+  tolerance;
+  constructor(list) {
+    this.black = new Set(list.blacklist.map(normalizeHost));
+    this.white = new Set((list.whitelist ?? []).map(normalizeHost));
+    this.fuzzy = [...new Set([...list.fuzzylist ?? [], ...list.extraFuzzylist ?? []].map(normalizeHost))];
+    this.tolerance = list.tolerance ?? 1;
+  }
+  get size() {
+    return this.black.size;
+  }
+  check(hostOrOrigin) {
+    const host = hostOf(hostOrOrigin);
+    const warnings = [];
+    if (!host) return { host, blocked: false, warnings };
+    if (matchesList(host, this.white)) return { host, blocked: false, warnings };
+    if (matchesList(host, this.black)) return { host, blocked: true, warnings: ["This site is on the shipped phishing list."] };
+    if (host.split(".").some((l) => l.startsWith("xn--"))) warnings.push("The address uses punycode (xn--): it may imitate another site with look-alike characters.");
+    const look = this.lookalike(host);
+    if (look) warnings.push(`The address looks like ${look} but is not that site.`);
+    else {
+      const brand = this.brandInLabel(host);
+      if (brand) warnings.push(`The address contains the name of ${brand.known} (\u201C${brand.label}\u201D) but is not that site.`);
+    }
+    return { host, blocked: false, warnings };
+  }
+  /**
+   * `metamask.io-login.com`, `app-uniswap.com`, `uniswap.org.evil.net`: a known site's name used as (part of) a label
+   * of a host that is not that site. Names shorter than 5 characters are skipped (too many honest matches).
+   */
+  brandInLabel(host) {
+    const labels = host.split(".");
+    for (const known of this.fuzzy) {
+      if (host === known || host.endsWith(`.${known}`)) return null;
+      const name = stripForFuzzy(known).split(".").pop() ?? "";
+      if (name.length < 5) continue;
+      const hit = labels.find((l) => l.includes(name));
+      if (hit) return { known, label: hit };
+    }
+    return null;
+  }
+  /** eth-phishing-detect's fuzzy check: the host (minus the TLD and a www.) within `tolerance` edits of a known one. */
+  lookalike(host) {
+    const probe = stripForFuzzy(host);
+    const probeName = probe.split(".").pop() ?? probe;
+    for (const known of this.fuzzy) {
+      if (host === known || host.endsWith(`.${known}`)) return null;
+      const stripped = stripForFuzzy(known);
+      if (levenshtein(probe, stripped) <= this.tolerance) return known;
+      const name = stripped.split(".").pop() ?? stripped;
+      if (name.length >= 5 && name !== probeName && levenshtein(probeName, name) <= this.tolerance) return known;
+    }
+    return null;
+  }
+};
+var normalizeHost = (h) => h.trim().toLowerCase().replace(/\.$/, "");
+function hostOf(hostOrOrigin) {
+  try {
+    return normalizeHost(new URL(hostOrOrigin.includes("://") ? hostOrOrigin : `https://${hostOrOrigin}`).hostname);
+  } catch {
+    return normalizeHost(hostOrOrigin);
+  }
+}
+function matchesList(host, list) {
+  const parts = host.split(".");
+  for (let i = 0; i < parts.length - 1; i++) if (list.has(parts.slice(i).join("."))) return true;
+  return list.has(host);
+}
+function stripForFuzzy(host) {
+  const parts = host.replace(/^www\./, "").split(".");
+  if (parts.length > 1) parts.pop();
+  return parts.join(".");
+}
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  const m = a.length, n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = Array.from({ length: n + 1 }, (_, j) => j);
+  for (let i = 1; i <= m; i++) {
+    const cur = [i];
+    for (let j = 1; j <= n; j++) cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    prev = cur;
+  }
+  return prev[n];
+}
+
+// src/webauthn.ts
+var FLAG_UP = 1;
+var FLAG_UV = 4;
+async function verifyAssertion(input, expect) {
+  const c = expect.crypto ?? globalThis.crypto;
+  try {
+    if (expect.alg !== -7) return { ok: false, reason: `unsupported algorithm ${expect.alg} (ES256 only)` };
+    const authData = fromBase64Url(input.authenticatorData);
+    const clientData = fromBase64Url(input.clientDataJSON);
+    const signature = fromBase64Url(input.signature);
+    if (authData.length < 37) return { ok: false, reason: "authenticatorData too short" };
+    let client;
+    try {
+      client = JSON.parse(new TextDecoder().decode(clientData));
+    } catch {
+      return { ok: false, reason: "clientDataJSON is not JSON" };
+    }
+    if (client.type !== "webauthn.get") return { ok: false, reason: `clientData.type is ${String(client.type)}` };
+    if (client.origin !== expect.origin) return { ok: false, reason: `assertion origin ${String(client.origin)} is not ${expect.origin}` };
+    if (client.crossOrigin === true) return { ok: false, reason: "cross-origin assertion" };
+    if (typeof client.challenge !== "string" || !equal(fromBase64Url(client.challenge), expect.challenge)) return { ok: false, reason: "challenge does not match this request" };
+    const rpIdHash = new Uint8Array(await c.subtle.digest("SHA-256", toArrayBuffer(new TextEncoder().encode(expect.rpId))));
+    if (!equal(authData.subarray(0, 32), rpIdHash)) return { ok: false, reason: "rpIdHash does not match this extension" };
+    const flags = authData[32];
+    if (!(flags & FLAG_UP)) return { ok: false, reason: "user presence flag not set" };
+    if (expect.requireUserVerification !== false && !(flags & FLAG_UV)) return { ok: false, reason: "user verification flag not set" };
+    const counter = (authData[33] << 24 | authData[34] << 16 | authData[35] << 8 | authData[36]) >>> 0;
+    const clientHash = new Uint8Array(await c.subtle.digest("SHA-256", toArrayBuffer(clientData)));
+    const signed = new Uint8Array(authData.length + clientHash.length);
+    signed.set(authData, 0);
+    signed.set(clientHash, authData.length);
+    const raw = derToRaw(signature);
+    if (!raw) return { ok: false, reason: "signature is not a DER ECDSA signature" };
+    const key = await c.subtle.importKey("spki", toArrayBuffer(fromBase64(expect.publicKey)), { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    const ok = await c.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, key, toArrayBuffer(raw), toArrayBuffer(signed));
+    return ok ? { ok: true, counter } : { ok: false, reason: "signature does not verify against the registered passkey" };
+  } catch (e) {
+    return { ok: false, reason: e instanceof Error ? e.message : String(e) };
+  }
+}
+function derToRaw(der) {
+  if (der[0] !== 48) return null;
+  let i = 2;
+  if (der[1] & 128) i = 2 + (der[1] & 127);
+  const int = () => {
+    if (der[i] !== 2) return null;
+    const len = der[i + 1];
+    const start = i + 2;
+    i = start + len;
+    let v = der.subarray(start, start + len);
+    while (v.length > 32 && v[0] === 0) v = v.subarray(1);
+    if (v.length > 32) return null;
+    const out = new Uint8Array(32);
+    out.set(v, 32 - v.length);
+    return out;
+  };
+  const r = int();
+  if (!r) return null;
+  const s = int();
+  if (!s) return null;
+  const raw = new Uint8Array(64);
+  raw.set(r, 0);
+  raw.set(s, 32);
+  return raw;
+}
+function rawToDer(raw) {
+  const enc = (v) => {
+    let i = 0;
+    while (i < v.length - 1 && v[i] === 0) i++;
+    let body = Array.from(v.subarray(i));
+    if (body[0] & 128) body = [0, ...body];
+    return [2, body.length, ...body];
+  };
+  const r = enc(raw.subarray(0, 32));
+  const s = enc(raw.subarray(32, 64));
+  return Uint8Array.from([48, r.length + s.length, ...r, ...s]);
+}
+async function approvalChallenge(request, c = globalThis.crypto) {
+  const text = JSON.stringify([request.id, request.kind, request.origin, request.payload]);
+  return new Uint8Array(await c.subtle.digest("SHA-256", toArrayBuffer(new TextEncoder().encode(text))));
+}
+function equal(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a[i] ^ b[i];
+  return d === 0;
+}
+
+// src/poison.ts
+var LOOKALIKE_PREFIX = 4;
+var LOOKALIKE_SUFFIX = 4;
+var norm = (a) => a.trim().toLowerCase().replace(/^0x/, "");
+function lookalikeOf(address, known) {
+  const a = norm(address);
+  if (a.length < LOOKALIKE_PREFIX + LOOKALIKE_SUFFIX + 1) return null;
+  for (const k of known) {
+    const b = norm(k);
+    if (b === a || b.length !== a.length) continue;
+    if (a.startsWith(b.slice(0, LOOKALIKE_PREFIX)) && a.endsWith(b.slice(-LOOKALIKE_SUFFIX))) return k;
+  }
+  return null;
+}
+var RecipientBook = class {
+  constructor(storage, cap = 500) {
+    this.storage = storage;
+    this.cap = cap;
+  }
+  storage;
+  cap;
+  _state = null;
+  async state() {
+    this._state ??= await this.storage.get() ?? {};
+    return this._state;
+  }
+  async list(namespace) {
+    return [...(await this.state())[namespace] ?? []];
+  }
+  async remember(namespace, address) {
+    const s = { ...await this.state() };
+    const list = (s[namespace] ?? []).filter((a) => norm(a) !== norm(address));
+    list.push(address);
+    s[namespace] = list.slice(-this.cap);
+    await this.storage.set(s);
+    this._state = s;
+  }
+  /** `known` → the address is one the user paid before; `lookalike` → it imitates one. */
+  async check(namespace, address) {
+    const list = await this.list(namespace);
+    const known = list.some((a) => norm(a) === norm(address));
+    return { known, lookalike: known ? null : lookalikeOf(address, list) };
+  }
+};
+export {
+  ACTIVE_STATUSES,
+  APPROVALS_MAX_PENDING_PER_ORIGIN,
+  ApprovalQueue,
+  BTC_CHAIN,
+  BTC_ESPLORA,
+  CHAIN_ACCOUNT_KEYS,
+  DEFAULT_CHAIN,
+  DEFAULT_NETWORKS,
+  FLOOR_TOLERANCE_BPS,
+  KEYRING_STORAGE_KEY,
+  LOOKALIKE_PREFIX,
+  LOOKALIKE_SUFFIX,
+  NEAR_CHAIN,
+  NEAR_PROVIDERS,
+  NON_EVM_CHAINS,
+  NetworksTable,
+  PAGE_TARGET,
+  PORT_NAME,
+  PermissionStore,
+  PhishingDetector,
+  QueueLimitError,
+  READ_METHODS,
+  RELAY_ERRORS,
+  RecipientBook,
+  RequestRouter,
+  ReviewDeclined,
+  ReviewGate,
+  RouterError,
+  SESSION_DEFAULT_AUTOLOCK_MS,
+  SIGNING_METHODS,
+  SOLANA_CHAIN,
+  SOLANA_RPCS,
+  Session,
+  SwapTracker,
+  SwapsStore,
+  TONCONNECT_ERRORS,
+  TONCONNECT_MAX_MESSAGES,
+  TON_CHAIN,
+  TON_ENDPOINTS,
+  TRON_CHAIN,
+  TRON_PROVIDERS,
+  TonConnectError,
+  VAULT_DEFAULT_ITERATIONS,
+  VAULT_MIN_ITERATIONS,
+  VAULT_MIN_PASSWORD_LENGTH,
+  VAULT_MIN_SCRYPT,
+  VAULT_SCRYPT,
+  VAULT_STORAGE_KEY,
+  Vault,
+  VaultError,
+  ZCASH_BLOCKCHAIR,
+  ZCASH_CHAIN,
+  approvalChallenge,
+  caip2FromChainId,
+  chainHex,
+  chainTxMatcher,
+  checkSenderOrigin,
+  chromeAlarms,
+  chromeJsonStorage,
+  chromeKeyringStorage,
+  chromeLocalVaultStorage,
+  chromeSessionStorage,
+  classifySignRequest,
+  createSignHandler,
+  decodedMessage,
+  derToRaw,
+  describeSiwe,
+  earnApprovalPayload,
+  earnPlanMatchers,
+  encodeApproveCalldata,
+  evmCallMatcher,
+  executionFloor,
+  fromBase64Url,
+  hostOf,
+  isCatalogChain,
+  isEnvelopeV1,
+  isEnvelopeV2,
+  isLocalHost,
+  isPageEvent,
+  isPageRequest,
+  isPageResponse,
+  isRelayRequest,
+  isRelayToContent,
+  levenshtein,
+  lookalikeOf,
+  memoryAlarms,
+  memoryApprovalWindow,
+  memoryJsonStorage,
+  memorySessionStorage,
+  memoryVaultStorage,
+  messageText,
+  newRequestId,
+  nonEvmChain,
+  normalizeHost,
+  parseAddChainParams,
+  parseConnectRequest,
+  parseRawAddress,
+  parseSendTransaction,
+  parseSignData,
+  parseSiwe,
+  parseSwapId,
+  planMatchers,
+  prepareTransaction,
+  proofDomain,
+  quoteRoutes,
+  rank,
+  rawToDer,
+  relayError,
+  reviewEarnPlan,
+  reviewSwapPlan,
+  siweProblems,
+  stampOrigin,
+  swapApprovalPayload,
+  toBase64Url,
+  toRelayError,
+  tonConnectErrorCode,
+  tonProofMessage,
+  tonSignDataMessage,
+  vaultSecretStorage,
+  verifyAssertion
+};
+//# sourceMappingURL=index.js.map