@deeeed/metamask-harness 0.79.0 → 0.81.0

package/adapters/mobile/metro-config.cjs

@@ -1,98 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const { createRequire } = require('node:module');
-const path = require('node:path');
-const { pathToFileURL } = require('node:url');
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function appendBlockList(blockList, pattern) {
-  if (Array.isArray(blockList)) return [...blockList, pattern];
-  return blockList instanceof RegExp ? [blockList, pattern] : [pattern];
-}
-
-function blockListFlags(blockList) {
-  const first = Array.isArray(blockList) ? blockList[0] : blockList;
-  return first instanceof RegExp && first.ignoreCase ? 'i' : '';
-}
-
-function resolveExpoConfigLoader(projectRoot) {
-  const requireFromProject = createRequire(path.join(projectRoot, 'package.json'));
-  let requireUtilsPath;
-  try {
-    requireUtilsPath = requireFromProject.resolve('@expo/require-utils');
-  } catch (error) {
-    if (error?.code !== 'MODULE_NOT_FOUND') throw error;
-    return null;
-  }
-  const { loadModuleSync } = requireFromProject(requireUtilsPath);
-  return typeof loadModuleSync === 'function' ? loadModuleSync : null;
-}
-
-async function loadProductConfig(configPath, baseConfig, projectRoot) {
-  let loaded;
-  const expoConfigLoader = resolveExpoConfigLoader(projectRoot);
-  if (expoConfigLoader) {
-    loaded = expoConfigLoader(configPath);
-  } else {
-    try {
-      loaded = require(configPath);
-    } catch (error) {
-      if (error?.code !== 'ERR_REQUIRE_ESM') throw error;
-      loaded = await import(pathToFileURL(configPath).href);
-    }
-  }
-
-  const moduleValue = await loaded;
-  const exported =
-    moduleValue?.__esModule || moduleValue?.[Symbol.toStringTag] === 'Module'
-      ? moduleValue.default
-      : moduleValue;
-  const config = await exported;
-  return typeof config === 'function' ? config(baseConfig) : config;
-}
-
-module.exports = async function harnessMetroConfig(baseConfig) {
-  const projectRoot = path.resolve(
-    process.env.MM_HARNESS_METRO_PROJECT_ROOT || process.cwd(),
-  );
-  const productConfigPath = path.resolve(
-    process.env.MM_HARNESS_METRO_BASE_CONFIG ||
-      path.join(projectRoot, 'metro.config.js'),
-  );
-  if (productConfigPath === __filename) {
-    throw new Error(
-      'MM_HARNESS_METRO_BASE_CONFIG must reference the product Metro config, not the harness wrapper.',
-    );
-  }
-  let productConfig = baseConfig;
-  if (fs.existsSync(productConfigPath)) {
-    productConfig = await loadProductConfig(
-      productConfigPath,
-      baseConfig,
-      projectRoot,
-    );
-  }
-
-  const tempRoot = path.join(projectRoot, 'temp');
-  const existingBlockList =
-    productConfig.resolver?.blockList ?? baseConfig.resolver?.blockList;
-  const tempPattern = new RegExp(
-    `^${escapeRegExp(tempRoot)}(?:${escapeRegExp(path.sep)}|$)`,
-    blockListFlags(existingBlockList),
-  );
-  // Inline environment values affect transformed JavaScript. Keep separate
-  // cache generations for those inputs instead of deleting the shared cache.
-  const envFingerprint = process.env.MM_HARNESS_METRO_ENV_FINGERPRINT;
-  return {
-    ...productConfig,
-    ...(envFingerprint ? { cacheVersion: `${productConfig.cacheVersion ?? ''}:mm-env:${envFingerprint}` } : {}),
-    resolver: {
-      ...productConfig.resolver,
-      blockList: appendBlockList(existingBlockList, tempPattern),
-    },
-  };
-};

