@deeeed/metamask-harness 0.80.0 → 0.81.0

package/library/actions/terminal/wallet/_signature-log.mjs

@@ -1,177 +1,56 @@
-// Read, window and assert the terminal wallet request log the wallet host
-// writes: one JSON line per request the app sent to the main wallet (method,
-// EIP-712 primary type, domain/active chain, outcome) and, in extension mode,
-// one line per confirmation window MetaMask opened. Never holds params,
-// messages or signatures.
+// The Terminal's wallet request log: where the wallet host writes it, and what
+// the Terminal forbids in it. Reading, windowing and asserting the log are
+// @farmslot/adapter-web/dapp's; the Hyperliquid rules are passed in as policy:
+//   - an L1 (agent-signed, Agent / chainId 1337) payload must never reach the
+//     main wallet (max_l1_requests, default 0);
+//   - a blocked mainnet venue request or a refused mainnet signature fails the
+//     assertion (testnet enforcement).
 
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
+import { shortPrimaryType } from '@farmslot/adapter-web/dapp';
 
 import { terminalRuntimePath } from '../platform/runtime.mjs';
 
 export const L1_PRIMARY_TYPE = 'Agent';
 export const L1_CHAIN_ID = 1337;
 
-export function signatureLogPath(projectRoot) {
-  return terminalRuntimePath(projectRoot, 'wallet-requests.jsonl');
-}
-
-export function signatureCursorPath(projectRoot) {
-  return terminalRuntimePath(projectRoot, 'wallet-requests.cursor.json');
-}
-
-export function parseLog(text) {
-  return text
-    .split('\n')
-    .filter((line) => line.trim())
-    .map((line, index) => {
-      try {
-        return { seq: index, ...JSON.parse(line) };
-      } catch {
-        return { seq: index, kind: 'unparseable' };
-      }
-    });
-}
-
-export async function readLog(projectRoot) {
-  try {
-    return parseLog(await readFile(signatureLogPath(projectRoot), 'utf8'));
-  } catch (error) {
-    if (error?.code === 'ENOENT') return [];
-    throw error;
-  }
-}
-
-export async function readCursor(projectRoot) {
-  try {
-    const cursor = JSON.parse(await readFile(signatureCursorPath(projectRoot), 'utf8'));
-    return Number.isInteger(cursor.seq) ? cursor.seq : 0;
-  } catch (error) {
-    if (error?.code === 'ENOENT') return 0;
-    throw error;
-  }
-}
-
-export async function writeCursor(projectRoot, seq) {
-  await writeFile(signatureCursorPath(projectRoot), `${JSON.stringify({ seq, at: new Date().toISOString() })}\n`, { mode: 0o600 });
-}
-
-// "HyperliquidTransaction:ApproveAgent" → "ApproveAgent".
-export function shortPrimaryType(primaryType) {
-  if (primaryType == null) return null;
-  const raw = String(primaryType);
-  return raw.includes(':') ? raw.slice(raw.lastIndexOf(':') + 1) : raw;
-}
-
-export function isTypedDataRequest(entry) {
-  return entry.kind === 'request' && /^eth_signTypedData/u.test(String(entry.method));
+export function signatureLog(projectRoot) {
+  return {
+    logFile: terminalRuntimePath(projectRoot, 'wallet-requests.jsonl'),
+    cursorFile: terminalRuntimePath(projectRoot, 'wallet-requests.cursor.json'),
+  };
 }
 
 export function isL1Request(entry) {
-  return isTypedDataRequest(entry) &&
+  return entry.kind === 'request' && /^eth_signTypedData/u.test(String(entry.method)) &&
     (shortPrimaryType(entry.primaryType) === L1_PRIMARY_TYPE || Number(entry.domainChainId) === L1_CHAIN_ID);
 }
 
-export function summarize(entries) {
-  const requests = entries.filter((entry) => entry.kind === 'request');
-  const typed = requests.filter(isTypedDataRequest);
-  const byPrimaryType = {};
-  for (const entry of typed) {
-    const key = shortPrimaryType(entry.primaryType) ?? '<none>';
-    byPrimaryType[key] ??= { requested: 0, signed: 0, rejected: 0, chainIds: [] };
-    byPrimaryType[key].requested += 1;
-    if (entry.outcome === 'signed') byPrimaryType[key].signed += 1;
-    if (entry.outcome === 'rejected' || entry.outcome === 'error') byPrimaryType[key].rejected += 1;
-    if (!byPrimaryType[key].chainIds.includes(entry.domainChainId)) byPrimaryType[key].chainIds.push(entry.domainChainId);
-  }
-  const byMethod = {};
-  for (const entry of requests) byMethod[entry.method] = (byMethod[entry.method] ?? 0) + 1;
+export const TERMINAL_SIGNATURE_POLICY = Object.freeze({
+  typedDataClasses: {
+    l1Requests: {
+      match: isL1Request,
+      param: 'max_l1_requests',
+      defaultMax: 0,
+      failure: (count, max) => `L1 requests reached the main wallet: ${count} > ${max}`,
+    },
+  },
+  forbiddenEntries: {
+    blockedMainnet: {
+      match: (entry) => entry.kind === 'blocked-mainnet' && !entry.probe,
+      failure: (count) => `the browser tried to reach a mainnet venue ${count} time(s) (blocked-mainnet)`,
+    },
+    refusedMainnet: {
+      match: (entry) => entry.kind === 'refused-mainnet',
+      failure: (count) => `the app asked the wallet to sign ${count} mainnet action(s) (refused-mainnet)`,
+    },
+  },
+});
+
+// Evidence goes to <artifacts>/terminal-wallet/<node>-signature-log.json.
+export function logArtifactTarget(input) {
   return {
-    requests: requests.length,
-    typedDataRequests: typed.length,
-    l1Requests: typed.filter(isL1Request).length,
-    confirmationsShown: entries.filter((entry) => entry.kind === 'confirmation-shown').length,
-    // Testnet enforcement and evidence gaps: each one fails the assertion.
-    blockedMainnet: entries.filter((entry) => entry.kind === 'blocked-mainnet' && !entry.probe).length,
-    refusedMainnet: entries.filter((entry) => entry.kind === 'refused-mainnet').length,
-    unattributed: entries.filter((entry) => entry.kind === 'unattributed').length,
-    // Calls from an iframe, a foreign page or a blank document: refused, kept as evidence.
-    outsideAppFrame: entries.filter((entry) => entry.kind === 'outside-app-frame').length,
-    byPrimaryType,
-    byMethod,
+    artifactsDir: input.context?.artifactsDir,
+    nodeId: input.context?.nodeId ?? input.action,
+    folder: 'terminal-wallet',
   };
 }
-
-function exact(label, actual, expected, failures) {
-  if (actual !== expected) failures.push(`${label}: expected ${expected}, got ${actual}`);
-}
-
-// Every expectation is optional; max_l1_requests defaults to 0 because an L1
-// (agent-signed) payload must never reach the main wallet.
-export function evaluateSignatureLog(entries, node = {}) {
-  const summary = summarize(entries);
-  const typed = entries.filter(isTypedDataRequest);
-  const failures = [];
-  if (summary.blockedMainnet > 0) failures.push(`the browser tried to reach a mainnet venue ${summary.blockedMainnet} time(s) (blocked-mainnet)`);
-  if (summary.refusedMainnet > 0) failures.push(`the app asked the wallet to sign ${summary.refusedMainnet} mainnet action(s) (refused-mainnet)`);
-  if (summary.unattributed > 0) failures.push(`${summary.unattributed} wallet log entr(y/ies) could not be attributed to the app's top frame (unattributed)`);
-  const maxL1 = node.max_l1_requests == null ? 0 : Number(node.max_l1_requests);
-  if (summary.l1Requests > maxL1) {
-    failures.push(`L1 requests reached the main wallet: ${summary.l1Requests} > ${maxL1}`);
-  }
-  if (Array.isArray(node.allowed_primary_types)) {
-    const allowed = new Set(node.allowed_primary_types.map(shortPrimaryType));
-    for (const entry of typed) {
-      const type = shortPrimaryType(entry.primaryType);
-      if (!allowed.has(type)) failures.push(`primary type ${type} (seq ${entry.seq}) is not allowed`);
-    }
-  }
-  if (node.counts && typeof node.counts === 'object') {
-    for (const [type, expected] of Object.entries(node.counts)) {
-      exact(`signed ${shortPrimaryType(type)}`, summary.byPrimaryType[shortPrimaryType(type)]?.signed ?? 0, Number(expected), failures);
-    }
-  }
-  if (node.request_counts && typeof node.request_counts === 'object') {
-    for (const [type, expected] of Object.entries(node.request_counts)) {
-      exact(`requested ${shortPrimaryType(type)}`, summary.byPrimaryType[shortPrimaryType(type)]?.requested ?? 0, Number(expected), failures);
-    }
-  }
-  if (node.methods && typeof node.methods === 'object') {
-    for (const [method, expected] of Object.entries(node.methods)) {
-      exact(`method ${method}`, summary.byMethod[method] ?? 0, Number(expected), failures);
-    }
-  }
-  if (node.max_typed_data_requests != null && summary.typedDataRequests > Number(node.max_typed_data_requests)) {
-    failures.push(`typed-data requests ${summary.typedDataRequests} > ${node.max_typed_data_requests}`);
-  }
-  if (node.expect_confirmations != null) {
-    exact('confirmations shown', summary.confirmationsShown, Number(node.expect_confirmations), failures);
-  }
-  if (node.require_active_chain === true) {
-    for (const entry of typed.filter((item) => item.outcome === 'signed')) {
-      if (Number(entry.domainChainId) !== Number(entry.activeChainId)) {
-        failures.push(`seq ${entry.seq} ${shortPrimaryType(entry.primaryType)} signed with domain chainId ${entry.domainChainId} while the wallet was on ${entry.activeChainId}`);
-      }
-    }
-  }
-  if (node.max_rejected != null) {
-    const rejected = typed.filter((entry) => entry.outcome === 'rejected' || entry.outcome === 'error').length;
-    if (rejected > Number(node.max_rejected)) failures.push(`rejected typed-data requests ${rejected} > ${node.max_rejected}`);
-  }
-  return { ok: failures.length === 0, failures, summary };
-}
-
-export async function windowSinceCursor(projectRoot) {
-  const [entries, cursor] = await Promise.all([readLog(projectRoot), readCursor(projectRoot)]);
-  return { cursor, entries: entries.filter((entry) => entry.seq >= cursor), total: entries.length };
-}
-
-export async function writeLogArtifact(input, payload) {
-  const artifactsDir = input.context?.artifactsDir;
-  if (!artifactsDir) return [];
-  const nodeId = String(input.context?.nodeId ?? input.action).replaceAll('/', '__');
-  const relative = `terminal-wallet/${nodeId}-signature-log.json`;
-  await mkdir(path.join(artifactsDir, 'terminal-wallet'), { recursive: true });
-  await writeFile(path.join(artifactsDir, relative), `${JSON.stringify(payload, null, 2)}\n`);
-  return [{ path: relative, type: 'report', nodeId: String(input.context?.nodeId ?? input.action) }];
-}

package/library/actions/terminal/wallet/assert_signatures.mjs

@@ -3,22 +3,16 @@
 // payloads, active-chain matching and, in extension mode, confirmations shown.
 // The full window is retained as evidence whether or not the assertion holds.
 
+import { awaitSignatureLog, writeLogArtifact } from '@farmslot/adapter-web/dapp';
+
 import { isDirectRun, runAdapter } from '../platform/runtime.mjs';
-import { evaluateSignatureLog, windowSinceCursor, writeLogArtifact } from './_signature-log.mjs';
+import { TERMINAL_SIGNATURE_POLICY, logArtifactTarget, signatureLog } from './_signature-log.mjs';
 
 export async function assertSignatures(input) {
   const node = input.node ?? {};
-  const projectRoot = input.context?.projectRoot;
-  const deadline = Date.now() + Math.max(0, Number(node.timeout_ms ?? 0));
-  let window = await windowSinceCursor(projectRoot);
-  let result = evaluateSignatureLog(window.entries, node);
-  // Entries arrive asynchronously from the wallet host; allow a short settle.
-  while (!result.ok && Date.now() < deadline) {
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    window = await windowSinceCursor(projectRoot);
-    result = evaluateSignatureLog(window.entries, node);
-  }
-  const artifacts = await writeLogArtifact(input, {
+  // Entries arrive asynchronously from the wallet host; timeout_ms allows a short settle.
+  const { window, result } = await awaitSignatureLog(signatureLog(input.context?.projectRoot), node, TERMINAL_SIGNATURE_POLICY);
+  const artifacts = await writeLogArtifact(logArtifactTarget(input), {
     cursor: window.cursor,
     total: window.total,
     expectations: node,

package/library/actions/terminal/wallet/read_signatures.mjs

@@ -2,26 +2,27 @@
 // evidence. reset=true moves the window start to the end of the log so the next
 // read covers only what follows (an explicit setup step, recorded in the trace).
 
+import { resetWindow, summarize, windowSinceCursor, writeLogArtifact } from '@farmslot/adapter-web/dapp';
+
 import { isDirectRun, runAdapter } from '../platform/runtime.mjs';
-import { readLog, summarize, windowSinceCursor, writeCursor, writeLogArtifact } from './_signature-log.mjs';
+import { TERMINAL_SIGNATURE_POLICY, logArtifactTarget, signatureLog } from './_signature-log.mjs';
 
 export async function readSignatures(input) {
-  const projectRoot = input.context?.projectRoot;
+  const log = signatureLog(input.context?.projectRoot);
   if (input.node?.reset === true) {
-    const entries = await readLog(projectRoot);
-    await writeCursor(projectRoot, entries.length);
+    const { cursor, previousEntries } = await resetWindow(log);
     return {
       action: input.action,
       source: 'terminal-wallet-request-log',
       reset: true,
-      cursor: entries.length,
-      previousEntries: entries.length,
+      cursor,
+      previousEntries,
       proofPath: 'terminal-wallet-request-log',
     };
   }
-  const { cursor, entries, total } = await windowSinceCursor(projectRoot);
-  const summary = summarize(entries);
-  const artifacts = await writeLogArtifact(input, { cursor, total, summary, entries });
+  const { cursor, entries, total } = await windowSinceCursor(log);
+  const summary = summarize(entries, TERMINAL_SIGNATURE_POLICY);
+  const artifacts = await writeLogArtifact(logArtifactTarget(input), { cursor, total, summary, entries });
   return {
     action: input.action,
     source: 'terminal-wallet-request-log',

package/library/manifests/core.action-manifest.json

@@ -819,7 +819,7 @@
       "execution_capabilities": []
     },
     "metamask.perps.quote_fees": {
-      "description": "core Quote an order's fees through the perps controller's calculateFees (HyperLiquid, testnet by default, read-only): protocol and MetaMask fee rates and amounts (plus the winning fee source on a core that reports it), with an optional rewards discount supplied as RewardsController:getPerpsDiscountForAccount.",
+      "description": "core Quote an order's fees through the perps controller's calculateFees (HyperLiquid, testnet by default, read-only): protocol and MetaMask fee rates and amounts (plus the winning fee source on a core that reports it), with the rewards discount the headless RewardsController answers: the rewards API's answer for the selected wallet fixture account, the calls Mobile makes (UAT by default, like Mobile dev builds; CORE_PERPS_REWARDS_API_URL selects another).",
       "schema": {
         "type": "object",
         "properties": {
@@ -852,7 +852,7 @@
           },
           "rewards_discount_bips": {
             "type": "integer",
-            "description": "Rewards discount the headless RewardsController answers with, an integer in basis points from 0 through 10000 (6500 = 65%). Omitted: no rewards source, the controller's 'not known yet'."
+            "description": "Rewards discount the headless RewardsController answers with, an integer in basis points from 0 through 10000 (6500 = 65%). Replaces the rewards API's answer, to prove a discount the fixture accounts do not hold."
           },
           "account": {
             "type": "string",
@@ -1093,6 +1093,10 @@
             "type": "number",
             "default": 3
           },
+          "close_immediately": {
+            "type": "boolean",
+            "description": "Close the opened position again inside this action and prove the market flat (market orders only; the market must start flat). Required on mainnet, with leverage 1 and notional at most $15 from a fixture account."
+          },
           "account": {
             "type": "string",
             "description": "Wallet fixture account name (dev1, dev2, ...) or the 0x address of one; defaults to dev1."

package/library/manifests/extension.action-manifest.json

@@ -4371,6 +4371,10 @@
             "type": "number",
             "default": 1
           },
+          "close_immediately": {
+            "type": "boolean",
+            "description": "Close the opened position again inside this action and prove the market flat (market orders only; the market must start flat). Required on mainnet, with leverage 1 and notional at most $15 from a fixture account."
+          },
           "provider": {
             "type": "string",
             "description": "Exact Perps provider required before background dispatch."

package/library/manifests/mobile.action-manifest.json

@@ -2775,6 +2775,18 @@
           "leverage": {
             "type": "number",
             "default": 3
+          },
+          "network": {
+            "type": "string",
+            "enum": [
+              "mainnet",
+              "testnet"
+            ],
+            "description": "Perps network the order must run on; checked against the live app. A mainnet order must declare mainnet."
+          },
+          "close_immediately": {
+            "type": "boolean",
+            "description": "Close the opened position again inside this action and prove the market flat (market orders only; the market must start flat). Required on mainnet, with leverage 1 and notional at most $15 from a fixture account."
           }
         },
         "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.80.0",
+  "version": "0.81.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"
@@ -22,12 +22,12 @@
   },
   "dependencies": {
     "@farmslot/adapter-rn": "0.17.0",
-    "@farmslot/adapter-sdk": "0.3.1",
-    "@farmslot/adapter-web": "0.2.0",
+    "@farmslot/adapter-sdk": "0.4.0",
+    "@farmslot/adapter-web": "0.3.1",
     "@farmslot/agent-runtime": "0.17.0",
     "@farmslot/handoff": "^0.3.1",
     "@farmslot/protocol": "0.34.0",
-    "@farmslot/recipe-cli": "0.4.1",
+    "@farmslot/recipe-cli": "0.5.0",
     "@farmslot/recipe-runner": "0.24.0",
     "agent-device": "0.19.3",
     "commander": "^12.0.0",

package/site/assets/help-recipes.json

@@ -173,6 +173,7 @@
         "Graph: no unconditional pass, generic intent, hidden start state, or opaque node that collapses preparation, action, assertion, evidence, and teardown.",
         "Assertion modes such as require_unchanged must fail before any corrective action. Verify the negative path leaves the inspected state untouched; an assertion must not repair the behavior it is supposed to test.",
         "Reuse structured reads with assert_output instead of adding a new domain action for every comparison: source names the earlier node, and assert can select $.matchingCount with operator eq and the expected parameter. A status-report action can succeed while reporting missing prerequisites; assert required values before the dependent action. Checking three rows exist does not prove there are exactly three, or that they belong to this task.",
+        "Test command nodes: assert_output on the literal pass count. An exit code alone is not proof: jest -t exits 0 when no test matches.",
         "Evidence: inspect the recipe resolution, summary, trace, manifest, logs, and actual artifacts. Verify the values and state required by the claim.",
         "For a change claim, compare the actual before/after values for the same subject. Two captures alone prove neither an update nor freshness. Preserve unchanged observations as unproven rather than retrying to obtain a pass.",
         {

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()});`;
-}