@deeeed/metamask-harness 0.36.0 → 0.38.0

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

@@ -12,8 +12,15 @@ const BACK_CONTROLS = [
   'perps-market-detail-back-button',
   'perps-activity-back-button',
   'perps-withdraw-back-button',
+  'wallet-initiated-header-back-button',
+  'transaction-details-back-button',
+  'asset__back',
+  'token-management-header-back-button',
+  'custom-token-import-back-button',
+  'networks-page-form-back-button',
+  'page-header-back-button',
   'back-button',
-].map(dataTestId);
+].map(dataTestId).concat('button[aria-label="Back"]');
 
 function text(value) {
   return typeof value === 'string' && value.length > 0 ? value : undefined;
@@ -22,13 +29,37 @@ function text(value) {
 function pageIntent(node) {
   const page = text(node?.page);
   if (!page) return undefined;
-  if (page === 'home' || page === 'perps') return { page };
+  if (page === 'back' || page === 'home' || page === 'perps' || page === 'swap') return { page };
+  if (page === 'perps-market-list' || page === 'perps-activity') return { page };
+  if (page === 'network') {
+    const network = text(node.network);
+    const chainId = Number(node.chain_id);
+    if (!network || !Number.isInteger(chainId) || chainId <= 0) {
+      throw new Error('extension ui.navigate page=network requires network and a positive integer chain_id.');
+    }
+    return { page, network, chainId, addIfMissing: node.add_if_missing !== false };
+  }
   if (page === 'perps-market') {
     const market = text(node.market) ?? text(node.symbol);
     if (!market) throw new Error('extension ui.navigate page=perps-market requires market or symbol.');
     return { page, market };
   }
-  throw new Error('extension ui.navigate supported page intents: home, perps, perps-market.');
+  throw new Error('extension ui.navigate supported page intents: back, home, network, perps, perps-market-list, perps-market, perps-activity, swap.');
+}
+
+async function goBack(page, timeoutMs) {
+  const before = await currentHref(page);
+  const history = await page.session.call('Page.getNavigationHistory');
+  const entry = history.entries?.[history.currentIndex - 1];
+  if (!entry) throw new Error('extension ui.navigate page=back has no previous browser history entry.');
+  await page.session.call('Page.navigateToHistoryEntry', { entryId: entry.id });
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const href = await currentHref(page);
+    if (href !== before) return { method: 'browser-history', href, previousHref: before };
+    await pauseForUi(page);
+  }
+  throw new Error(`extension ui.navigate page=back did not leave ${JSON.stringify(before)}.`);
 }
 
 async function hasVisibleSelector(page, selector) {
@@ -59,6 +90,12 @@ async function currentHref(page) {
   return page.evaluate('location.href');
 }
 
+function isHomeHref(href) {
+  const hash = href.includes('#') ? href.slice(href.indexOf('#')) : '';
+  const route = hash.split('?')[0];
+  return route === '' || route === '#' || route === '#/';
+}
+
 async function activateSemanticControl(page, selector) {
   return {
     activation: 'trusted-pointer',
@@ -68,6 +105,7 @@ async function activateSemanticControl(page, selector) {
 
 export async function openHome(page, timeoutMs) {
   const home = dataTestId('bottom-nav-home');
+  const drawerClose = dataTestId('drawer-close-button');
   const selectedHome = `${home}[aria-current="page"]`;
   const legacyHome = dataTestId('account-overview__asset-tab');
   const selectedLegacyHome = `${legacyHome}[aria-selected="true"]`;
@@ -76,13 +114,20 @@ export async function openHome(page, timeoutMs) {
   let pendingActivation;
 
   while (Date.now() < deadline) {
+    if (await hasVisibleSelector(page, drawerClose)) {
+      await activateSemanticControl(page, drawerClose);
+      steps.push(drawerClose);
+      await pauseForUi(page);
+      continue;
+    }
+    const href = await currentHref(page);
     if (
-      (await hasVisibleSelector(page, selectedHome)) ||
-      (await hasVisibleSelector(page, selectedLegacyHome))
+      isHomeHref(href) &&
+      ((await hasVisibleSelector(page, selectedHome)) ||
+        (await hasVisibleSelector(page, selectedLegacyHome)))
     ) {
-      return { method: 'visible-ui', href: await currentHref(page), steps };
+      return { method: 'visible-ui', href, steps };
     }
-    const href = await currentHref(page);
     if (pendingActivation && pendingActivation.href !== href) {
       pendingActivation = undefined;
       await pauseForUi(page);
@@ -130,12 +175,19 @@ export async function openPerpsHome(page, timeoutMs) {
   const bottomNav = dataTestId('bottom-nav-perps');
   const legacyTab = dataTestId('account-overview__perps-tab');
   const perpsHome = dataTestId('perps-home-page');
+  const tutorialSkip = dataTestId('perps-tutorial-skip-button');
   const steps = [];
   const deadline = Date.now() + timeoutMs;
   let pendingActivation;
   let perpsActivation;
 
   while (Date.now() < deadline) {
+    if (await hasVisibleSelector(page, tutorialSkip)) {
+      await activateSemanticControl(page, tutorialSkip);
+      steps.push(tutorialSkip);
+      await pauseForUi(page);
+      continue;
+    }
     if (await hasVisibleSelector(page, perpsHome)) {
       return {
         ...(perpsActivation ? { navigation: perpsActivation, selector: bottomNav } : {}),
@@ -207,8 +259,23 @@ export async function openPerpsHome(page, timeoutMs) {
 
 export async function openPerpsMarket(page, market, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
-  const home = await openPerpsHome(page, Math.max(1, deadline - Date.now()));
   const normalizedMarket = normalizeMarketSymbol(market.trim());
+  if (await hasVisibleSelector(page, dataTestId('market-list-view'))) {
+    const marketRow = dataTestId(`market-row-${normalizedMarket.replace(':', '-')}`);
+    await page.waitForSelector(marketRow, { timeoutMs: Math.max(1, deadline - Date.now()) });
+    const navigation = await activateSemanticControl(page, marketRow);
+    await page.waitForSelector(dataTestId('perps-market-detail-page'), {
+      timeoutMs: Math.max(1, deadline - Date.now()),
+    });
+    return {
+      navigation,
+      method: 'visible-ui',
+      href: await currentHref(page),
+      selector: marketRow,
+      steps: [marketRow],
+    };
+  }
+  const home = await openPerpsHome(page, Math.max(1, deadline - Date.now()));
   const selectors = [
     dataTestId(`perps-watchlist-${normalizedMarket}`),
     dataTestId(`explore-markets-${normalizedMarket.replaceAll(':', '-')}`),
@@ -239,11 +306,178 @@ export async function openPerpsMarket(page, market, timeoutMs) {
   };
 }
 
+export async function openPerpsActivity(page, timeoutMs) {
+  if (await hasVisibleSelector(page, dataTestId('perps-activity-page'))) {
+    return { method: 'visible-ui', href: await currentHref(page), steps: [] };
+  }
+  const deadline = Date.now() + timeoutMs;
+  const home = await openPerpsHome(page, Math.max(1, deadline - Date.now()));
+  const activity = dataTestId('perps-recent-activity-see-all');
+  await page.waitForSelector(activity, { timeoutMs: Math.max(1, deadline - Date.now()) });
+  const navigation = await activateSemanticControl(page, activity);
+  await page.waitForSelector(dataTestId('perps-activity-page'), {
+    timeoutMs: Math.max(1, deadline - Date.now()),
+  });
+  return {
+    navigation,
+    method: 'visible-ui',
+    href: await currentHref(page),
+    selector: activity,
+    steps: [...(home.steps ?? []), activity],
+  };
+}
+
+export async function openPerpsMarketList(page, timeoutMs) {
+  const marketList = dataTestId('market-list-view');
+  if (await hasVisibleSelector(page, marketList)) {
+    return { method: 'visible-ui', href: await currentHref(page), steps: [] };
+  }
+  const deadline = Date.now() + timeoutMs;
+  const detailListButton = dataTestId('perps-market-detail-market-list-button');
+  if (await hasVisibleSelector(page, detailListButton)) {
+    const navigation = await activateSemanticControl(page, detailListButton);
+    await page.waitForSelector(marketList, { timeoutMs: Math.max(1, deadline - Date.now()) });
+    return {
+      navigation,
+      method: 'visible-ui',
+      href: await currentHref(page),
+      selector: detailListButton,
+      steps: [detailListButton],
+    };
+  }
+  const home = await openPerpsHome(page, Math.max(1, deadline - Date.now()));
+  const explore = dataTestId('perps-explore-markets-row');
+  await page.waitForSelector(explore, { timeoutMs: Math.max(1, deadline - Date.now()) });
+  const navigation = await activateSemanticControl(page, explore);
+  await page.waitForSelector(marketList, { timeoutMs: Math.max(1, deadline - Date.now()) });
+  return {
+    navigation,
+    method: 'visible-ui',
+    href: await currentHref(page),
+    selector: explore,
+    steps: [...home.steps, explore],
+  };
+}
+
+export async function openNetwork(page, network, chainId, addIfMissing, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const hexChainId = `0x${chainId.toString(16)}`;
+  const installed = dataTestId(`home-network-filter-network-${hexChainId}`);
+  const custom = dataTestId(`home-network-filter-custom-${hexChainId}`);
+  const additional = dataTestId(`home-network-filter-additional-${hexChainId}`);
+  const manage = dataTestId('home-network-filter-manage-networks');
+  const sort = dataTestId('sort-by-networks');
+  const assets = dataTestId('account-overview__asset-tab');
+  const steps = [];
+  await openHome(page, Math.max(1, deadline - Date.now()));
+  if (!(await hasVisibleSelector(page, `${assets}[aria-selected="true"]`))) {
+    await activateSemanticControl(page, assets);
+    steps.push(assets);
+    if (!(await waitForFirstVisible(page, [`${assets}[aria-selected="true"]`], deadline))) {
+      throw new Error('Token assets did not become selected before network navigation.');
+    }
+  }
+  await activateSemanticControl(page, sort);
+  steps.push(sort);
+  let choice = await waitForFirstVisible(page, [installed, custom, additional, manage], deadline);
+  if (!choice) throw new Error(`Network filter did not show ${network} (${chainId}) before timeout.`);
+  if (choice !== manage) {
+    await activateSemanticControl(page, choice);
+    steps.push(choice);
+  } else {
+    if (!addIfMissing) {
+      throw new Error(`Network ${network} (${chainId}) is not added to the wallet.`);
+    }
+    await activateSemanticControl(page, manage);
+    steps.push(manage);
+    const listItem = dataTestId(`network-list-item-eip155:${chainId}`);
+    if (!await hasVisibleSelector(page, listItem)) {
+      const popular = `${dataTestId(`popular-network-${hexChainId}`)} ${dataTestId('test-add-button')}`;
+      await page.waitForSelector(popular, { timeoutMs: Math.max(1, deadline - Date.now()) });
+      await activateSemanticControl(page, popular);
+      steps.push(popular);
+      await page.waitForSelector(listItem, { timeoutMs: Math.max(1, deadline - Date.now()) });
+    }
+    const back = dataTestId('page-header-back-button');
+    await activateSemanticControl(page, back);
+    steps.push(back);
+    await page.waitForSelector(sort, { timeoutMs: Math.max(1, deadline - Date.now()) });
+    await activateSemanticControl(page, sort);
+    steps.push(sort);
+    choice = await waitForFirstVisible(page, [installed, custom, additional], deadline);
+    if (!choice) throw new Error(`Added network ${network} (${chainId}) did not appear in the wallet filter.`);
+    await activateSemanticControl(page, choice);
+    steps.push(choice);
+  }
+  while (Date.now() < deadline) {
+    const label = await page.evaluate(`String(document.querySelector(${JSON.stringify(sort)})?.innerText || '')`);
+    if (label.toLowerCase().includes(network.toLowerCase())) {
+      return { method: 'visible-ui', href: await currentHref(page), network, chainId, steps };
+    }
+    await pauseForUi(page);
+  }
+  throw new Error(`Network ${network} (${chainId}) did not become the selected wallet filter.`);
+}
+
+export async function openSwap(page, timeoutMs) {
+  const sourceAmount = dataTestId('from-amount');
+  const sourceToken = dataTestId('bridge-source-button');
+  const destinationToken = dataTestId('bridge-destination-button');
+  const bottomNav = dataTestId('bottom-nav-swaps');
+  const deadline = Date.now() + timeoutMs;
+  if (
+    await hasVisibleSelector(page, sourceAmount) &&
+    await hasVisibleSelector(page, sourceToken) &&
+    await hasVisibleSelector(page, destinationToken)
+  ) {
+    return { method: 'visible-ui', href: await currentHref(page), steps: [] };
+  }
+  const home = await openHome(page, Math.max(1, deadline - Date.now()));
+  let navigation;
+  let lastActivationAt = 0;
+  let observedHref = await currentHref(page);
+  while (Date.now() < deadline) {
+    if (
+      await hasVisibleSelector(page, sourceAmount) &&
+      await hasVisibleSelector(page, sourceToken) &&
+      await hasVisibleSelector(page, destinationToken)
+    ) break;
+    const href = await currentHref(page);
+    if (href !== observedHref) {
+      observedHref = href;
+      lastActivationAt = Date.now();
+    }
+    if (await hasVisibleSelector(page, bottomNav) && (!navigation || Date.now() - lastActivationAt >= 1000)) {
+      navigation = await activateSemanticControl(page, bottomNav);
+      lastActivationAt = Date.now();
+    }
+    await pauseForUi(page);
+  }
+  if (
+    !(await hasVisibleSelector(page, sourceAmount)) ||
+    !(await hasVisibleSelector(page, sourceToken)) ||
+    !(await hasVisibleSelector(page, destinationToken))
+  ) {
+    throw new Error('Swap inputs did not appear after visible Swap navigation.');
+  }
+  return {
+    navigation,
+    method: 'visible-ui',
+    href: await currentHref(page),
+    selector: bottomNav,
+    steps: [...home.steps, bottomNav],
+  };
+}
+
 export async function navigateExtensionUi(input) {
   return withExtensionPage(input, async (page) => {
   const intent = pageIntent(input.node);
   if (intent) {
     const timeoutMs = Number(input.node?.timeout_ms ?? 20000);
+    if (intent.page === 'back') {
+      const result = await goBack(page, timeoutMs);
+      return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
+    }
     if (intent.page === 'home') {
       const result = await openHome(page, timeoutMs);
       return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
@@ -252,6 +486,28 @@ export async function navigateExtensionUi(input) {
       const result = await openPerpsHome(page, timeoutMs);
       return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
     }
+    if (intent.page === 'perps-market-list') {
+      const result = await openPerpsMarketList(page, timeoutMs);
+      return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
+    }
+    if (intent.page === 'perps-activity') {
+      const result = await openPerpsActivity(page, timeoutMs);
+      return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
+    }
+    if (intent.page === 'network') {
+      const result = await openNetwork(
+        page,
+        intent.network,
+        intent.chainId,
+        intent.addIfMissing,
+        timeoutMs,
+      );
+      return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
+    }
+    if (intent.page === 'swap') {
+      const result = await openSwap(page, timeoutMs);
+      return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
+    }
     const result = await openPerpsMarket(page, intent.market, timeoutMs);
     return { action: input.action, ...intent, ...result, proofPath: 'ui-navigation' };
   }

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

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import { walletFixturePath } from '../../harness-exports.mjs';
 
 async function fixturePassword(projectRoot) {
@@ -32,11 +32,7 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
 
   const password = input.node?.password ?? await fixturePassword(input.context.projectRoot);
   await page.setInput('input[type="password"]', String(password));
-  await page.evaluate(`(() => {
-    const button = document.querySelector('button[type="submit"]') || Array.from(document.querySelectorAll('button')).find((candidate) => /unlock/i.test(candidate.innerText || candidate.textContent || ''));
-    if (!button) throw new Error('Unlock button not found.');
-    button.click();
-  })()`);
+  await page.click(dataTestId('unlock-submit'));
   await page.waitForExpression(`!document.querySelector('input[type="password"]')`, { timeoutMs: Number(input.node?.timeout_ms ?? 15000) });
   return { action: input.action, unlocked: true, redacted: true, proofPath: 'extension-password-unlock' };
 }));

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

@@ -1,5 +1,6 @@
 import { resolveWalletImportCredentials, validateWalletImportOptions, walletImportMethod } from '../../shared/wallet/import-source.mjs';
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { pasteSecretRecoveryPhrase, setSecretInput } from './secret-input.mjs';
 import { readWalletStateExpression } from './state.mjs';
 
 const SELECTORS = {
@@ -54,42 +55,6 @@ async function waitForFirstSelector(page, selectors, timeoutMs) {
   throw new Error('Wallet import timed out waiting for the next onboarding screen.');
 }
 
-async function setSecretInput(page, selector, value) {
-  await page.evaluate(`(() => {
-    const element = document.querySelector(${JSON.stringify(selector)});
-    if (!element) throw new Error('Wallet import secret input was not found.');
-    element.focus();
-    if (typeof element.select === 'function') element.select();
-  })()`);
-  await page.session.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace' });
-  await page.session.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace' });
-  await page.session.call('Input.insertText', { text: value });
-  const matches = await page.evaluate(`(() => {
-    const element = document.querySelector(${JSON.stringify(selector)});
-    if (!element) return false;
-    element.dispatchEvent(new Event('change', { bubbles: true }));
-    return element.value === ${JSON.stringify(value)};
-  })()`);
-  if (!matches) throw new Error('Wallet import secret input did not retain the supplied value.');
-}
-
-async function pasteSecretInput(page, selector, value) {
-  const pasted = await page.evaluate(`(() => {
-    const element = document.querySelector(${JSON.stringify(selector)});
-    if (!element) return false;
-    const clipboardData = new DataTransfer();
-    clipboardData.setData('text', ${JSON.stringify(value)});
-    element.focus();
-    element.dispatchEvent(new ClipboardEvent('paste', {
-      bubbles: true,
-      cancelable: true,
-      clipboardData,
-    }));
-    return true;
-  })()`);
-  if (!pasted) throw new Error('Wallet import Secret Recovery Phrase input was not found.');
-}
-
 async function waitForEnabled(page, selector, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
@@ -120,17 +85,19 @@ async function importThroughUi(page, input, timeoutMs) {
   if (interests.length > 0) {
     throw new Error('metamask.wallet.import interests are supported only on Mobile.');
   }
-  await page.click(SELECTORS.importWallet);
-  const importChoice = await waitForFirstSelector(
-    page,
-    [SELECTORS.importWithSrp, SELECTORS.srp],
-    timeoutMs,
-  );
-  if (importChoice === SELECTORS.importWithSrp) {
-    await page.click(SELECTORS.importWithSrp);
+  if (!(await hasSelector(page, SELECTORS.srp))) {
+    await page.click(SELECTORS.importWallet);
+    const importChoice = await waitForFirstSelector(
+      page,
+      [SELECTORS.importWithSrp, SELECTORS.srp],
+      timeoutMs,
+    );
+    if (importChoice === SELECTORS.importWithSrp) {
+      await page.click(SELECTORS.importWithSrp);
+    }
+    await waitForSelector(page, SELECTORS.srp, timeoutMs);
   }
-  await waitForSelector(page, SELECTORS.srp, timeoutMs);
-  await pasteSecretInput(page, SELECTORS.srp, credentials.mnemonic);
+  await pasteSecretRecoveryPhrase(page, SELECTORS.srp, credentials.mnemonic, timeoutMs);
   await waitForEnabled(page, SELECTORS.confirmSrp, timeoutMs);
   await page.click(SELECTORS.confirmSrp);
   await waitForSelector(page, SELECTORS.password, timeoutMs);

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

@@ -0,0 +1,35 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+const MENU = dataTestId('account-options-menu-button');
+const LOCK = dataTestId('global-menu-lock');
+const UNLOCK_PAGE = dataTestId('unlock-page');
+
+async function visible(page, selector) {
+  return page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return false;
+    const style = getComputedStyle(element);
+    const rect = element.getBoundingClientRect();
+    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+  })()`);
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  if (!(await visible(page, LOCK))) await page.click(MENU);
+  const deadline = Date.now() + Number(input.node?.timeout_ms ?? 15_000);
+  while (!(await visible(page, LOCK))) {
+    if (Date.now() >= deadline) throw new Error('Wallet lock control did not become visible.');
+    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 100))');
+  }
+  await page.click(LOCK);
+  while (!(await visible(page, UNLOCK_PAGE))) {
+    if (Date.now() >= deadline) throw new Error('Wallet did not reach the unlock page after locking.');
+    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 100))');
+  }
+  return {
+    action: input.action,
+    locked: true,
+    route: await page.evaluate('location.hash'),
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

package/library/actions/extension/wallet/secret-input.mjs

@@ -0,0 +1,98 @@
+export async function setSecretInput(page, selector, value) {
+  const found = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return false;
+    element.focus();
+    if (typeof element.select === 'function') element.select();
+    return true;
+  })()`);
+  if (!found) throw new Error('Wallet import secret input was not found.');
+
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace' });
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace' });
+  await page.session.call('Input.insertText', { text: value });
+
+  const retainedLength = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return -1;
+    element.dispatchEvent(new Event('change', { bubbles: true }));
+    return typeof element.value === 'string' ? element.value.length : -1;
+  })()`);
+  if (retainedLength !== value.length) {
+    throw new Error('Wallet import secret input did not retain the supplied value.');
+  }
+}
+
+export async function pasteSecretRecoveryPhrase(page, selector, value, timeoutMs) {
+  const bridgeKey = 'mm-harness.wallet.recovery-phrase-paste';
+  const preload = await page.session.call('Page.addScriptToEvaluateOnNewDocument', {
+    source: `(() => {
+      const bridgeKey = Symbol.for(${JSON.stringify(bridgeKey)});
+      const NativeDataTransfer = globalThis.DataTransfer;
+      const NativeClipboardEvent = globalThis.ClipboardEvent;
+      Object.defineProperty(globalThis, bridgeKey, {
+        configurable: true,
+        value(selector) {
+          const element = document.querySelector(selector);
+          if (!element || typeof element.value !== 'string') return false;
+          const clipboardData = new NativeDataTransfer();
+          clipboardData.setData('text', element.value);
+          element.focus();
+          element.dispatchEvent(new NativeClipboardEvent('paste', {
+            bubbles: true,
+            cancelable: true,
+            clipboardData,
+          }));
+          return true;
+        },
+      });
+    })();`,
+  });
+  if (typeof preload?.identifier !== 'string' || preload.identifier.length === 0) {
+    throw new Error('Wallet import recovery phrase preload was not installed.');
+  }
+
+  let actionError;
+  try {
+    await page.session.call('Page.reload', { ignoreCache: false });
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+      const found = await page.evaluate(
+        `Boolean(document.querySelector(${JSON.stringify(selector)}))`,
+      ).catch(() => false);
+      if (found) break;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    await setSecretInput(page, selector, value);
+    const pasted = await page.evaluate(`(() => {
+      const bridge = globalThis[Symbol.for(${JSON.stringify(bridgeKey)})];
+      return typeof bridge === 'function' && bridge(${JSON.stringify(selector)});
+    })()`);
+    if (!pasted) throw new Error('Wallet import Secret Recovery Phrase input was not found.');
+  } catch (error) {
+    actionError = error;
+  }
+
+  const cleanupErrors = [];
+  try {
+    const removed = await page.evaluate(`(() => {
+      const key = Symbol.for(${JSON.stringify(bridgeKey)});
+      delete globalThis[key];
+      return !(key in globalThis);
+    })()`);
+    if (removed !== true) cleanupErrors.push('page bridge removal was not confirmed');
+  } catch (error) {
+    cleanupErrors.push(error instanceof Error ? error.message : String(error));
+  }
+  try {
+    await page.session.call('Page.removeScriptToEvaluateOnNewDocument', {
+      identifier: preload.identifier,
+    });
+  } catch (error) {
+    cleanupErrors.push(error instanceof Error ? error.message : String(error));
+  }
+  if (cleanupErrors.length > 0) {
+    throw new Error(`Wallet import recovery phrase bridge cleanup failed: ${cleanupErrors.join('; ')}.`);
+  }
+  if (actionError) throw actionError;
+}

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

@@ -1,5 +1,9 @@
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
-import { selectWalletAccountExpression } from './state.mjs';
+import {
+  listWalletAccountsExpression,
+  readWalletStateExpression,
+  selectWalletAccountExpression,
+} from './state.mjs';
 
 function normalize(value) {
   return String(value ?? '').toLowerCase();
@@ -12,10 +16,70 @@ 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(selectWalletAccountExpression({
-    address: requestedAddress,
-    id: requestedId,
-    name: requestedName,
-  }), { awaitPromise: true });
-  return { action: input.action, selected, proofPath: 'extension-account-selection' };
+  try {
+    const selected = await page.evaluate(selectWalletAccountExpression({
+      address: requestedAddress,
+      id: requestedId,
+      name: requestedName,
+    }), { awaitPromise: true });
+    return { action: input.action, selected, proofPath: 'extension-background-account-selection' };
+  } catch (error) {
+    if (!String(error?.message ?? error).includes('submitRequestToBackground is unavailable')) throw error;
+  }
+
+  let searchAddress = requestedAddress;
+  if (!searchAddress) {
+    const listed = await page.evaluate(listWalletAccountsExpression('all'), { awaitPromise: true });
+    const account = listed.accounts.find((entry) =>
+      (requestedId && entry.id === requestedId) ||
+      (requestedName && entry.name === requestedName));
+    searchAddress = normalize(account?.address);
+  }
+  if (!searchAddress) throw new Error('Requested account does not have a searchable EVM address.');
+
+  await page.navigateHash('#/account-list');
+  const searchSelector = 'input[data-testid="multichain-account-list-search"], [data-testid="multichain-account-list-search"] input';
+  await page.waitForSelector(searchSelector);
+  await page.setInput(searchSelector, searchAddress);
+
+  const rowDeadline = Date.now() + 15_000;
+  let row;
+  while (Date.now() <= rowDeadline) {
+    row = await page.evaluate(`(() => {
+      const rows = [...document.querySelectorAll('.multichain-account-cell[data-testid^="multichain-account-cell-"]')]
+        .filter((element) => {
+          const style = getComputedStyle(element);
+          const rect = element.getBoundingClientRect();
+          return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+        });
+      return {
+        count: rows.length,
+        testId: rows.length === 1 ? rows[0].getAttribute('data-testid') : null,
+        label: rows.length === 1 ? String(rows[0].innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500) : null,
+      };
+    })()`);
+    if (row.count === 1 && row.testId) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (row?.count !== 1 || !row.testId) {
+    throw new Error(`Expected one visible account for the requested address, observed ${row?.count ?? 0}.`);
+  }
+  await page.click(`[data-testid=${JSON.stringify(row.testId)}]`);
+
+  const selectedDeadline = Date.now() + 15_000;
+  let selected;
+  while (Date.now() <= selectedDeadline) {
+    const state = await page.evaluate(readWalletStateExpression(), { awaitPromise: true });
+    selected = state.selectedAccount;
+    if (normalize(selected?.address) === searchAddress) {
+      return {
+        action: input.action,
+        selected,
+        visibleAccount: row,
+        proofPath: 'trusted-pointer-visible-ui',
+      };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Visible account selection did not select ${searchAddress}.`);
 }));