@anywalletkit/extension-kit 0.2.2 → 0.3.1

package/README.md

@@ -36,7 +36,7 @@ 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, `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 |
+| Relay | `PageRequest` / `RelayRequest` shapes and guards, `isRelayMethod`, `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 |
@@ -68,6 +68,12 @@ pnpm add @anywalletkit/extension-kit @anywalletkit/core @anywalletkit/keyring
   `create` never overwrites; reset is an explicit `destroy()`.
 - **Passkeys.** A passkey wraps the same DEK under HKDF-SHA256(PRF output,
   salt = credential id); the password stays the recovery path.
+- **Re-keying.** `changePassword` re-wraps the same DEK, and `removePasskey`
+  does not take back a DEK the passkey already unwrapped. After a suspected
+  compromise, `rotateVaultKey(password)` makes a fresh DEK, re-seals every
+  secret, drops the passkeys (register them again) and writes one envelope;
+  hand the returned DEK to `session.unlock`, which replaces the old one.
+  `setSecret` refuses a DEK that does not open the vault's secrets.
 - **Unlocked state.** Only the DEK is kept, in `chrome.storage.session`
   (memory-only, trusted contexts), with an expiry enforced on every read and an
   alarm that locks; key buffers this package owns are zeroized after use.

package/dist/index.cjs

