@deeeed/metamask-harness 0.38.1 → 0.40.0

package/library/actions/extension/platform/cdp.mjs

@@ -59,12 +59,13 @@ function cdpPort(input) {
   return port;
 }
 
-export function extensionTarget(targets, extensionId = null) {
+export function extensionTarget(targets, extensionId = null, cdpTargetId = null) {
   const candidates = (Array.isArray(targets) ? targets : []).filter((target) => {
     if (target?.type !== 'page') return false;
     if (!String(target?.url ?? '').startsWith('chrome-extension://')) return false;
     if (!String(target.url).includes('/home.html') && !String(target.url).includes('/sidepanel.html')) return false;
     if (extensionId && extensionIdFromTarget(target) !== extensionId) return false;
+    if (cdpTargetId && target.id !== cdpTargetId) return false;
     return Boolean(target.webSocketDebuggerUrl);
   });
   const home = candidates.find((target) =>
@@ -663,15 +664,24 @@ async function openExtensionHomePage(port, extensionId) {
 
 async function ensureExtensionTarget(input, port) {
   let launch = null;
+  const trustedTargetId = input.context?.trustedMutation?.cdpTargetId ?? null;
+  if (trustedTargetId !== null && !/^[A-Za-z0-9._:-]{1,128}$/u.test(String(trustedTargetId))) {
+    throw new Error('Funded Extension action has no valid trusted CDP target id.');
+  }
   try {
     const targets = await jsonGet(`http://127.0.0.1:${port}/json/list`);
     const expectedExtensionId = await extensionIdFromFile(input.context.projectRoot);
     const target =
-      (expectedExtensionId ? extensionTarget(Array.isArray(targets) ? targets : [], expectedExtensionId) : null) ??
-      extensionTarget(Array.isArray(targets) ? targets : []);
+      (expectedExtensionId
+        ? extensionTarget(Array.isArray(targets) ? targets : [], expectedExtensionId, trustedTargetId)
+        : null) ??
+      extensionTarget(Array.isArray(targets) ? targets : [], null, trustedTargetId);
     if (target?.webSocketDebuggerUrl) return { target, launch };
+    if (trustedTargetId) {
+      throw new Error(`Trusted Extension CDP target ${trustedTargetId} is unavailable on port ${port}.`);
+    }
   } catch (error) {
-    if (!autolaunchEnabled(input)) throw error;
+    if (trustedTargetId || !autolaunchEnabled(input)) throw error;
   }
   if (!autolaunchEnabled(input)) {
     throw new Error(`No extension page target found on CDP port ${port}. Launch the extension runtime first, or set METAMASK_RECIPE_EXTENSION_AUTOLAUNCH=1 to launch an existing dist/chrome.`);
@@ -707,29 +717,98 @@ export async function writeOutput(input, output) {
   await writeFile(input.outputPath, `${JSON.stringify(output, null, 2)}\n`);
 }
 
+export function extensionActionOutput(result, { port, target, launch, browserVersion }) {
+  const identity = extensionRuntimeIdentity({ port, target, browserVersion });
+  return {
+    ...result,
+    cdpPort: identity.cdpPort,
+    targetUrl: target.url,
+    runtimeLaunch: launch,
+    cdpTargetId: identity.cdpTargetId,
+    runtimeSessionId: identity.runtimeSessionId,
+  };
+}
+
+export function extensionRuntimeIdentity({ port, target, browserVersion }) {
+  const cdpTargetId = String(target?.id ?? '');
+  if (!/^[A-Za-z0-9._:-]{1,128}$/u.test(cdpTargetId)) {
+    throw new Error('Selected Extension CDP target has no valid stable target id.');
+  }
+  let runtimeSessionId = '';
+  try {
+    const browserSocket = new URL(String(browserVersion?.webSocketDebuggerUrl ?? ''));
+    if (!['ws:', 'wss:'].includes(browserSocket.protocol)) throw new Error('invalid protocol');
+    const match = /^\/devtools\/browser\/([A-Za-z0-9._:-]{1,128})$/u.exec(browserSocket.pathname);
+    runtimeSessionId = match?.[1] ?? '';
+  } catch {
+    runtimeSessionId = '';
+  }
+  if (!runtimeSessionId) {
+    throw new Error('Extension browser CDP endpoint has no valid stable runtime session id.');
+  }
+  return {
+    cdpPort: port,
+    cdpTargetId,
+    runtimeSessionId,
+  };
+}
+
 export async function withExtensionPage(input, callback) {
   const port = cdpPort(input);
   const { target, launch } = await ensureExtensionTarget(input, port);
+  const browserVersion = await jsonGet(`http://127.0.0.1:${port}/json/version`);
   const session = await CdpSession.connect(target.webSocketDebuggerUrl);
   try {
     const extensionId = extensionIdFromTarget(target);
     const origin = `chrome-extension://${extensionId}`;
-    const page = new ExtensionPage(session, origin, target, port);
-    await session.call('Runtime.enable');
-    await session.call('Page.enable');
+    const runtimeIdentity = extensionRuntimeIdentity({ port, target, browserVersion });
+    const page = new ExtensionPage(session, origin, target, port, runtimeIdentity);
+    const recoverVisibleWallet = input.action === 'metamask.wallet.import' && input.node?.method === 'ui';
+    if (recoverVisibleWallet) {
+      try {
+        await session.call('Runtime.enable', {}, { timeoutMs: 1000 });
+      } catch {
+        let route = '<unavailable>';
+        try {
+          await session.call('Page.enable', {}, { timeoutMs: 1000 });
+          const history = await session.call('Page.getNavigationHistory', {}, { timeoutMs: 1000 });
+          const currentUrl = new URL(String(history.entries?.[history.currentIndex]?.url ?? ''));
+          route = currentUrl.hash.split('?')[0]
+            .replace(/0x[0-9a-f]{40}/giu, '<redacted-address>')
+            .slice(0, 200);
+          if (currentUrl.origin !== origin || !['/home.html', '/sidepanel.html'].includes(currentUrl.pathname)) {
+            throw new Error('unexpected visible wallet target');
+          }
+          const navigation = await session.call('Page.navigate', { url: `${origin}${currentUrl.pathname}#/` }, { timeoutMs: 1000 });
+          if (navigation.errorText) throw new Error('visible wallet Home reload failed');
+          await sleep(100);
+          await session.call('Runtime.enable', {}, { timeoutMs: 5000 });
+        } catch {
+          throw new Error(`Visible wallet Runtime did not recover after the same-target Home reload (route ${JSON.stringify(route)}).`);
+        }
+      }
+      await session.call('Page.enable', {}, { timeoutMs: 1000 });
+    } else {
+      await session.call('Runtime.enable');
+      await session.call('Page.enable');
+    }
     const result = await callback(page);
-    return { ...result, cdpPort: port, targetUrl: target.url, runtimeLaunch: launch };
+    return extensionActionOutput(result, { port, target, launch, browserVersion });
   } finally {
     session.close();
   }
 }
 
 export class ExtensionPage extends CdpWebPage {
-  constructor(session, origin, target, port) {
+  constructor(session, origin, target, port, runtimeIdentity) {
     super(session);
     this.origin = origin;
     this.target = target;
     this.port = port;
+    this.runtimeIdentity = Object.freeze({
+      ...runtimeIdentity,
+      extensionOrigin: origin,
+    });
   }
 
   async click(selector) {

package/library/actions/extension/settings/set_basic_functionality.mjs

@@ -27,11 +27,24 @@ async function waitForState(page, enabled, timeoutMs = 15_000) {
   throw new Error(`Basic Functionality did not become ${enabled ? 'enabled' : 'disabled'}.`);
 }
 
-runAdapter(async (input) => withExtensionPage(input, async (page) => {
-  if (typeof input.node?.enabled !== 'boolean') {
-    throw new Error('metamask.settings.set_basic_functionality requires enabled=true or enabled=false.');
+async function waitForEnabledControl(page, selector, timeoutMs = 15_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const enabled = await page.evaluate(`(() => {
+      const element = document.querySelector(${JSON.stringify(selector)});
+      if (!element) return false;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return !element.disabled && element.getAttribute('aria-disabled') !== 'true' &&
+        style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+    })()`);
+    if (enabled) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  const requested = input.node.enabled;
+  throw new Error(`Basic Functionality confirmation did not become enabled: ${selector}.`);
+}
+
+export async function setBasicFunctionality(page, requested, timeoutMs = 15_000) {
   await page.navigateHash('#/settings/privacy');
   await page.waitForSelector(TOGGLE_LABEL_SELECTOR);
   const before = await readState(page);
@@ -42,17 +55,32 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     if (!requested) {
       await page.waitForSelector(dataTestId('basic-configuration-checkbox'));
       await page.click(dataTestId('basic-configuration-checkbox'));
-      await page.click(dataTestId('basic-configuration-modal-toggle-button'));
+      const confirm = dataTestId('basic-configuration-modal-toggle-button');
+      await waitForEnabledControl(page, confirm, timeoutMs);
+      await page.click(confirm);
     }
   }
 
-  const after = await waitForState(page, requested);
+  const after = await waitForState(page, requested, timeoutMs);
   return {
-    action: input.action,
     requested,
     changed: before.enabled !== after.enabled,
     before,
     after,
     proofPath: 'trusted-pointer-visible-ui',
   };
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  if (typeof input.node?.enabled !== 'boolean') {
+    throw new Error('metamask.settings.set_basic_functionality requires enabled=true or enabled=false.');
+  }
+  return {
+    action: input.action,
+    ...await setBasicFunctionality(
+      page,
+      input.node.enabled,
+      Number(input.node?.timeout_ms ?? 15_000),
+    ),
+  };
 }));

package/library/actions/extension/swap_bridge/read_visible_state.mjs

@@ -13,6 +13,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
       'bridge-source-button',
       'bridge-destination-button',
       'bridge__header-settings-button',
+      'slippage-edit-button',
       'prepare-swap-page-error',
       'bridge-missing-price-banner',
     ];
@@ -39,6 +40,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
       route: location.hash,
       title: document.title,
       items,
+      slippage: String(slippageButton?.parentElement?.innerText || '').replace(/\\s+/gu, ' ').trim() || null,
       quote: {
         slippage: String(slippageButton?.parentElement?.innerText || '').replace(/\\s+/gu, ' ').trim() || null,
         networkFee: text('[data-testid="network-fees-sponsored"], [data-testid="network-fees-included"], [data-testid="network-fees"]') || null,
@@ -52,16 +54,10 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   })()`);
   const state = normalizeVisibleSwapBridgeState(raw, options, 'extension');
   const requireQuote = input.node?.require_quote === true;
-  const expectedSlippage = input.node?.expected_slippage == null
-    ? null
-    : Number(input.node.expected_slippage);
   if (requireQuote && (!raw.quote.ctaEnabled || !(Number(state.destinationAmount) > 0)
     || !/^(?:Swap|Bridge)$/iu.test(String(raw.quote.cta)))) {
     throw new Error('Swap quote is not ready for review.');
   }
-  if (expectedSlippage !== null && raw.quote.slippage !== `${expectedSlippage}%`) {
-    throw new Error(`Swap slippage mismatch: expected ${expectedSlippage}%, observed ${raw.quote.slippage ?? 'none'}.`);
-  }
   return {
     action: input.action,
     ...state,

package/library/actions/extension/swap_bridge/set_amount.mjs

@@ -7,6 +7,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   await page.setInput(source, options.amount);
   const deadline = Date.now() + options.timeoutMs;
   let observed;
+  let lastRefreshAt = 0;
   do {
     observed = await page.evaluate(`(() => {
       const value = (testId) => {
@@ -23,13 +24,21 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
         noQuote: document.body.innerText.includes("This trade route isn't available right now"),
       };
     })()`);
-    if (!options.waitForQuote || observed.noQuote || (Number(observed.destinationAmount) > 0 && observed.cta && observed.ctaEnabled)) break;
+    if (!options.waitForQuote || observed.noQuote) break;
+    if (/^(?:Get new quote|Refresh quote)$/iu.test(String(observed.cta))
+      && observed.ctaEnabled && Date.now() - lastRefreshAt >= 1000) {
+      await page.click(dataTestId('bridge-cta-button'));
+      lastRefreshAt = Date.now();
+    }
+    if (Number(observed.destinationAmount) > 0 && observed.ctaEnabled
+      && /^(?:Swap|Bridge)$/iu.test(String(observed.cta))) break;
     await page.evaluate('new Promise((resolve) => setTimeout(resolve, 250))');
   } while (Date.now() < deadline);
   if (observed.sourceAmount !== options.amount) {
     throw new Error(`Swap source amount mismatch: expected ${options.amount}, observed ${observed.sourceAmount}.`);
   }
-  if (options.waitForQuote && !observed.noQuote && !(Number(observed.destinationAmount) > 0 && observed.cta && observed.ctaEnabled)) {
+  if (options.waitForQuote && !observed.noQuote && !(Number(observed.destinationAmount) > 0
+    && observed.ctaEnabled && /^(?:Swap|Bridge)$/iu.test(String(observed.cta)))) {
     throw new Error(`Swap quote did not resolve within ${options.timeoutMs}ms.`);
   }
   return { action: input.action, ...observed, proofPath: 'visible-ui-amount' };

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

@@ -21,6 +21,8 @@ const BACK_CONTROLS = [
   'page-header-back-button',
   'back-button',
 ].map(dataTestId).concat('button[aria-label="Back"]');
+const UI_POLL_MS = 200;
+const PERPS_HOME_SETTLE_MS = 1000;
 
 function text(value) {
   return typeof value === 'string' && value.length > 0 ? value : undefined;
@@ -73,7 +75,7 @@ async function hasVisibleSelector(page, selector) {
 }
 
 async function pauseForUi(page) {
-  await page.evaluate('new Promise((resolve) => setTimeout(resolve, 200))');
+  await page.evaluate(`new Promise((resolve) => setTimeout(resolve, ${UI_POLL_MS}))`);
 }
 
 async function waitForFirstVisible(page, selectors, deadline) {
@@ -180,15 +182,26 @@ export async function openPerpsHome(page, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   let pendingActivation;
   let perpsActivation;
+  let perpsHomeVisibleAt;
 
   while (Date.now() < deadline) {
     if (await hasVisibleSelector(page, tutorialSkip)) {
       await activateSemanticControl(page, tutorialSkip);
       steps.push(tutorialSkip);
+      perpsHomeVisibleAt = undefined;
       await pauseForUi(page);
       continue;
     }
     if (await hasVisibleSelector(page, perpsHome)) {
+      perpsHomeVisibleAt ??= Date.now();
+      const settleUntil = Math.min(
+        perpsHomeVisibleAt + PERPS_HOME_SETTLE_MS,
+        deadline - UI_POLL_MS,
+      );
+      if (Date.now() + UI_POLL_MS <= settleUntil) {
+        await pauseForUi(page);
+        continue;
+      }
       return {
         ...(perpsActivation ? { navigation: perpsActivation, selector: bottomNav } : {}),
         method: 'visible-ui',
@@ -196,6 +209,7 @@ export async function openPerpsHome(page, timeoutMs) {
         steps,
       };
     }
+    perpsHomeVisibleAt = undefined;
     if (await hasVisibleSelector(page, bottomNav)) {
       if (!perpsActivation) {
         perpsActivation = await activateSemanticControl(page, bottomNav);
@@ -347,15 +361,41 @@ export async function openPerpsMarketList(page, timeoutMs) {
   }
   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()) });
+  const tutorialSkip = dataTestId('perps-tutorial-skip-button');
+  if (!(await waitForFirstVisible(page, [explore], deadline))) {
+    throw new Error('Perps Explore Markets did not become visible before timeout.');
+  }
+  let navigation = await activateSemanticControl(page, explore);
+  const destination = await waitForFirstVisible(page, [marketList, tutorialSkip], deadline);
+  const steps = [...home.steps, explore];
+  if (destination === tutorialSkip) {
+    await activateSemanticControl(page, tutorialSkip);
+    steps.push(tutorialSkip);
+    let exploreReady = false;
+    while (Date.now() < deadline) {
+      if (!(await hasVisibleSelector(page, tutorialSkip)) && await hasVisibleSelector(page, explore)) {
+        exploreReady = true;
+        break;
+      }
+      await pauseForUi(page);
+    }
+    if (!exploreReady) {
+      throw new Error('Perps Explore Markets did not become visible after dismissing the tutorial.');
+    }
+    navigation = await activateSemanticControl(page, explore);
+    steps.push(explore);
+    if (!(await waitForFirstVisible(page, [marketList], deadline))) {
+      throw new Error('Perps market list did not become visible after dismissing the tutorial.');
+    }
+  } else if (destination !== marketList) {
+    throw new Error('Perps market list did not become visible before timeout.');
+  }
   return {
     navigation,
     method: 'visible-ui',
     href: await currentHref(page),
     selector: explore,
-    steps: [...home.steps, explore],
+    steps,
   };
 }
 

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

@@ -2,6 +2,10 @@ import { resolveWalletImportCredentials, validateWalletImportOptions, walletImpo
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import { pasteSecretRecoveryPhrase, setSecretInput } from './secret-input.mjs';
 import { readWalletStateExpression } from './state.mjs';
+import {
+  dismissVisibleOnboardingCompletion,
+  ensureVisibleSelectedAccount,
+} from './visible-session.mjs';
 
 const SELECTORS = {
   importWallet: '[data-testid="onboarding-import-wallet"]',
@@ -16,6 +20,8 @@ const SELECTORS = {
   metricsCheckbox: '[data-testid="metametrics-checkbox"]',
   metricsContinue: '[data-testid="metametrics-i-agree"]',
   complete: '[data-testid="onboarding-complete-done"]',
+  unlockPassword: '[data-testid="unlock-password"]',
+  unlockSubmit: '[data-testid="unlock-submit"]',
 };
 
 async function hasSelector(page, selector) {
@@ -26,6 +32,20 @@ async function hasSelector(page, selector) {
   }
 }
 
+async function hasVisibleSelector(page, selector) {
+  try {
+    return await 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;
+    })()`);
+  } catch {
+    return false;
+  }
+}
+
 async function waitForSelector(page, selector, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
@@ -73,9 +93,9 @@ async function readState(page) {
 }
 
 async function unlockProfile(page, credentials, timeoutMs) {
-  await setSecretInput(page, 'input[type="password"]', credentials.password);
-  await page.click('button[type="submit"]');
-  await waitForSelectorToDisappear(page, 'input[type="password"]', timeoutMs);
+  await setSecretInput(page, SELECTORS.unlockPassword, credentials.password);
+  await page.click(SELECTORS.unlockSubmit);
+  await waitForSelectorToDisappear(page, SELECTORS.unlockPassword, timeoutMs);
 }
 
 async function importThroughUi(page, input, timeoutMs) {
@@ -127,38 +147,57 @@ async function importThroughUi(page, input, timeoutMs) {
   await waitForSelector(page, SELECTORS.complete, timeoutMs);
   await page.click(SELECTORS.complete);
 
-  const deadline = Date.now() + timeoutMs;
-  let state = await readState(page);
-  while (
-    Date.now() <= deadline &&
-    (!state.completedOnboarding || !state.selectedAccount?.address)
-  ) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    state = await readState(page);
-  }
-  if (!state.completedOnboarding || !state.selectedAccount?.address) {
-    throw new Error('Extension wallet import did not complete onboarding with a selected account.');
-  }
-  if (state.metametricsOptedIn !== metametricsEnabled) {
-    throw new Error(`Extension MetaMetrics preference was ${String(state.metametricsOptedIn)}, expected ${String(metametricsEnabled)}.`);
-  }
-  const actualAddress = String(state.selectedAccount?.address ?? '').toLowerCase();
-  if (actualAddress !== credentials.expectedAddress) {
-    throw new Error(`Wallet import selected ${actualAddress || 'no address'}, expected ${credentials.expectedAddress}.`);
-  }
-  return { credentials, state, metametricsEnabled };
+  const visibleSession = await ensureVisibleSelectedAccount(page, credentials.expectedAddress, timeoutMs);
+  return { credentials, visibleSession, metametricsEnabled };
 }
 
 runAdapter((input) => withExtensionPage(input, async (page) => {
   validateWalletImportOptions('extension', input.node);
   const method = walletImportMethod(input);
   const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
-  const before = await readState(page);
-  const onboarding = String(before.href ?? '').includes('onboarding');
+  const onboardingRoute = await page.evaluate(`(() => String(location.hash || '').includes('onboarding'))()`);
+  const onboarding = onboardingRoute && (
+    await hasVisibleSelector(page, SELECTORS.importWallet) ||
+    await hasVisibleSelector(page, SELECTORS.importWithSrp) ||
+    await hasVisibleSelector(page, SELECTORS.srp)
+  );
 
-  if (method === 'ui' && !onboarding) {
-    throw new Error('metamask.wallet.import method=ui requires a fresh Extension onboarding profile.');
+  if (method === 'ui') {
+    if (!onboarding) {
+      const credentials = await resolveWalletImportCredentials(input);
+      const completionTriggered = await dismissVisibleOnboardingCompletion(page);
+      const locked = await hasVisibleSelector(page, SELECTORS.unlockPassword);
+      if (locked) await unlockProfile(page, credentials, timeoutMs);
+      const visibleSession = await ensureVisibleSelectedAccount(page, credentials.expectedAddress, timeoutMs);
+      return {
+        action: input.action,
+        method: 'ui-visible-session',
+        credentialSource: credentials.source,
+        credentialSourceName: credentials.sourceName,
+        completedOnboarding: true,
+        completionTriggered,
+        ...visibleSession,
+        proofPath: 'extension-visible-wallet-session',
+      };
+    }
+    const imported = await importThroughUi(page, input, timeoutMs);
+    return {
+      action: input.action,
+      method: 'ui-import',
+      credentialSource: imported.credentials.source,
+      credentialSourceName: imported.credentials.sourceName,
+      selectedIdentitySha256: imported.visibleSession.selectedIdentitySha256,
+      selectedAddressMatched: imported.visibleSession.selectedAddressMatched,
+      selectionPerformed: imported.visibleSession.selectionPerformed,
+      completedOnboarding: true,
+      metametricsEnabled: imported.metametricsEnabled,
+      interests: [],
+      redacted: true,
+      proofPath: 'extension-visible-onboarding-import',
+    };
   }
+
+  const before = await readState(page);
   if (onboarding) {
     if (method === 'profile') {
       throw new Error('metamask.wallet.import method=profile found a fresh Extension onboarding profile.');
@@ -169,8 +208,10 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
       method: 'ui-import',
       credentialSource: imported.credentials.source,
       credentialSourceName: imported.credentials.sourceName,
-      selectedAddress: imported.state.selectedAccount.address,
-      completedOnboarding: imported.state.completedOnboarding,
+      selectedIdentitySha256: imported.visibleSession.selectedIdentitySha256,
+      selectedAddressMatched: imported.visibleSession.selectedAddressMatched,
+      selectionPerformed: imported.visibleSession.selectionPerformed,
+      completedOnboarding: true,
       metametricsEnabled: imported.metametricsEnabled,
       interests: [],
       redacted: true,

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

@@ -3,6 +3,7 @@ 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');
+const HOME = dataTestId('bottom-nav-home');
 
 async function visible(page, selector) {
   return page.evaluate(`(() => {
@@ -14,9 +15,61 @@ async function visible(page, selector) {
   })()`);
 }
 
-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);
+async function clickUncovered(page, selector, deadline) {
+  let point;
+  while (!point && Date.now() < deadline) {
+    point = await page.evaluate(`(() => {
+      const element = document.querySelector(${JSON.stringify(selector)});
+      if (!element) return null;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) return null;
+      const offsets = [[0.25, 0.25], [0.25, 0.5], [0.25, 0.75], [0.5, 0.75], [0.75, 0.75]];
+      for (const [xOffset, yOffset] of offsets) {
+        const x = rect.left + (rect.width * xOffset);
+        const y = rect.top + (rect.height * yOffset);
+        const hit = document.elementFromPoint(x, y);
+        if (hit === element || element.contains(hit)) return { x, y };
+      }
+      return null;
+    })()`);
+    if (!point) await page.evaluate('new Promise((resolve) => setTimeout(resolve, 100))');
+  }
+  if (!point) throw new Error(`Wallet control has no uncovered pointer target: ${selector}`);
+  await page.session.call('Input.dispatchMouseEvent', { type: 'mouseMoved', x: point.x, y: point.y });
+  await page.session.call('Input.dispatchMouseEvent', {
+    type: 'mousePressed',
+    x: point.x,
+    y: point.y,
+    button: 'left',
+    buttons: 1,
+    clickCount: 1,
+  });
+  await page.session.call('Input.dispatchMouseEvent', {
+    type: 'mouseReleased',
+    x: point.x,
+    y: point.y,
+    button: 'left',
+    buttons: 0,
+    clickCount: 1,
+  });
+}
+
+export async function lockWallet(page, timeoutMs = 15_000) {
+  const deadline = Date.now() + timeoutMs;
+  if (!(await visible(page, LOCK))) {
+    if (!(await visible(page, MENU))) {
+      if (!(await visible(page, HOME))) {
+        throw new Error('Wallet lock requires a visible Home control when the global menu is unavailable.');
+      }
+      await page.click(HOME);
+      while (!(await visible(page, MENU))) {
+        if (Date.now() >= deadline) throw new Error('Wallet Home did not expose the account options menu.');
+        await page.evaluate('new Promise((resolve) => setTimeout(resolve, 100))');
+      }
+    }
+    await clickUncovered(page, MENU, deadline);
+  }
   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))');
@@ -27,9 +80,13 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     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',
   };
-}));
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => ({
+  action: input.action,
+  ...await lockWallet(page, Number(input.node?.timeout_ms ?? 15_000)),
+})));