@anywalletkit/extension-kit 0.1.4 → 0.2.0

package/README.md

@@ -36,17 +36,17 @@ pnpm add @anywalletkit/extension-kit @anywalletkit/core @anywalletkit/keyring
 | Vault | `Vault`, `chromeLocalVaultStorage`, `memoryVaultStorage`, `VAULT_SCRYPT`, `VAULT_LIMITS`, `VAULT_MIN_PASSWORD_LENGTH` | every secret at rest in `chrome.storage.local`, two key layers (a KEK wraps a DEK, the DEK seals each secret); passkey (WebAuthn PRF) unlock as a second wrap of the same DEK |
 | Session | `Session`, `chromeSessionStorage`, `chromeAlarms`, `SESSION_DEFAULT_AUTOLOCK_MS` | the DEK in `chrome.storage.session` with an expiry and an alarm; `getKey()` re-checks the expiry itself |
 | Keyring adapters | `chromeKeyringStorage`, `vaultSecretStorage` | `@anywalletkit/keyring` metadata as plain JSON, secrets through the vault, one DEK use per call |
-| Relay | `PageRequest` / `RelayRequest` shapes and guards, `stampOrigin`, `checkSenderOrigin`, `RELAY_ERRORS` | page ⇄ content script ⇄ service worker messages; the origin is the browser's (`port.sender`), never the page's |
+| Relay | `PageRequest` / `RelayRequest` shapes and guards, `pageRequestFrom`, `stampOrigin`, `checkSenderOrigin`, `RELAY_ERRORS` | page ⇄ content script ⇄ service worker messages; the content script takes only messages the page window itself posted (`pageRequestFrom(event, window)`: an iframe's `parent.postMessage` is not the site), and the origin is the browser's (`port.sender`), never the page's |
 | Router | `RequestRouter`, `READ_METHODS`, `SIGNING_METHODS`, `toRelayError` | what a dApp may call: accounts only for connected origins, chain add / switch through the approval window, reads from the wallet's own RPCs, `eth_sign` never offered, everything else 4200 |
 | Permissions | `PermissionStore`, `CHAIN_ACCOUNT_KEYS` | per-origin accounts (EVM, Solana, TON, Tron, Bitcoin, NEAR) and chain |
 | Approvals | `ApprovalQueue`, `ReviewDeclined`, `QueueLimitError`, `APPROVALS_MAX_PENDING_PER_ORIGIN` | one approval window at a time, at most 3 pending requests per origin and one pending `connect`; transport notes (`setVia`) for WalletConnect peers |
 | Signing | `classifySignRequest`, `prepareTransaction`, `createSignHandler`, `messageText` | connected-address and chain checks, EIP-7702 delegations from sites refused, nonce / gas / fees from the wallet's RPC |
 | Networks | `NetworksTable`, `DEFAULT_NETWORKS`, `parseAddChainParams`, Solana / TON / Tron endpoints | EVM networks with public RPC failover lists; `wallet_addEthereumChain` only for catalog chains, https only, `eth_chainId` verified, site-supplied RPCs stamped `custom` |
 | Review gate | `ReviewGate`, `evmCallMatcher`, `chainTxMatcher` | after one sheet reviewed a whole plan, exactly those operations pass once within a TTL |
-| Swaps | `quoteRoutes`, `reviewSwapPlan`, `executionFloor`, `SwapsStore`, `SwapTracker`, `parseSwapId` | progressive quotes over swap2 providers, one review sheet per plan, pending swaps resumed across worker restarts |
-| Earn | `reviewEarnPlan`, `earnPlanMatchers` | one sheet for an Earn module's plan (approvals + call) |
-| TON Connect | `parseConnectRequest`, `parseSendTransaction`, `parseSignData`, `tonProofMessage`, `tonSignDataMessage` | the pure-data half of TON Connect v2 (the bytes `ton_proof` and `signData` sign) |
-| Phishing | `PhishingDetector` | MetaMask `eth-phishing-detect` list format, shipped with the build (never fetched at runtime), fuzzy lookalikes, brand-in-label, punycode |
+| Swaps | `quoteRoutes`, `reviewSwapPlan`, `executionFloor`, `SwapsStore`, `SwapTracker`, `parseSwapId` | progressive quotes over swap2 providers, one review sheet per plan (a gasless order is shown and matched by its EIP-712 hash), pre-approvals bound to the reviewing account (`meta.account`), pending swaps resumed across worker restarts |
+| Earn | `reviewEarnPlan`, `earnPlanMatchers` | one sheet for an Earn module's plan (approvals + call), bound to `meta.account` |
+| TON Connect | `parseConnectRequest`, `parseSendTransaction`, `parseSignData`, `tonProofMessage`, `tonSignDataMessage` | the pure-data half of TON Connect v2 (the digests `ton_proof` and `signData` sign, to verify them); the account signs with `signTonProof` / `signTonConnectData` (wallet-ton) — `sign()` refuses 32-byte digests |
+| Phishing | `PhishingDetector` | MetaMask `eth-phishing-detect` list format, shipped with the build (never fetched at runtime); a listed site is refused (`refusal` → `refuse` on `ApprovalQueue` and `RequestRouter`, 4100, no window); fuzzy lookalikes, brand-in-label, punycode warn |
 | SIWE | `parseSiwe`, `siweProblems`, `describeSiwe` | EIP-4361 sign-in messages: domain vs. the asking site, address, chain, expiry, nonce (warnings) |
 | Address poisoning | `lookalikeOf`, `RecipientBook` | warns when a new recipient imitates one the user confirmed |
 | WebAuthn | `verifyAssertion`, `approvalChallenge`, `derToRaw`, `rawToDer` | ES256 assertion check for "passkey on every signature"; the worker never trusts the page's word |
@@ -76,8 +76,11 @@ pnpm add @anywalletkit/extension-kit @anywalletkit/core @anywalletkit/keyring
 - **Errors to pages.** `toRelayError(e, { log })` passes the wallet's own refusals
   (EIP-1193 codes) and a node's JSON-RPC error (code, revert data) with URLs
   removed; anything else is `-32603 Internal error` on the page and goes to `log`.
-- **Origins.** The service worker answers a relay message only when the
-  content script's stamped origin equals `port.sender.origin`. Permissions are
+- **Origins.** The content script relays only what the page window itself
+  posted (`pageRequestFrom`: `event.source` is the page, `event.origin` its
+  origin), so an ad or embed in an iframe cannot speak as the site. The
+  service worker answers a relay message only when the content script's
+  stamped origin equals `port.sender.origin`. Permissions are
   keyed by that origin, never by a URL a page or a WalletConnect peer claims.
 - **Requests.** Everything that reveals accounts or moves funds goes through
   the approval queue; blind signing (`eth_sign`) is not offered; typed data for

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(src_exports, {
   NEAR_PROVIDERS: () => NEAR_PROVIDERS,
   NON_EVM_CHAINS: () => NON_EVM_CHAINS,
   NetworksTable: () => NetworksTable,
+  OriginRefused: () => OriginRefused,
   PAGE_TARGET: () => PAGE_TARGET,
   PORT_NAME: () => PORT_NAME,
   PermissionStore: () => PermissionStore,
@@ -115,6 +116,7 @@ __export(src_exports, {
   newRequestId: () => newRequestId,
   nonEvmChain: () => nonEvmChain,
   normalizeHost: () => normalizeHost,
+  pageRequestFrom: () => pageRequestFrom,
   parseAddChainParams: () => parseAddChainParams,
   parseConnectRequest: () => parseConnectRequest,
   parseRawAddress: () => parseRawAddress,
@@ -139,6 +141,7 @@ __export(src_exports, {
   tonConnectErrorCode: () => tonConnectErrorCode,
   tonProofMessage: () => tonProofMessage,
   tonSignDataMessage: () => tonSignDataMessage,
+  typedDataMatcher: () => typedDataMatcher,
   vaultSecretStorage: () => vaultSecretStorage,
   verifyAssertion: () => verifyAssertion
 });
@@ -179,6 +182,14 @@ function toArrayBuffer(bytes) {
   copy.set(bytes);
   return copy.buffer;
 }
+async function withSecretBuffer(bytes, fn) {
+  const buffer = toArrayBuffer(bytes);
+  try {
+    return await fn(buffer);
+  } finally {
+    new Uint8Array(buffer).fill(0);
+  }
+}
 
 // src/vault.ts
 var VAULT_MIN_ITERATIONS = 6e5;
@@ -446,7 +457,13 @@ var Vault = class {
   }
   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"]);
+    const pw = new TextEncoder().encode(password.normalize("NFKC"));
+    let material;
+    try {
+      material = await withSecretBuffer(pw, (b) => subtle.importKey("raw", b, "PBKDF2", false, ["deriveKey"]));
+    } finally {
+      (0, import_core.zeroize)(pw);
+    }
     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) {
@@ -458,7 +475,7 @@ var Vault = class {
       (0, import_core.zeroize)(pw);
     }
     try {
-      return await this._crypto.subtle.importKey("raw", toArrayBuffer(raw), { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+      return await withSecretBuffer(raw, (b) => this._crypto.subtle.importKey("raw", b, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]));
     } finally {
       (0, import_core.zeroize)(raw);
     }
@@ -466,16 +483,16 @@ var Vault = class {
   /** 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"]);
+    const ikm = await withSecretBuffer(prf, (b) => subtle.importKey("raw", b, "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"]);
+    return withSecretBuffer(dek, (b) => this._crypto.subtle.importKey("raw", b, { 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));
+    const ct = await withSecretBuffer(plaintext, (b) => this._crypto.subtle.encrypt({ name: "AES-GCM", iv: toArrayBuffer(iv), additionalData: toArrayBuffer(new TextEncoder().encode(aad)) }, key, b));
     return { iv: toBase64(iv), data: toBase64(new Uint8Array(ct)) };
   }
   async _open(key, box, aad, onFail) {
@@ -660,22 +677,40 @@ var Session = class {
     if (was !== void 0 && was !== null) for (const cb of this._onLock) cb();
   }
   _expiry() {
-    return this._autoLockMs > 0 ? this._now() + this._autoLockMs : Number.POSITIVE_INFINITY;
+    return this._autoLockMs > 0 ? this._now() + this._autoLockMs : null;
   }
   async _arm(expiresAt) {
-    if (Number.isFinite(expiresAt)) await this._alarms.schedule(this._alarm, expiresAt);
+    if (expiresAt !== null) await this._alarms.schedule(this._alarm, expiresAt);
     else await this._alarms.clear(this._alarm);
   }
+  /** The stored record, or `null` when locked. A record that is there but unreadable locks the wallet (removed, listeners told). */
   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()) {
+    if (raw === void 0 || raw === null) return null;
+    const r = raw;
+    const expiryOk = r.expiresAt === null || typeof r.expiresAt === "number" && Number.isFinite(r.expiresAt);
+    if (typeof raw !== "object" || typeof r.key !== "string" || !expiryOk || !isKey(r.key)) {
       await this._lockNow();
       return null;
     }
-    return raw;
+    if (r.expiresAt !== null && r.expiresAt <= this._now()) {
+      await this._lockNow();
+      return null;
+    }
+    return r;
   }
 };
+function isKey(text) {
+  let bytes;
+  try {
+    bytes = fromBase64(text);
+  } catch {
+    return false;
+  }
+  const ok = bytes.length === 32;
+  (0, import_core2.zeroize)(bytes);
+  return ok;
+}
 function memorySessionStorage() {
   const data = /* @__PURE__ */ new Map();
   return {
@@ -752,6 +787,10 @@ function isRelayToContent(x) {
 function newRequestId() {
   return crypto.randomUUID();
 }
+function pageRequestFrom(event, page) {
+  if (event.source !== page || event.origin !== page.location.origin) return null;
+  return isPageRequest(event.data) ? event.data : null;
+}
 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 };
@@ -980,14 +1019,27 @@ var NetworksTable = class {
     return this._loading;
   }
 };
+function isPrivateRpcHost(url) {
+  const m = /^https:\/\/(?:[^@/?#]*@)?(\[[^\]]+\]|[^:/?#]+)/i.exec(url);
+  if (!m) return true;
+  const h = m[1].toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  if (h === "localhost" || h.endsWith(".localhost") || h.endsWith(".local") || h === "0.0.0.0") return true;
+  const v4 = /^(\d{1,3})\.(\d{1,3})\.\d{1,3}\.\d{1,3}$/.exec(h);
+  if (v4) {
+    const a = Number(v4[1]), b = Number(v4[2]);
+    return a === 127 || a === 10 || a === 0 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+  }
+  if (h.includes(":")) return h === "::1" || h === "::" || /^f[cd]/.test(h) || /^fe[89ab]/.test(h);
+  return false;
+}
 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 rpcs = Array.isArray(p.rpcUrls) ? p.rpcUrls.filter((u) => typeof u === "string" && /^https:\/\/[^\s/?#]+/i.test(u) && !isPrivateRpcHost(u)) : [];
+  if (rpcs.length === 0) return relayError(RELAY_ERRORS.invalidParams, "rpcUrls must contain at least one public https URL (a site cannot add a private / local endpoint).");
   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.");
@@ -1184,6 +1236,13 @@ var QueueLimitError = class extends Error {
   }
   code;
 };
+var OriginRefused = class extends Error {
+  code = RELAY_ERRORS.unauthorized;
+  constructor(message) {
+    super(message);
+    this.name = "OriginRefused";
+  }
+};
 var APPROVALS_MAX_PENDING_PER_ORIGIN = 3;
 var ApprovalQueue = class {
   constructor(window, newId = () => crypto.randomUUID(), options = {}) {
@@ -1203,6 +1262,13 @@ var ApprovalQueue = class {
   _via = /* @__PURE__ */ new Map();
   /** Enqueue and wait for the user's answer. Refuses (never queues) past the per-origin limits. */
   request(input) {
+    let refused;
+    try {
+      refused = this.options.refuse?.(input.origin);
+    } catch (e) {
+      refused = `The wallet could not check this site (${e instanceof Error ? e.message : String(e)}).`;
+    }
+    if (refused) return Promise.reject(new OriginRefused(refused));
     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."));
@@ -1391,6 +1457,8 @@ var RequestRouter = class {
     return await this.deps.networks.get(wanted) ?? await this.deps.networks.get(DEFAULT_CHAIN);
   }
   async handle(origin, chain, method, rawParams) {
+    const refused = this.deps.refuse?.(origin);
+    if (refused) throw new RouterError(RELAY_ERRORS.unauthorized, refused);
     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);
@@ -1699,6 +1767,23 @@ 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 readFees(deps, network, block) {
+  const b = block === void 0 ? await deps.rpc(network, "eth_getBlockByNumber", ["latest", false]) : block;
+  const base = b?.baseFeePerGas != null ? big(b.baseFeePerGas) : null;
+  if (base === null) return { gasPrice: big(await deps.rpc(network, "eth_gasPrice", [])) };
+  const floor = deps.tipFloor?.(network.chainId) ?? MIN_TIP_WEI;
+  const nodeTip = await deps.rpc(network, "eth_maxPriorityFeePerGas", []).then(big).catch(() => 0n);
+  return { base, tip: nodeTip > floor ? nodeTip : floor };
+}
+function withFees(chainId, nonce, gasLimit, fees) {
+  if ("gasPrice" in fees) return { chainId, nonce, gasLimit: hex(gasLimit), gasPrice: hex(fees.gasPrice), maxFee: (gasLimit * fees.gasPrice).toString() };
+  const maxFeePerGas = fees.base * 2n + fees.tip;
+  return { chainId, nonce, gasLimit: hex(gasLimit), maxFeePerGas: hex(maxFeePerGas), maxPriorityFeePerGas: hex(fees.tip), maxFee: (gasLimit * maxFeePerGas).toString() };
+}
+function outgrown(shown, now) {
+  if ("gasPrice" in now) return shown.gasPrice === void 0 || now.gasPrice > big(shown.gasPrice);
+  return shown.maxFeePerGas === void 0 || now.base + now.tip > big(shown.maxFeePerGas);
+}
 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([
@@ -1708,18 +1793,20 @@ async function prepareTransaction(deps, network, from, tx) {
   ]);
   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: safeNonce(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: safeNonce(big(nonceHex)), gasLimit: hex(gasLimit), maxFeePerGas: hex(maxFeePerGas), maxPriorityFeePerGas: hex(tip), maxFee: (gasLimit * maxFeePerGas).toString() };
+  return withFees(network.chainId, safeNonce(big(nonceHex)), gasLimit, await readFees(deps, network, block));
 }
 function createSignHandler(deps) {
+  const tails = /* @__PURE__ */ new Map();
+  const nextNonce = /* @__PURE__ */ new Map();
+  const serial = (key, fn) => {
+    const run = (tails.get(key) ?? Promise.resolve()).then(fn, fn);
+    const tail = run.then(() => void 0, () => void 0);
+    tails.set(key, tail);
+    void tail.then(() => {
+      if (tails.get(key) === tail) tails.delete(key);
+    });
+    return run;
+  };
   return async ({ origin, network, method, params, accounts }) => {
     const via = deps.approvals.viaFor(origin);
     const info = classifySignRequest({ network, method, params, accounts, origin, ...via ? { via } : {} });
@@ -1728,6 +1815,41 @@ function createSignHandler(deps) {
     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 });
+    if (info.kind === "send-transaction") {
+      const key = `${network.caip2}|${lc(info.account)}`;
+      return serial(key, async () => {
+        let shown = prepared;
+        for (; ; ) {
+          const [nonceHex, fees] = await Promise.all([deps.rpc(network, "eth_getTransactionCount", [info.account, "pending"]), readFees(deps, network)]);
+          const local = nextNonce.get(key) ?? 0;
+          const nodeNonce = safeNonce(big(nonceHex));
+          const nonce = nodeNonce > local ? nodeNonce : local;
+          if (outgrown(shown, fees)) {
+            shown = withFees(network.chainId, nonce, big(shown.gasLimit), fees);
+            await deps.approvals.request({ origin, chain: network.caip2, kind: info.kind, payload: { ...payload, prepared: shown, repriced: true } });
+            continue;
+          }
+          const handle2 = await deps.signerFor(info.account, network);
+          let raw;
+          try {
+            raw = await handle2.signer.signTransaction({
+              chainId: shown.chainId,
+              nonce,
+              to: info.tx.to,
+              value: BigInt(info.tx.value),
+              data: info.tx.data ?? "0x",
+              gasLimit: BigInt(shown.gasLimit),
+              ...shown.gasPrice !== void 0 ? { gasPrice: BigInt(shown.gasPrice) } : { maxFeePerGas: BigInt(shown.maxFeePerGas), maxPriorityFeePerGas: BigInt(shown.maxPriorityFeePerGas) }
+            });
+          } finally {
+            handle2.dispose();
+          }
+          const hash = await deps.rpc(network, "eth_sendRawTransaction", [raw]);
+          nextNonce.set(key, nonce + 1);
+          return hash;
+        }
+      });
+    }
     const handle = await deps.signerFor(info.account, network);
     try {
       switch (info.kind) {
@@ -1735,19 +1857,6 @@ function createSignHandler(deps) {
           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();
@@ -1756,22 +1865,28 @@ function createSignHandler(deps) {
 }
 
 // src/gate.ts
+var HEX_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+var sameAccount = (a, b) => a === b || HEX_ADDRESS.test(a) && a.toLowerCase() === b.toLowerCase();
 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) {
+  /**
+   * Each matcher passes ONE operation, within `ttlMs` (default 10 min). With `account`, only an op
+   * whose `account` is that account (an op without one does not pass). `reviewSwapPlan` and
+   * `reviewEarnPlan` always bind.
+   */
+  preApprove(matchers, ttlMs = 10 * 6e4, account) {
     const until = this.now() + ttlMs;
-    this.approved.push(...matchers.map((match) => ({ match, until })));
+    this.approved.push(...matchers.map((match) => ({ match, until, ...account ? { account } : {} })));
   }
   /** 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));
+    const i = this.approved.findIndex((a) => (a.account === void 0 || op.account !== void 0 && sameAccount(a.account, op.account)) && a.match(op));
     if (i < 0) return false;
     this.approved.splice(i, 1);
     return true;
@@ -1788,12 +1903,17 @@ 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 typedDataMatcher(expected) {
+  const hash = lc2(expected.typedDataHash);
+  return (op) => op.kind === "evm-typed-data" && op.caip2 === expected.caip2 && lc2(op.typedDataHash) === hash;
+}
 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
 var import_protocol_swap2_core = require("@anywalletkit/protocol-swap2-core");
+var import_wallet_evm = require("@anywalletkit/wallet-evm");
 async function quoteRoutes(providers, params, options = {}) {
   const timeoutMs = options.timeoutMs ?? 2e4;
   const from = { chain: params.sourceChain, token: params.sourceToken };
@@ -1899,7 +2019,8 @@ function swapApprovalPayload(plan, meta) {
     source = { kind: "serialized" };
     checks.push({ status: "ok", label: "Balance changes are proven before signing (SDK guard)" });
   } else {
-    source = { kind: "typed-order" };
+    const typedData = parseTypedOrder(s.typedData);
+    source = { kind: "typed-order", typedData, text: JSON.stringify(typedData, null, 2) };
     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" });
@@ -1924,6 +2045,11 @@ function swapApprovalPayload(plan, meta) {
     checks
   };
 }
+function parseTypedOrder(json) {
+  const t = JSON.parse(json);
+  if (!t || typeof t !== "object" || !t.domain || typeof t.domain !== "object" || !t.types || typeof t.types !== "object" || !t.message || typeof t.message !== "object") throw new Error("The swap order is not EIP-712 typed data.");
+  return t;
+}
 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;
@@ -1938,16 +2064,18 @@ function planMatchers(plan) {
   } 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);
+    m.push(typedDataMatcher({ caip2: plan.fromChain, typedDataHash: (0, import_wallet_evm.typedDataHash)(parseTypedOrder(s.typedData)) }));
   }
   return m;
 }
 function reviewSwapPlan(approvals, gate, meta) {
+  if (typeof meta.account !== "string" || !meta.account) throw new TypeError("reviewSwapPlan needs meta.account: the gate passes the plan for that account only.");
   return async (plan) => {
+    const matchers = planMatchers(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));
+    gate.preApprove(matchers, Math.max(6e4, plan.validUntilMs - Date.now() + 5 * 6e4), meta.account);
   };
 }
 
@@ -1957,11 +2085,13 @@ var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["pending", "action-required", "re
 function parseSwapId(id) {
   if (!id.startsWith(`${import_protocol_swap2_core2.SWAP2_ID_PREFIX}.`)) return null;
   const parts = id.slice(import_protocol_swap2_core2.SWAP2_ID_PREFIX.length + 1).split(".");
-  if (parts.length < 2 || parts.length > 3 || !parts[0] || !parts[1]) return null;
+  if (parts.length < 2 || parts.length > 4 || !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 };
+  const destTxHash = parts[3] ? decodeURIComponent(parts[3]) : void 0;
+  if (destTxHash && !sourceTxHash) return null;
+  return { provider, intentId, ...sourceTxHash ? { sourceTxHash } : {}, ...destTxHash ? { destTxHash } : {} };
 }
 var SwapsStore = class {
   constructor(storage) {
@@ -1970,9 +2100,14 @@ var SwapsStore = class {
   storage;
   _records = null;
   _listeners = /* @__PURE__ */ new Set();
+  /**
+   * add / update / remove run here one after another, each reading the list inside its turn: an
+   * alarm tick's update that read the list before a new swap was added would otherwise write the
+   * old list back and drop the swap.
+   */
+  _queue = Promise.resolve();
   async list() {
-    this._records ??= await this.storage.get() ?? [];
-    return [...this._records].sort((a, b) => b.createdAt - a.createdAt);
+    return [...await this._all()].sort((a, b) => b.createdAt - a.createdAt);
   }
   async get(id) {
     return (await this.list()).find((r) => r.id === id) ?? null;
@@ -1980,26 +2115,41 @@ var SwapsStore = class {
   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]);
+  add(record) {
+    return this._serial(async () => {
+      const all = (await this._all()).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;
+  update(id, patch) {
+    return this._serial(async () => {
+      const all = [...await this._all()];
+      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));
+  remove(id) {
+    return this._serial(async () => {
+      await this.write((await this._all()).filter((r) => r.id !== id));
+    });
   }
   onChange(listener) {
     this._listeners.add(listener);
     return () => this._listeners.delete(listener);
   }
+  async _all() {
+    this._records ??= await this.storage.get() ?? [];
+    return this._records;
+  }
+  _serial(fn) {
+    const run = this._queue.then(fn, fn);
+    this._queue = run.then(() => void 0, () => void 0);
+    return run;
+  }
   async write(records) {
     await this.storage.set(records);
     this._records = records;
@@ -2074,8 +2224,9 @@ function earnApprovalPayload(plan, meta) {
   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) {
+  if (typeof meta.account !== "string" || !meta.account) throw new TypeError("reviewEarnPlan needs meta.account: the gate passes the plan for that account only.");
   await approvals.request({ origin: meta.origin, chain: meta.network.caip2, kind: "earn", payload: earnApprovalPayload(plan, meta) });
-  gate.preApprove(earnPlanMatchers(meta.network, plan), 10 * 6e4);
+  gate.preApprove(earnPlanMatchers(meta.network, plan), 10 * 6e4, meta.account);
 }
 
 // src/tonconnect.ts
@@ -2236,6 +2387,14 @@ var PhishingDetector = class {
     }
     return { host, blocked: false, warnings };
   }
+  /**
+   * Why `hostOrOrigin` must be refused outright, or `null`: a host on the blocklist (or under a
+   * listed domain) and not on the allowlist. Lookalikes and punycode only warn ({@link check}).
+   * Wire it as `ApprovalQueueOptions.refuse` and `RouterDeps.refuse`.
+   */
+  refusal(hostOrOrigin) {
+    return this.check(hostOrOrigin).blocked ? "This site is on the wallet's phishing list; the wallet refuses its requests." : null;
+  }
   /**
    * `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).