@@ -44,6 +44,7 @@ __export(src_exports, {
   QueueLimitError: () => QueueLimitError,
   READ_METHODS: () => READ_METHODS,
   RELAY_ERRORS: () => RELAY_ERRORS,
+  RELAY_METHOD_MAX: () => RELAY_METHOD_MAX,
   RecipientBook: () => RecipientBook,
   RequestRouter: () => RequestRouter,
   ReviewDeclined: () => ReviewDeclined,
@@ -103,6 +104,7 @@ __export(src_exports, {
   isPageEvent: () => isPageEvent,
   isPageRequest: () => isPageRequest,
   isPageResponse: () => isPageResponse,
+  isRelayMethod: () => isRelayMethod,
   isRelayRequest: () => isRelayRequest,
   isRelayToContent: () => isRelayToContent,
   levenshtein: () => levenshtein,
@@ -293,7 +295,12 @@ var Vault = class {
     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. */
+  /**
+   * Re-wrap the DEK under a new password (fresh salt, current KDF). Secrets and passkeys are untouched —
+   * and so is the DEK: after a suspected compromise (a copied profile, a leaked session, a lost passkey)
+   * this is not enough, because whoever holds the DEK still opens every secret, old and new. Use
+   * {@link Vault.rotateVaultKey} then.
+   */
   async changePassword(oldPassword, newPassword) {
     requirePassword(newPassword, VAULT_MIN_PASSWORD_LENGTH);
     requirePassword(oldPassword);
@@ -309,6 +316,45 @@ var Vault = class {
       }
     });
   }
+  /**
+   * Replace the DEK (scan 2026-10-27 modules, F30): a fresh random DEK, every secret re-sealed under it,
+   * the DEK wrapped under `password` with a fresh salt — written as one envelope, so a failure leaves the
+   * old vault as it was. Returns the new DEK: hand it to `session.unlock(dek)`, which overwrites the old
+   * one in `chrome.storage.session`. A DEK copied before the rotation opens nothing in the new envelope,
+   * and {@link Vault.setSecret} refuses it, so a stale session cannot seal new secrets under it.
+   *
+   * Passkeys are dropped — their boxes hold the old DEK and cannot be re-wrapped without their PRF
+   * output — and must be registered again ({@link Vault.addPasskey} with the new DEK).
+   */
+  async rotateVaultKey(password) {
+    requirePassword(password);
+    return this._exclusive(async () => {
+      const oldDek = await this._unlock(password);
+      const dek = this._random(DEK_BYTES);
+      try {
+        const envelope = await this._load();
+        const [oldKey, newKey] = await Promise.all([this._importDek(oldDek), this._importDek(dek)]);
+        const secrets = {};
+        for (const [id, box] of Object.entries(envelope.secrets)) {
+          const plaintext = await this._open(oldKey, box, aadSecret(id), "locked");
+          try {
+            secrets[id] = await this._seal(newKey, plaintext, aadSecret(id));
+          } finally {
+            (0, import_core.zeroize)(plaintext);
+          }
+        }
+        const next = await this._sealEnvelope(password, dek, secrets, [], envelope.createdAt);
+        const upgradedAt = isEnvelopeV2(envelope) ? envelope.upgradedAt : void 0;
+        await this._write(isEnvelopeV2(next) ? { ...next, ...upgradedAt !== void 0 ? { upgradedAt } : {}, rotatedAt: Date.now() } : next);
+        return dek;
+      } catch (e) {
+        (0, import_core.zeroize)(dek);
+        throw e;
+      } finally {
+        (0, import_core.zeroize)(oldDek);
+      }
+    });
+  }
   // ---- passkeys (v2) ----
   /** Public view of the registered passkeys (ids, labels; whether each can verify assertions). */
   async listPasskeys() {
@@ -366,6 +412,7 @@ var Vault = class {
       (0, import_core.zeroize)(prf);
     }
   }
+  /** Forget one passkey's box. A DEK that passkey already unwrapped stays valid: after a lost or compromised passkey, {@link Vault.rotateVaultKey}. */
   async removePasskey(id) {
     requireId(id);
     return this._exclusive(async () => {
@@ -379,13 +426,17 @@ var Vault = class {
     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). */
+  /**
+   * Seal `secret` under the DEK as `sourceId` (overwrites an entry with the same id). The DEK must open the
+   * vault's secrets (`locked` otherwise): a key retired by {@link Vault.rotateVaultKey} never seals a new one.
+   */
   async setSecret(dek, sourceId, secret) {
     requireId(sourceId);
     if (secret.length > VAULT_LIMITS.secretBytes) throw new VaultError(`A secret is at most ${VAULT_LIMITS.secretBytes} bytes.`, "invalid-input");
     const key = await this._importDek(dek);
     return this._exclusive(async () => {
       const envelope = await this._load();
+      if (Object.keys(envelope.secrets).length > 0) await this._requireDek(dek, envelope);
       if (!(sourceId in envelope.secrets) && Object.keys(envelope.secrets).length >= VAULT_LIMITS.secrets) {
         throw new VaultError(`A vault holds at most ${VAULT_LIMITS.secrets} secrets.`, "invalid-input");
       }
@@ -769,8 +820,10 @@ var RELAY_ERRORS = {
 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;
+var RELAY_METHOD_MAX = 128;
+var isRelayMethod = (x) => typeof x === "string" && x.length > 0 && x.length <= RELAY_METHOD_MAX && /^[A-Za-z0-9_]+$/.test(x);
 function isPageRequest(x) {
-  return isRecord(x) && x.target === PAGE_TARGET.toContent && isId(x.id) && CHAINS.has(x.chain) && typeof x.method === "string";
+  return isRecord(x) && x.target === PAGE_TARGET.toContent && isId(x.id) && CHAINS.has(x.chain) && isRelayMethod(x.method);
 }
 function isPageResponse(x) {
   return isRecord(x) && x.target === PAGE_TARGET.toPage && isId(x.id);
@@ -779,7 +832,7 @@ 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";
+  return isRecord(x) && x.kind === "request" && isId(x.id) && typeof x.origin === "string" && CHAINS.has(x.chain) && isRelayMethod(x.method);
 }
 function isRelayToContent(x) {
   return isRecord(x) && (x.kind === "response" && isId(x.id) || x.kind === "event" && typeof x.event === "string");
@@ -906,6 +959,7 @@ function vaultSecretStorage(vault, session) {
 }
 
 // src/networks.ts
+var import_url = require("@anywalletkit/networks/url");
 var import_swap2_assets = require("@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 };
@@ -1019,26 +1073,14 @@ 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;
-}
+var isSiteRpcUrl = (u) => typeof u === "string" && u.length <= 2048 && (0, import_url.isPublicHttpsUrl)(u);
 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) && !isPrivateRpcHost(u)) : [];
+  const rpcs = Array.isArray(p.rpcUrls) ? p.rpcUrls.filter(isSiteRpcUrl) : [];
   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;
@@ -1399,8 +1441,9 @@ var RouterError = class _RouterError extends Error {
 };
 var PROVIDER_CODES = /* @__PURE__ */ new Set([4001, 4100, 4200, 4900, 4901, 4902]);
 var isNodeCode = (code) => typeof code === "number" && Number.isInteger(code) && (code === 3 || code >= -32768 && code <= -32e3);
-var URL_RE = /\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>()]+/gi;
-var pageText = (text) => text.replace(URL_RE, "[url]").split("\n")[0].slice(0, 300);
+var URL_RE = /[a-z][a-z0-9+.-]{0,31}:\/\/[^\s"'<>()]+/gi;
+var PAGE_TEXT_WINDOW = 1024;
+var pageText = (text) => text.slice(0, PAGE_TEXT_WINDOW).split("\n", 1)[0].replace(URL_RE, "[url]").slice(0, 300);
 var isHexData = (v) => typeof v === "string" && /^0x[0-9a-fA-F]*$/.test(v) && v.length <= 2 + 2 * 8192;
 function nodeError(e) {
   for (let cur = e, depth = 0; cur && typeof cur === "object" && depth < 8; cur = cur.cause, depth++) {
@@ -1459,6 +1502,7 @@ var RequestRouter = class {
   async handle(origin, chain, method, rawParams) {
     const refused = this.deps.refuse?.(origin);
     if (refused) throw new RouterError(RELAY_ERRORS.unauthorized, refused);
+    if (!isRelayMethod(method)) throw new RouterError(RELAY_ERRORS.invalidRequest, "The request has no valid method name.");
     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);