@deeeed/metamask-harness 0.27.0 → 0.29.0

package/dist/mm-harness-cli.js

@@ -8,6 +8,7 @@ import { withCommandJournal } from "./command-journal.js";
 import { JsonStreamWriter } from "./json-stream.js";
 import { handleUpdate, maybeNudge } from "./commands/update.js";
 import { handleCallHelp } from "./commands/call.js";
+import { handleSetupBase } from "./commands/setup-base.js";
 import { getAdapterSurface } from "./adapters/surface.js";
 import { detectAdapter } from "./harness.js";
 import {
@@ -20,6 +21,28 @@ globalThis.__MM_HARNESS_WRAPPER__ = true;
 const { main: recipeMain } = await import("./cli.js");
 const rawArgv = process.argv.slice(2);
 const REAL = [
+  {
+    name: "setup-base",
+    summary: "Bootstrap numbered MetaMask product checkouts and install their dependencies.",
+    example: "mm-harness setup-base --only core --counts core=1",
+    helpText: `mm-harness setup-base [flags]
+
+  Bootstrap numbered MetaMask Extension, Mobile, and Core checkouts under one
+  base directory, then run each checkout's pinned dependency install.
+
+  --dir <base>                       Destination root
+  --counts <repo=n,...>              Copies per selected repository
+  --only <extension,mobile,core>     Repository subset
+  --dry-run                          Print the plan without changing anything
+  --force                            Override the free-space refusal
+  --json                             Machine-readable terminal summary
+  --show-config                      Print saved preferences and exit
+  --reset-config                     Remove saved preferences and exit
+  --skip-harness-update              Skip the installed-version notice
+
+Example:
+  mm-harness setup-base --only core --counts core=1`
+  },
   {
     name: "status",
     aliases: ["health", "home"],
@@ -121,6 +144,7 @@ Materialize:
 
   query                              Search names, categories, fields, and descriptions (typo-tolerant)
   --action <name>                    Describe one action; fuzzy-resolves like call (short or full name)
+  --matrix                           Compare action availability across Mobile, Extension, and Core
   --categories                       List compact action categories and counts
   --category <name>                  List only one category (for example ui, wallet, or perps)
   --adapter <mobile|extension|core>  Target adapter (auto-detected inside a checkout)
@@ -130,6 +154,7 @@ Materialize:
 
 Example:
   mm-harness actions --adapter mobile
+  mm-harness actions --matrix --json
   mm-harness actions positions --adapter mobile
   mm-harness actions --adapter mobile --categories --json
   mm-harness actions --adapter mobile --category ui --json
@@ -601,7 +626,7 @@ const HELP_GROUPS = [
   {
     title: "MAINTAIN",
     blurb: "keep the installed harness current with the npm registry",
-    commands: ["update"]
+    commands: ["setup-base", "update"]
   }
 ];
 function commandMeta(name) {
@@ -730,7 +755,7 @@ program.command("completions").description("Install/print bundled shell tab-comp
   const result = spawnSync("bash", [script, ...rawArgv.slice(1)], { stdio: "inherit" });
   process.exit(result.status ?? 1);
 });
-const NUDGE_SKIP = ["update", "completions", "completion-candidates"];
+const NUDGE_SKIP = ["setup-base", "update", "completions", "completion-candidates"];
 if (rawArgv.length > 0 && !NUDGE_SKIP.includes(rawArgv[0])) {
   maybeNudge();
 }
@@ -792,6 +817,9 @@ if (rawArgv.length === 0) {
   process.stdout.write(groupedHelp());
   process.exit(0);
 }
+if (rawArgv[0] === "setup-base") {
+  process.exit(handleSetupBase(rawArgv.slice(1)));
+}
 const preflightBypass = /* @__PURE__ */ new Set([
   ...HIDDEN,
   "completions"

package/dist/recipe-security.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { lstat, readFile, readdir, realpath } from "node:fs/promises";
 import path from "node:path";
 const READ_ONLY_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
+  "ui.locators",
   "metamask.wallet.fixture_status",
   "metamask.wallet.list_accounts",
   "metamask.wallet.read_state",

package/library/actions/extension/analytics/consent.mjs

@@ -0,0 +1,203 @@
+export function consentControllerExpression({
+  bridgeSymbol,
+  participate,
+  marketing,
+  timeoutMs,
+}) {
+  return `(async () => {
+    const submit = globalThis.stateHooks?.submitRequestToBackground;
+    const bridgeKey = Symbol.for(${JSON.stringify(bridgeSymbol)});
+    const capturedChrome = globalThis[bridgeKey];
+    let port;
+    let nextId = Date.now();
+    // Popup connections are ref-counted, so temporary ports cannot erase the
+    // live fullscreen or side-panel registration for the same tab.
+    const connectionName = 'popup';
+
+    const rawSubmit = (method, params) => new Promise((resolve, reject) => {
+      if (!port) {
+        if (typeof capturedChrome?.runtime?.connect !== 'function') {
+          reject(new Error('Extension consent setup could not reach the background controller.'));
+          return;
+        }
+        port = capturedChrome.runtime.connect({ name: connectionName });
+      }
+      const id = nextId++;
+      const timer = setTimeout(() => {
+        port.onMessage.removeListener(listener);
+        reject(new Error(method + ' timed out after ${Number(timeoutMs)}ms'));
+      }, ${Number(timeoutMs)});
+      const listener = (message) => {
+        const data = message?.name === 'controller' ? message.data : null;
+        if (data?.id !== id) return;
+        clearTimeout(timer);
+        port.onMessage.removeListener(listener);
+        if (data.error) reject(new Error(JSON.stringify(data.error)));
+        else resolve(data.result);
+      };
+      port.onMessage.addListener(listener);
+      try {
+        port.postMessage({
+          name: 'controller',
+          data: { jsonrpc: '2.0', id, method, params }
+        });
+      } catch (error) {
+        clearTimeout(timer);
+        port.onMessage.removeListener(listener);
+        reject(error);
+      }
+    });
+
+    const callController = typeof submit === 'function' ? submit : rawSubmit;
+    const readBackgroundState = () => new Promise((resolve, reject) => {
+      if (typeof capturedChrome?.runtime?.connect !== 'function') {
+        reject(new Error('Extension consent state is unavailable.'));
+        return;
+      }
+      const statePort = capturedChrome.runtime.connect({ name: connectionName });
+      const timer = setTimeout(() => {
+        statePort.onMessage.removeListener(listener);
+        statePort.disconnect();
+        reject(new Error('Extension consent state timed out after ${Number(timeoutMs)}ms.'));
+      }, ${Number(timeoutMs)});
+      const listener = (message) => {
+        const data = message?.name === 'controller' ? message.data : null;
+        if (data?.method !== 'START_UI_SYNC') return;
+        clearTimeout(timer);
+        statePort.onMessage.removeListener(listener);
+        statePort.disconnect();
+        resolve(data.params?.[0]);
+      };
+      statePort.onMessage.addListener(listener);
+    });
+    const readConsentState = async () => {
+      const hooks = globalThis.stateHooks || {};
+      const storeState = hooks.store?.getState?.();
+      const cleanState = typeof hooks.getCleanAppState === 'function'
+        ? await hooks.getCleanAppState()
+        : undefined;
+      const root = capturedChrome
+        ? await readBackgroundState()
+        : storeState ?? cleanState;
+      if (!root) {
+        throw new Error('Extension consent state is unavailable.');
+      }
+      const metamask = root?.metamask ?? root ?? {};
+      if (
+        typeof metamask.optedIn !== 'boolean' ||
+        typeof metamask.dataCollectionForMarketing !== 'boolean'
+      ) {
+        throw new Error('Extension consent state did not contain boolean consent fields.');
+      }
+      return {
+        state: {
+          optedIn: metamask.optedIn,
+          dataCollectionForMarketing: metamask.dataCollectionForMarketing,
+          analyticsId: metamask.analyticsId ? 'set' : null
+        },
+        source: capturedChrome
+          ? 'background-controller-flat-state'
+          : storeState
+            ? 'debug-page-store'
+            : 'debug-clean-app-state'
+      };
+    };
+    const waitForConsentState = async () => {
+      const expected = {
+        optedIn: ${JSON.stringify(participate)},
+        dataCollectionForMarketing: ${JSON.stringify(marketing)}
+      };
+      const deadline = Date.now() + ${Number(timeoutMs)};
+      let result;
+      do {
+        result = await readConsentState();
+        if (Object.entries(expected).every(([key, value]) => result.state[key] === value)) {
+          return result;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      } while (Date.now() < deadline);
+      throw new Error(
+        'Consent state did not settle to ' + JSON.stringify(expected) +
+        '; got ' + JSON.stringify(result?.state) + '.',
+      );
+    };
+    const setMarketing = async (value) => {
+      await callController('setDataCollectionForMarketing', [value]);
+    };
+
+    try {
+      if (!${JSON.stringify(participate)}) await setMarketing(false);
+      const analyticsId = await callController(
+        'setParticipateInMetaMetrics',
+        [${JSON.stringify(participate)}],
+      );
+      if (${JSON.stringify(participate)}) {
+        await setMarketing(${JSON.stringify(marketing)});
+      }
+      const settled = await waitForConsentState();
+      return {
+        analyticsId: analyticsId ? 'set' : null,
+        state: settled.state,
+        stateSource: settled.source
+      };
+    } finally {
+      port?.disconnect();
+      if (capturedChrome) delete globalThis[bridgeKey];
+    }
+  })()`;
+}
+
+export async function withConsentChromeBridge(page, {
+  bridgeSymbol,
+  timeoutMs,
+}, operation) {
+  const preload = await page.session.call('Page.addScriptToEvaluateOnNewDocument', {
+    source: `Object.defineProperty(
+      globalThis,
+      Symbol.for(${JSON.stringify(bridgeSymbol)}),
+      { value: globalThis.chrome, configurable: true }
+    );`,
+  });
+  if (!preload?.identifier) {
+    throw new Error('Extension consent setup could not register its temporary Chrome bridge.');
+  }
+
+  try {
+    let notifyLoaded;
+    const loaded = new Promise((resolve) => {
+      notifyLoaded = resolve;
+    });
+    const unsubscribe = page.session.on('Page.loadEventFired', () => notifyLoaded?.());
+    let reloadTimeout;
+    try {
+      await page.session.call('Page.reload', { ignoreCache: false });
+      await Promise.race([
+        loaded,
+        new Promise((_, reject) => {
+          reloadTimeout = setTimeout(
+            () => reject(new Error(`Extension consent reload timed out after ${timeoutMs}ms.`)),
+            timeoutMs,
+          );
+        }),
+      ]);
+    } finally {
+      clearTimeout(reloadTimeout);
+      unsubscribe();
+    }
+    await page.waitForExpression(
+      `typeof globalThis[Symbol.for(${JSON.stringify(bridgeSymbol)})]?.runtime?.connect === 'function'`,
+      { timeoutMs },
+    );
+    return await operation();
+  } finally {
+    try {
+      await page.session.call('Page.removeScriptToEvaluateOnNewDocument', {
+        identifier: preload.identifier,
+      });
+    } finally {
+      await page.evaluate(
+        `delete globalThis[Symbol.for(${JSON.stringify(bridgeSymbol)})]`,
+      );
+    }
+  }
+}

package/library/actions/extension/analytics/set_consent.mjs

@@ -1,155 +1,31 @@
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import { consentParams } from '../../shared/analytics/consent.mjs';
+import {
+  consentControllerExpression,
+  withConsentChromeBridge,
+} from './consent.mjs';
 
 runAdapter((input) => withExtensionPage(input, async (page) => {
   const { participate, marketing, timeoutMs } = consentParams(input.node);
   const bridgeSymbol = 'metamask-harness-consent-bridge';
 
-  async function readConsentState() {
-    return page.evaluate(`(async () => {
-      const hooks = globalThis.stateHooks || {};
-      const storeState = hooks.store?.getState?.();
-      const cleanState = typeof hooks.getCleanAppState === 'function'
-        ? await hooks.getCleanAppState()
-        : undefined;
-      if (!storeState && !cleanState) {
-        throw new Error('Extension consent state is unavailable.');
-      }
-      const metamask = storeState?.metamask ?? cleanState?.metamask ?? {};
-      return {
-        optedIn: Boolean(metamask.optedIn),
-        dataCollectionForMarketing: Boolean(metamask.dataCollectionForMarketing),
-        analyticsId: metamask.analyticsId ? 'set' : null
-      };
-    })()`, { awaitPromise: true });
-  }
-
-  async function waitForConsentState(expected) {
-    const deadline = Date.now() + timeoutMs;
-    let state;
-    do {
-      state = await readConsentState();
-      if (Object.entries(expected).every(([key, value]) => state[key] === value)) {
-        return state;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    } while (Date.now() < deadline);
-    throw new Error(`Consent state did not settle to ${JSON.stringify(expected)}; got ${JSON.stringify(state)}.`);
-  }
-
   const hasDebugBridge = await page.evaluate(
     `typeof globalThis.stateHooks?.submitRequestToBackground === 'function'`,
   );
-  let preloadIdentifier;
-  if (!hasDebugBridge) {
-    const preload = await page.session.call('Page.addScriptToEvaluateOnNewDocument', {
-      source: `Object.defineProperty(
-        globalThis,
-        Symbol.for(${JSON.stringify(bridgeSymbol)}),
-        { value: globalThis.chrome, configurable: true }
-      );`,
-    });
-    preloadIdentifier = preload?.identifier;
-    try {
-      let notifyLoaded;
-      const loaded = new Promise((resolve) => {
-        notifyLoaded = resolve;
-      });
-      const unsubscribe = page.session.on('Page.loadEventFired', () => notifyLoaded?.());
-      let reloadTimeout;
-      try {
-        await page.session.call('Page.reload', { ignoreCache: false });
-        await Promise.race([
-          loaded,
-          new Promise((_, reject) => {
-            reloadTimeout = setTimeout(
-              () => reject(new Error(`Extension consent reload timed out after ${timeoutMs}ms.`)),
-              timeoutMs,
-            );
-          }),
-        ]);
-      } finally {
-        clearTimeout(reloadTimeout);
-        unsubscribe();
-      }
-      await page.waitForExpression(
-        `typeof globalThis[Symbol.for(${JSON.stringify(bridgeSymbol)})]?.runtime?.connect === 'function'`,
-        { timeoutMs },
-      );
-    } finally {
-      if (preloadIdentifier) {
-        await page.session.call('Page.removeScriptToEvaluateOnNewDocument', {
-          identifier: preloadIdentifier,
-        });
-      }
-    }
-  }
-
-  const controllerResult = await page.evaluate(`(async () => {
-    const submit = globalThis.stateHooks?.submitRequestToBackground;
-    const bridgeKey = Symbol.for(${JSON.stringify(bridgeSymbol)});
-    const capturedChrome = globalThis[bridgeKey];
-    let port;
-    let nextId = Date.now();
-
-    const rawSubmit = (method, params) => new Promise((resolve, reject) => {
-      if (!port) {
-        const connectionName = location.pathname.includes('sidepanel')
-          ? 'sidepanel'
-          : location.pathname.includes('popup')
-            ? 'popup'
-            : 'fullscreen';
-        port = capturedChrome.runtime.connect({ name: connectionName });
-      }
-      const id = nextId++;
-      const timer = setTimeout(
-        () => reject(new Error(method + ' timed out after ${timeoutMs}ms')),
-        ${timeoutMs},
-      );
-      const listener = (message) => {
-        const data = message?.name === 'controller' ? message.data : null;
-        if (data?.id !== id) return;
-        clearTimeout(timer);
-        port.onMessage.removeListener(listener);
-        if (data.error) reject(new Error(JSON.stringify(data.error)));
-        else resolve(data.result);
-      };
-      port.onMessage.addListener(listener);
-      port.postMessage({
-        name: 'controller',
-        data: { jsonrpc: '2.0', id, method, params }
-      });
-    });
-
-    const callController = typeof submit === 'function' ? submit : rawSubmit;
-    if (typeof callController !== 'function') {
-      throw new Error('Extension consent setup could not reach the background controller.');
-    }
-
-    const setMarketing = async (value) => {
-      await callController('setDataCollectionForMarketing', [value]);
-    };
-
-    try {
-      if (!${JSON.stringify(participate)}) await setMarketing(false);
-      const analyticsId = await callController(
-        'setParticipateInMetaMetrics',
-        [${JSON.stringify(participate)}],
-      );
-      if (${JSON.stringify(participate)}) {
-        await setMarketing(${JSON.stringify(marketing)});
-      }
-      return { analyticsId: analyticsId ? 'set' : null };
-    } finally {
-      port?.disconnect();
-      if (capturedChrome) delete globalThis[bridgeKey];
-    }
-  })()`, { awaitPromise: true });
-
-  const state = await waitForConsentState({
-    optedIn: participate,
-    dataCollectionForMarketing: marketing,
-  });
+  const runController = () => page.evaluate(consentControllerExpression({
+    bridgeSymbol,
+    participate,
+    marketing,
+    timeoutMs,
+  }), { awaitPromise: true });
+  const controllerResult = hasDebugBridge
+    ? await runController()
+    : await withConsentChromeBridge(
+      page,
+      { bridgeSymbol, timeoutMs },
+      runController,
+    );
+  const state = controllerResult.state;
 
   if (state.optedIn !== participate) {
     throw new Error(`Expected optedIn=${participate}, got ${state.optedIn}.`);
@@ -166,6 +42,6 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
       ...state,
       analyticsId: controllerResult.analyticsId,
     },
-    proofPath: 'extension-background-controller',
+    proofPath: `extension-${controllerResult.stateSource}`,
   };
 }));

package/library/actions/extension/perps/perps.mjs

@@ -1,5 +1,6 @@
 import { pathToFileURL } from 'node:url';
 import { dataTestId, marketSymbol, normalizeMarketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { readPerpsRuntimeStateExpression } from './state.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -704,22 +705,7 @@ async function applyStateNavigation(input, config) {
 
 
 async function readPerpsRuntimeState(page) {
-  return page.evaluate(`(async () => {
-    const hooks = globalThis.stateHooks || {};
-    const request = hooks.submitRequestToBackground;
-    const reduxState = hooks.store?.getState?.() || {};
-    const cleanState = (await hooks.getCleanAppState?.()) || hooks.getState?.() || {};
-    const metamask = reduxState.metamask || cleanState.metamask || {};
-    const nestedPerps = metamask.PerpsController || cleanState.PerpsController || cleanState.perps || {};
-    return {
-      available: typeof request === 'function',
-      activeProvider: metamask.activeProvider || nestedPerps.activeProvider || 'hyperliquid',
-      networkKnown: typeof nestedPerps.isTestnet === 'boolean',
-      isTestnet: Boolean(nestedPerps.isTestnet),
-      initializationState: metamask.initializationState || nestedPerps.initializationState || null,
-      isEligible: Boolean(metamask.isEligible ?? nestedPerps.isEligible),
-    };
-  })()`);
+  return page.evaluate(readPerpsRuntimeStateExpression());
 }
 
 async function ensureProvider(input, config) {

package/library/actions/extension/perps/state.mjs

@@ -0,0 +1,20 @@
+export function readPerpsRuntimeStateExpression() {
+  return `(async () => {
+    const hooks = globalThis.stateHooks || {};
+    const request = hooks.submitRequestToBackground;
+    const reduxState = hooks.store?.getState?.() || {};
+    const cleanState = (await hooks.getCleanAppState?.()) || hooks.getState?.() || {};
+    const reduxMetamask = reduxState.metamask || {};
+    const cleanMetamask = cleanState.metamask || {};
+    const metamask = { ...cleanMetamask, ...reduxMetamask };
+    const nestedPerps = reduxMetamask.PerpsController || cleanMetamask.PerpsController || cleanState.PerpsController || cleanState.perps || {};
+    return {
+      available: typeof request === 'function',
+      activeProvider: metamask.activeProvider || nestedPerps.activeProvider || 'hyperliquid',
+      networkKnown: typeof metamask.isTestnet === 'boolean' || typeof nestedPerps.isTestnet === 'boolean',
+      isTestnet: Boolean(metamask.isTestnet ?? nestedPerps.isTestnet),
+      initializationState: metamask.initializationState || nestedPerps.initializationState || null,
+      isEligible: Boolean(metamask.isEligible ?? nestedPerps.isEligible),
+    };
+  })()`;
+}

package/library/actions/extension/ui/locators.mjs

@@ -0,0 +1,13 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  locatorsFromObservation,
+  requireVisibleObservation,
+} from '../../shared/ui/locators.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const observed = await page.observe(['ui.visible']);
+  return {
+    action: input.action,
+    ...locatorsFromObservation(requireVisibleObservation(observed)),
+  };
+}));

package/library/actions/extension/wallet/list_accounts.mjs

@@ -1,37 +1,15 @@
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { listWalletAccountsExpression } from './state.mjs';
 
 runAdapter((input) => withExtensionPage(input, async (page) => {
   const scope = input.node?.scope == null ? 'named' : String(input.node.scope);
   if (scope !== 'selected' && scope !== 'named' && scope !== 'evm' && scope !== 'all') {
     throw new Error('metamask.wallet.list_accounts scope must be selected, named, evm, or all.');
   }
-  const result = await page.evaluate(`(() => {
-    const store = globalThis.stateHooks?.store;
-    if (!store || typeof store.getState !== 'function') {
-      throw new Error('stateHooks.store.getState is unavailable.');
-    }
-    const internal = store.getState()?.metamask?.internalAccounts || {};
-    const selectedId = internal.selectedAccount || null;
-    const scope = ${JSON.stringify(scope)};
-    const accounts = Object.entries(internal.accounts || {})
-      .map(([id, account]) => ({
-        id,
-        address: account?.address || null,
-        name: account?.metadata?.name || null,
-        type: account?.type || null,
-        selected: id === selectedId
-      }))
-      .filter((account) => {
-        if (scope === 'selected') return account.selected;
-        if (scope === 'all') return true;
-        if (scope === 'evm') return /^0x[0-9a-f]{40}$/iu.test(account.address || '');
-        return account.selected || Boolean(String(account.name || '').trim());
-      });
-    return { accounts };
-  })()`);
+  const result = await page.evaluate(listWalletAccountsExpression(scope), { awaitPromise: true });
   return {
     action: input.action,
-    source: 'extension-stateHooks-store',
+    source: 'extension-stateHooks-clean-state',
     scope,
     ...result,
     count: result.accounts.length,

package/library/actions/extension/wallet/read_state.mjs

@@ -1,27 +1,7 @@
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { readWalletStateExpression } from './state.mjs';
 
 runAdapter((input) => withExtensionPage(input, async (page) => {
-  const state = await page.evaluate(`(() => {
-    const hooks = globalThis.stateHooks;
-    const store = hooks && hooks.store;
-    const root = store && typeof store.getState === 'function' ? store.getState() : {};
-    const metamask = root.metamask || {};
-    const internal = metamask.internalAccounts || {};
-    const accounts = internal.accounts || {};
-    const selectedId = internal.selectedAccount || null;
-    const selected = selectedId && accounts[selectedId] ? accounts[selectedId] : null;
-    const metadata = selected && selected.metadata ? selected.metadata : {};
-    return {
-      href: String(globalThis.location && globalThis.location.href || ''),
-      selectedAccount: selected ? {
-        id: selectedId,
-        address: selected.address || null,
-        name: metadata.name || null,
-        type: selected.type || null
-      } : null,
-      completedOnboarding: Boolean(metamask.completedOnboarding),
-      selectedNetworkClientId: metamask.selectedNetworkClientId || null
-    };
-  })()`);
-  return { action: input.action, source: 'extension-stateHooks-store', state, redacted: true, proofPath: 'extension-wallet-state' };
+  const state = await page.evaluate(readWalletStateExpression(), { awaitPromise: true });
+  return { action: input.action, source: 'extension-stateHooks-clean-state', state, redacted: true, proofPath: 'extension-wallet-state' };
 }));

package/library/actions/extension/wallet/select_account.mjs

@@ -1,4 +1,5 @@
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { selectWalletAccountExpression } from './state.mjs';
 
 function normalize(value) {
   return String(value ?? '').toLowerCase();
@@ -11,38 +12,10 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
   if (!requestedAddress && !requestedId && !requestedName) {
     throw new Error('metamask.wallet.select_account extension live adapter requires node.address, node.id, or node.name.');
   }
-  const selected = await page.evaluate(`(async () => {
-    const hooks = globalThis.stateHooks;
-    const store = hooks && hooks.store;
-    const request = hooks && hooks.submitRequestToBackground;
-    if (!store || typeof store.getState !== 'function') throw new Error('stateHooks.store.getState is unavailable.');
-    if (typeof request !== 'function') throw new Error('stateHooks.submitRequestToBackground is unavailable.');
-    const state = store.getState() || {};
-    const internal = state.metamask?.internalAccounts || {};
-    const accounts = internal.accounts || {};
-    const requestedAddress = ${JSON.stringify(requestedAddress)};
-    const requestedId = ${JSON.stringify(requestedId)};
-    const requestedName = ${JSON.stringify(requestedName)};
-    const entries = Object.entries(accounts);
-    const match = entries.find(([id, account]) => {
-      const metadata = account?.metadata || {};
-      return (requestedId && id === requestedId) ||
-        (requestedAddress && String(account?.address || '').toLowerCase() === requestedAddress) ||
-        (requestedName && metadata.name === requestedName);
-    });
-    if (!match) throw new Error('Requested account was not found in internalAccounts.');
-    const [id, account] = match;
-    await request('setSelectedInternalAccount', [id]);
-    const after = store.getState()?.metamask?.internalAccounts || {};
-    const selectedId = after.selectedAccount;
-    const selected = after.accounts?.[selectedId];
-    if (selectedId !== id) throw new Error('Expected selected account ' + id + ', got ' + selectedId);
-    return {
-      id: selectedId,
-      address: selected?.address || null,
-      name: selected?.metadata?.name || null,
-      type: selected?.type || null
-    };
-  })()`, { awaitPromise: true });
+  const selected = await page.evaluate(selectWalletAccountExpression({
+    address: requestedAddress,
+    id: requestedId,
+    name: requestedName,
+  }), { awaitPromise: true });
   return { action: input.action, selected, proofPath: 'extension-account-selection' };
 }));