package/adapters/mobile/metro-log-generation.cjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const generationIdPattern = /^[A-Za-z0-9-]+$/u;
-
-function archiveGenerationId(name) {
-  if (!name.startsWith('metro.') || !name.endsWith('.log')) return null;
-  const generationId = name.slice('metro.'.length, -'.log'.length);
-  return generationIdPattern.test(generationId) ? generationId : null;
-}
-
-function positiveInteger(name, fallback) {
-  const raw = process.env[name];
-  if (raw === undefined || raw === '') return fallback;
-  if (!/^[1-9][0-9]*$/u.test(raw)) throw new Error(`${name} must be a positive integer`);
-  return Number(raw);
-}
-
-function main() {
-  const runtimeArg = process.argv[2];
-  const port = process.argv[3];
-  const reason = process.argv[4];
-  if (!runtimeArg || !/^[1-9][0-9]*$/u.test(port ?? '') || !reason) {
-    throw new Error('usage: metro-log-generation.cjs <runtime-dir> <port> <reason>');
-  }
-  const runtimeDir = fs.realpathSync(runtimeArg);
-  const activeLog = path.join(runtimeDir, 'metro.log');
-  const evidenceFile = path.join(runtimeDir, 'metro-generation.json');
-  const maxArchives = positiveInteger('MM_HARNESS_METRO_LOG_ARCHIVE_COUNT', 4);
-  const maxArchiveBytes = positiveInteger('MM_HARNESS_METRO_LOG_ARCHIVE_BYTES', 8 * 1024 * 1024);
-  const generationId = `${new Date().toISOString().replace(/[-:.]/gu, '')}-${port}-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
-  if (!generationIdPattern.test(generationId)) throw new Error('generated Metro log identity is invalid');
-  let rotatedLog = null;
-
-  rotatedLog = path.join(runtimeDir, `metro.${generationId}.log`);
-  try {
-    fs.renameSync(activeLog, rotatedLog);
-    const stat = fs.lstatSync(rotatedLog);
-    if (!stat.isFile()) {
-      fs.renameSync(rotatedLog, activeLog);
-      throw new Error('metro.log must be a regular file');
-    }
-  } catch (error) {
-    if (error && error.code === 'ENOENT') rotatedLog = null;
-    else throw error;
-  }
-  try {
-    fs.closeSync(fs.openSync(activeLog, 'wx', 0o600));
-  } catch (error) {
-    if (error && error.code === 'EEXIST') throw new Error('another Metro generation recreated metro.log; refusing to truncate it');
-    throw error;
-  }
-
-  const archives = fs.readdirSync(runtimeDir)
-    .filter((name) => archiveGenerationId(name) !== null)
-    .map((name) => {
-      const file = path.join(runtimeDir, name);
-      const stat = fs.lstatSync(file);
-      if (!stat.isFile()) return null;
-      return { file, size: stat.size, mtimeMs: stat.mtimeMs };
-    })
-    .filter(Boolean)
-    .sort((left, right) => right.mtimeMs - left.mtimeMs || right.file.localeCompare(left.file));
-
-  let retainedBytes = 0;
-  let retainedCount = 0;
-  const retained = [];
-  const removed = [];
-  for (const archive of archives) {
-    if (retainedCount < maxArchives && retainedBytes + archive.size <= maxArchiveBytes) {
-      retained.push(archive.file);
-      retainedCount += 1;
-      retainedBytes += archive.size;
-      continue;
-    }
-    fs.unlinkSync(archive.file);
-    removed.push({ path: archive.file, size: archive.size, reason: retainedCount >= maxArchives ? 'count-limit' : 'size-limit' });
-  }
-
-  const evidence = {
-    schemaVersion: 1,
-    generationId,
-    port: Number(port),
-    startedAt: new Date().toISOString(),
-    currentLog: activeLog,
-    rotatedLog: rotatedLog && fs.existsSync(rotatedLog) ? rotatedLog : null,
-    archivedLogs: retained,
-    rotationReason: reason,
-    retention: { maxArchives, maxArchiveBytes, retainedBytes, removed },
-  };
-  const temporary = `${evidenceFile}.${process.pid}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify(evidence, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
-  fs.renameSync(temporary, evidenceFile);
-  process.stdout.write(`${JSON.stringify(evidence)}\n`);
-}
-
-try {
-  main();
-} catch (error) {
-  console.error(`metro-log-generation: ${error instanceof Error ? error.message : String(error)}`);
-  process.exit(1);
-}

package/adapters/terminal/lib/origin.mjs

@@ -1,30 +0,0 @@
-// Exact app-origin checks for the terminal slot. A prefix match would let
-// http://localhost:30001 pass for http://localhost:3000, so every check parses
-// the URL and compares origins.
-
-export function originOf(url) {
-  try {
-    return new URL(String(url)).origin;
-  } catch {
-    return null;
-  }
-}
-
-export function isAppUrl(url, appOrigin) {
-  const origin = originOf(url);
-  return origin !== null && origin !== 'null' && origin === originOf(appOrigin);
-}
-
-// A wallet request (or log entry) is accepted only from the default execution
-// context of the tab's top frame, on the app origin, while that frame's
-// committed document is an app URL. The committed URL matters because an
-// about:blank document (a popup the app opened) inherits the app origin. For
-// a page target the main frame id equals the target id.
-export function isAppTopFrameContext(context, { targetId, appOrigin, committedUrl }) {
-  if (!context || !targetId) return false;
-  const aux = context.auxData ?? {};
-  return aux.isDefault === true &&
-    aux.frameId === targetId &&
-    isAppUrl(context.origin, appOrigin) &&
-    isAppUrl(committedUrl, appOrigin);
-}

package/adapters/terminal/lib/page-script.mjs

@@ -1,246 +0,0 @@
-// Source of the script the wallet host evaluates in every app document before
-// page scripts. It reports each wallet request the app makes (method, EIP-712
-// primary type, domain/active chain, outcome; no params or signatures) through
-// a CDP binding, and in injected mode also provides the strict test wallet
-// announced over EIP-6963 as io.metamask. It installs itself only in the top
-// frame of a document on the exact app origin: the CDP preload also runs in
-// iframes and after the tab navigates elsewhere. Errors are logged as a code
-// and a fixed category, never as provider text.
-
-import { mainnetTypedDataReason } from './mainnet-guard.mjs';
-
-export const LOG_BINDING = '__mmTerminalWalletLog';
-export const REQUEST_BINDING = '__mmTerminalWalletRequest';
-export const RESOLVE_FN = '__mmTerminalWalletResolve';
-
-export const LOGGED_METHODS = Object.freeze([
-  'eth_requestAccounts',
-  'wallet_requestPermissions',
-  'wallet_revokePermissions',
-  'wallet_switchEthereumChain',
-  'wallet_addEthereumChain',
-  'eth_signTypedData',
-  'eth_signTypedData_v3',
-  'eth_signTypedData_v4',
-  'personal_sign',
-  'eth_sign',
-  'eth_sendTransaction',
-]);
-
-export const ERROR_CATEGORIES = Object.freeze({
-  4001: 'user-rejected',
-  4100: 'unauthorized',
-  4200: 'unsupported-method',
-  4900: 'disconnected',
-  4901: 'chain-disconnected',
-  4902: 'unrecognized-chain',
-  [-32602]: 'invalid-params',
-  [-32603]: 'internal',
-});
-
-function pageMain(config, mainnetTypedDataReason) {
-  if (window.top !== window || location.origin !== config.appOrigin) return;
-  if (window.__mmTerminalHarness) return;
-  // The wallet host's ready check reads this marker on the committed document:
-  // the preload ran, and the page's provider is wrapped (covers).
-  const wrapped = new WeakSet();
-  const harness = {
-    signer: config.signer,
-    network: config.network,
-    wrapped: 0,
-    wrapFailures: [],
-    covers: (provider) => Boolean(provider) && wrapped.has(provider),
-  };
-  window.__mmTerminalHarness = harness;
-  const logged = new Set(config.loggedMethods);
-  // Without the host's binding a wallet request would go unrecorded, so it is
-  // refused (fail closed) rather than passed through.
-  const unrecorded = () => Object.assign(
-    new Error('The harness wallet host is not attached to this document; the request was refused so it cannot go unrecorded.'),
-    { code: 4100 },
-  );
-  const hasBinding = (binding) => typeof window[binding] === 'function';
-  const report = (entry) => {
-    try {
-      window[config.logBinding](JSON.stringify(entry));
-    } catch {
-      // Binding unavailable (host detached): the request still proceeds.
-    }
-  };
-  const describe = (method, params) => {
-    const entry = { kind: 'request', method, t: Date.now(), url: location.pathname };
-    if (/^eth_signTypedData/.test(method)) {
-      try {
-        const raw = params?.[1];
-        const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
-        entry.primaryType = data?.primaryType ?? null;
-        entry.domainName = data?.domain?.name ?? null;
-        entry.domainChainId = data?.domain?.chainId == null ? null : Number(BigInt(data.domain.chainId));
-      } catch {
-        entry.primaryType = null;
-      }
-    }
-    if (method === 'wallet_switchEthereumChain' || method === 'wallet_addEthereumChain') {
-      try {
-        entry.toChainId = Number.parseInt(params[0].chainId, 16);
-      } catch {
-        entry.toChainId = null;
-      }
-    }
-    return entry;
-  };
-  const wrap = (provider, source) => {
-    if (!provider || typeof provider.request !== 'function' || wrapped.has(provider)) return provider;
-    const original = provider.request.bind(provider);
-    const request = async (args) => {
-      const method = args?.method;
-      if (!logged.has(method)) return original(args);
-      if (!hasBinding(config.logBinding)) throw unrecorded();
-      const entry = { ...describe(method, args?.params), source };
-      // Testnet runs never let a mainnet Hyperliquid action reach the signer.
-      if (config.network === 'testnet' && /^eth_signTypedData/.test(method)) {
-        let reason = null;
-        try {
-          const raw = args?.params?.[1];
-          reason = mainnetTypedDataReason(typeof raw === 'string' ? JSON.parse(raw) : raw);
-        } catch {
-          reason = null;
-        }
-        if (reason) {
-          report({ ...entry, kind: 'refused-mainnet', reason, outcome: 'refused', errorCode: 4100 });
-          throw Object.assign(new Error('Refused: this test run is held to Hyperliquid testnet and the request signs a mainnet action.'), { code: 4100 });
-        }
-      }
-      try {
-        entry.activeChainId = Number.parseInt(await original({ method: 'eth_chainId' }), 16);
-      } catch {
-        entry.activeChainId = null;
-      }
-      const started = Date.now();
-      try {
-        const result = await original(args);
-        entry.outcome = /sign/i.test(method) ? 'signed' : 'approved';
-        entry.durationMs = Date.now() - started;
-        report(entry);
-        return result;
-      } catch (error) {
-        const code = Number.isInteger(error?.code) ? error.code : null;
-        entry.outcome = code === 4001 ? 'rejected' : 'error';
-        entry.errorCode = code;
-        entry.errorCategory = config.errorCategories[code] ?? 'other';
-        entry.durationMs = Date.now() - started;
-        report(entry);
-        throw error;
-      }
-    };
-    try {
-      provider.request = request;
-    } catch {
-      // Read-only property: define it instead (below).
-    }
-    if (provider.request !== request) {
-      try {
-        Object.defineProperty(provider, 'request', { value: request, configurable: true, writable: true });
-      } catch {
-        // Frozen provider: recorded below.
-      }
-    }
-    // A provider whose request could not be replaced would sign unrecorded.
-    if (provider.request !== request) {
-      harness.wrapFailures.push(source);
-      return provider;
-    }
-    wrapped.add(provider);
-    harness.wrapped += 1;
-    return provider;
-  };
-
-  if (config.signer === 'injected') {
-    const listeners = {};
-    const emit = (event, ...args) => (listeners[event] ?? []).forEach((fn) => {
-      try { fn(...args); } catch { /* listener errors stay in the app */ }
-    });
-    const pending = new Map();
-    let nextId = 1;
-    window[config.resolveFn] = (id, outcome) => {
-      const entry = pending.get(id);
-      if (!entry) return;
-      pending.delete(id);
-      if (outcome.error) entry.reject(Object.assign(new Error(outcome.error.message), { code: outcome.error.code }));
-      else entry.resolve(outcome.result);
-    };
-    let lastChain = null;
-    const provider = {
-      isMetaMask: true,
-      _metamask: { isUnlocked: async () => true },
-      request: ({ method, params }) => new Promise((resolve, reject) => {
-        if (!hasBinding(config.requestBinding)) {
-          reject(unrecorded());
-          return;
-        }
-        const id = nextId++;
-        pending.set(id, { resolve, reject });
-        window[config.requestBinding](JSON.stringify({ id, method, params }));
-      }).then((result) => {
-        if (method === 'wallet_switchEthereumChain' && params?.[0]?.chainId !== lastChain) {
-          lastChain = params[0].chainId;
-          emit('chainChanged', lastChain);
-        }
-        if (method === 'eth_chainId') lastChain = result;
-        if (method === 'eth_requestAccounts') emit('connect', { chainId: lastChain ?? '0x1' });
-        return result;
-      }),
-      on: (event, fn) => { (listeners[event] ??= []).push(fn); return provider; },
-      removeListener: (event, fn) => { listeners[event] = (listeners[event] ?? []).filter((f) => f !== fn); return provider; },
-      enable: () => provider.request({ method: 'eth_requestAccounts' }),
-    };
-    wrap(provider, 'injected-strict-wallet');
-    window.ethereum = provider;
-    const info = {
-      uuid: '5d1e5b4e-e2e0-4c3f-9a1d-000000000001',
-      name: 'MetaMask (strict test wallet)',
-      icon: "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>",
-      rdns: 'io.metamask',
-    };
-    const announce = () => window.dispatchEvent(new CustomEvent('eip6963:announceProvider', { detail: Object.freeze({ info, provider }) }));
-    window.addEventListener('eip6963:requestProvider', announce);
-    announce();
-    return;
-  }
-
-  // Extension mode: wrap whatever provider MetaMask injects, however the app
-  // reaches it (window.ethereum or an EIP-6963 announcement).
-  let current = window.ethereum ? wrap(window.ethereum, 'window.ethereum') : undefined;
-  try {
-    Object.defineProperty(window, 'ethereum', {
-      configurable: true,
-      get: () => current,
-      set: (value) => { current = wrap(value, 'window.ethereum'); },
-    });
-  } catch {
-    // A non-configurable window.ethereum is still wrapped by the poll below.
-  }
-  window.addEventListener('eip6963:announceProvider', (event) => {
-    wrap(event.detail?.provider, `eip6963:${event.detail?.info?.rdns ?? 'unknown'}`);
-  }, true);
-  let polls = 0;
-  const poll = setInterval(() => {
-    if (window.ethereum) wrap(window.ethereum, 'window.ethereum');
-    if (++polls > 200) clearInterval(poll);
-  }, 50);
-}
-
-export function pageScriptSource({ signer, appOrigin, network = 'testnet' }) {
-  const origin = new URL(appOrigin).origin;
-  const config = {
-    signer,
-    network,
-    appOrigin: origin,
-    errorCategories: ERROR_CATEGORIES,
-    loggedMethods: LOGGED_METHODS,
-    logBinding: LOG_BINDING,
-    requestBinding: REQUEST_BINDING,
-    resolveFn: RESOLVE_FN,
-  };
-  return `(${pageMain.toString()})(${JSON.stringify(config)}, ${mainnetTypedDataReason.toString()});`;
-}

package/adapters/terminal/lib/strict-wallet.mjs

@@ -1,138 +0,0 @@
-// EIP-1193 test wallet that enforces MetaMask's typed-data rule: reject
-// eth_signTypedData_v4 whose domain chainId differs from the active chain.
-// Signs with a viem account held by the wallet host; never exposes key
-// material. Ported from the TAT-4032 migration e2e strict wallet.
-
-export const DEFAULT_KNOWN_CHAINS = Object.freeze([1, 10, 137, 8453, 42161, 421614, 59144, 59141, 11155111]);
-
-const READ_RPC = {
-  1: 'https://ethereum-rpc.publicnode.com',
-  42161: 'https://arbitrum-one-rpc.publicnode.com',
-  421614: 'https://arbitrum-sepolia-rpc.publicnode.com',
-  59144: 'https://linea-rpc.publicnode.com',
-};
-
-// Only these reads go to the public RPC. Anything else the wallet does not
-// answer itself (eth_sendRawTransaction, account or filter methods, unknown
-// wallet_* calls) is refused before any network request.
-export const READ_ONLY_RPC_METHODS = Object.freeze([
-  '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',
-  'web3_clientVersion',
-]);
-const READ_ONLY = new Set(READ_ONLY_RPC_METHODS);
-
-function rpcError(message, code) {
-  return Object.assign(new Error(message), { code });
-}
-
-function toBigIntDeep(types, primaryType, message) {
-  const out = {};
-  for (const field of types[primaryType] ?? []) {
-    const value = message[field.name];
-    if (value === undefined) continue;
-    if (/^u?int\d*$/u.test(field.type)) out[field.name] = BigInt(value);
-    else if (types[field.type]) out[field.name] = toBigIntDeep(types, field.type, value);
-    else out[field.name] = value;
-  }
-  return out;
-}
-
-export function createStrictWallet({
-  account,
-  chainId = 42161,
-  knownChains = DEFAULT_KNOWN_CHAINS,
-  refuseSwitch = false,
-  fetchImpl = globalThis.fetch,
-}) {
-  let activeChain = chainId;
-  const known = new Set(knownChains);
-  let rpcId = 1;
-
-  async function request({ method, params = [] }) {
-    switch (method) {
-      case 'eth_chainId':
-        return `0x${activeChain.toString(16)}`;
-      case 'net_version':
-        return String(activeChain);
-      case 'eth_accounts':
-      case 'eth_requestAccounts':
-        return [account.address];
-      case 'wallet_requestPermissions':
-      case 'wallet_getPermissions':
-        return [{ parentCapability: 'eth_accounts', caveats: [{ type: 'restrictReturnedAccounts', value: [account.address.toLowerCase()] }] }];
-      case 'wallet_revokePermissions':
-        return null;
-      case 'metamask_getProviderState':
-        return { accounts: [account.address.toLowerCase()], chainId: `0x${activeChain.toString(16)}`, isUnlocked: true, networkVersion: String(activeChain) };
-      case 'wallet_switchEthereumChain': {
-        const id = Number.parseInt(params[0].chainId, 16);
-        if (refuseSwitch) throw rpcError('User rejected the request.', 4001);
-        if (!known.has(id)) throw rpcError(`Unrecognized chain ID ${params[0].chainId}`, 4902);
-        activeChain = id;
-        return null;
-      }
-      case 'wallet_addEthereumChain':
-        known.add(Number.parseInt(params[0].chainId, 16));
-        return null;
-      case 'eth_signTypedData_v4': {
-        const [from, raw] = params;
-        const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
-        const domainChain = Number(BigInt(data.domain.chainId));
-        if (String(from).toLowerCase() !== account.address.toLowerCase()) throw rpcError('Unknown account', 4100);
-        if (domainChain !== activeChain) {
-          throw rpcError(`Provided chainId "${domainChain}" must match the active chainId "${activeChain}"`, -32602);
-        }
-        const types = { ...data.types };
-        delete types.EIP712Domain;
-        return account.signTypedData({
-          domain: { ...data.domain, chainId: domainChain },
-          types,
-          primaryType: data.primaryType,
-          message: toBigIntDeep(types, data.primaryType, data.message),
-        });
-      }
-      case 'personal_sign': {
-        const [message, from] = params;
-        if (String(from).toLowerCase() !== account.address.toLowerCase()) throw rpcError('Unknown account', 4100);
-        return account.signMessage({ message: { raw: message } });
-      }
-      case 'eth_sendTransaction':
-      case 'eth_sign':
-        throw rpcError(`${method} is not supported by the strict test wallet`, 4200);
-      default: {
-        if (!READ_ONLY.has(method)) throw rpcError(`${method} is not supported by the strict test wallet`, 4200);
-        const url = READ_RPC[activeChain];
-        if (!url) throw rpcError(`No read RPC for chain ${activeChain}`, 4200);
-        const response = await fetchImpl(url, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ jsonrpc: '2.0', id: rpcId++, method, params }),
-        });
-        const body = await response.json();
-        if (body.error) throw rpcError(body.error.message, body.error.code);
-        return body.result;
-      }
-    }
-  }
-
-  return {
-    request,
-    get chainId() {
-      return activeChain;
-    },
-  };
-}