@deeeed/metamask-harness 0.39.0 → 0.40.0

package/library/actions/extension/wallet/visible-session.mjs

@@ -0,0 +1,218 @@
+import { createHash } from 'node:crypto';
+
+const ACCOUNT_SEARCH = 'input[data-testid="multichain-account-list-search"], [data-testid="multichain-account-list-search"] input';
+const ONBOARDING_COMPLETE = '[data-testid="onboarding-complete-done"]';
+const HOME_BOUNDARY = '[data-testid="bottom-nav-home"], [data-testid="account-overview__asset-tab"]';
+
+async function hasVisibleSelector(page, selector, deadline) {
+  const expression = `(() => {
+    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;
+  })()`;
+  if (deadline === undefined) return page.evaluate(expression);
+  const result = await page.session.call('Runtime.evaluate', {
+    expression,
+    awaitPromise: true,
+    returnByValue: true,
+  }, { timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())) });
+  if (result.exceptionDetails) throw new Error('Visible wallet selector probe failed.');
+  return result.result?.value === true;
+}
+
+export async function dismissVisibleOnboardingCompletion(page) {
+  if (!(await hasVisibleSelector(page, ONBOARDING_COMPLETE))) return false;
+  await page.click(ONBOARDING_COMPLETE);
+  return true;
+}
+
+function accountProbeAddress(expectedAddress) {
+  const replacement = expectedAddress.endsWith('0') ? '1' : '0';
+  return `${expectedAddress.slice(0, -1)}${replacement}`;
+}
+
+async function currentRoute(page, deadline) {
+  const history = await page.session.call('Page.getNavigationHistory', {}, {
+    timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())),
+  });
+  const url = String(history.entries?.[history.currentIndex]?.url ?? '');
+  const route = new URL(url).hash.split('?')[0];
+  return route.replace(/0x[0-9a-f]{40}/giu, '<redacted-address>').slice(0, 200);
+}
+
+async function routeError(page, message, deadline) {
+  let route = '<deadline-expired>';
+  if (Date.now() < deadline) {
+    try {
+      route = await currentRoute(page, deadline);
+    } catch {
+      route = '<unavailable>';
+    }
+  }
+  return new Error(`${message} (route ${JSON.stringify(route)}).`);
+}
+
+async function visibleAccountMatch(page, deadline) {
+  const result = await page.session.call('Runtime.evaluate', {
+    expression: `(() => {
+    const input = document.querySelector(${JSON.stringify(ACCOUNT_SEARCH)});
+    const query = String(input?.value || '').trim().toLowerCase();
+    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;
+      });
+    const row = rows.length === 1 ? rows[0] : null;
+    const accountName = String(row?.querySelector('.multichain-account-cell__account-name')?.textContent || '')
+      .trim()
+      .toLowerCase();
+    return {
+      query,
+      count: rows.length,
+      testId: row?.getAttribute('data-testid') || null,
+      selected: Boolean(row?.classList.contains('is-selected')),
+      addressMatchedBySearch: Boolean(/^0x[0-9a-f]{40}$/u.test(query) && !accountName.includes(query)),
+    };
+  })()`,
+    awaitPromise: true,
+    returnByValue: true,
+  }, { timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())) });
+  if (result.exceptionDetails || !result.result?.value) {
+    throw new Error('Visible wallet account probe failed.');
+  }
+  return result.result.value;
+}
+
+async function navigateHashThroughPage(page, hash, deadline) {
+  const pathname = new URL(String(page.target?.url ?? `${page.origin}/home.html`)).pathname;
+  const walletPath = pathname === '/sidepanel.html' ? pathname : '/home.html';
+  await page.session.call('Page.navigate', { url: `${page.origin}${walletPath}${hash}` }, {
+    timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())),
+  });
+}
+
+async function withinDeadline(promise, deadline) {
+  const timeoutMs = Math.max(1, deadline - Date.now());
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('Visible wallet stage exceeded its shared deadline.')), timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function leavePerpsForWalletHome(page, deadline) {
+  if (!(await currentRoute(page, deadline)).includes('/perps')) return;
+  while (Date.now() <= deadline) {
+    try {
+      await navigateHashThroughPage(page, '#/', deadline);
+      if (await hasVisibleSelector(page, HOME_BOUNDARY, deadline)) return;
+    } catch {
+      // Retry within the shared deadline while the authenticated Home surface settles.
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw await routeError(page, 'Visible wallet session did not reach Home before account-list navigation', deadline);
+}
+
+async function openAccountList(page, deadline) {
+  await leavePerpsForWalletHome(page, deadline);
+  while (Date.now() <= deadline) {
+    try {
+      await navigateHashThroughPage(page, '#/account-list', deadline);
+      if (await hasVisibleSelector(page, ACCOUNT_SEARCH, deadline)) return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  throw await routeError(page, 'Visible wallet session did not reach the authenticated account list', deadline);
+}
+
+async function proveAddressSearchControl(page, expectedAddress, deadline) {
+  const probeAddress = accountProbeAddress(expectedAddress);
+  try {
+    await withinDeadline(page.setInput(ACCOUNT_SEARCH, probeAddress), deadline);
+  } catch {
+    throw await routeError(page, 'Visible wallet account search could not enter the alternate-address control', deadline);
+  }
+  let consecutiveEmpty = 0;
+  while (Date.now() <= deadline) {
+    let observed;
+    try {
+      observed = await visibleAccountMatch(page, deadline);
+    } catch {
+      throw await routeError(page, 'Visible wallet alternate-address result did not become readable', deadline);
+    }
+    if (observed.query === probeAddress && observed.count === 0) {
+      consecutiveEmpty += 1;
+      if (consecutiveEmpty === 2) return;
+    } else {
+      consecutiveEmpty = 0;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw await routeError(page, 'Visible wallet account search did not reject the alternate address control', deadline);
+}
+
+async function queryExpectedAccount(page, expectedAddress, deadline, requireSelected) {
+  await proveAddressSearchControl(page, expectedAddress, deadline);
+  try {
+    await withinDeadline(page.setInput(ACCOUNT_SEARCH, expectedAddress), deadline);
+  } catch {
+    throw await routeError(page, 'Visible wallet account search could not enter the derived release identity', deadline);
+  }
+  let observed;
+  while (Date.now() <= deadline) {
+    try {
+      observed = await visibleAccountMatch(page, deadline);
+    } catch {
+      throw await routeError(page, 'Visible wallet derived-account result did not become readable', deadline);
+    }
+    const exactMatch = observed.query === expectedAddress &&
+      observed.count === 1 &&
+      observed.testId &&
+      observed.addressMatchedBySearch;
+    if (exactMatch && (!requireSelected || observed.selected)) return observed;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (requireSelected) {
+    throw await routeError(page, 'Visible wallet session did not converge to the derived release account', deadline);
+  }
+  throw await routeError(page, 'Visible wallet session did not resolve the derived release account to one rendered account row', deadline);
+}
+
+export async function ensureVisibleSelectedAccount(page, expectedAddress, timeoutMs) {
+  if (!/^0x[0-9a-f]{40}$/u.test(expectedAddress)) {
+    throw new Error('Visible wallet session requires a derived EVM account address.');
+  }
+  const deadline = Date.now() + timeoutMs;
+  await openAccountList(page, deadline);
+  const initial = await queryExpectedAccount(page, expectedAddress, deadline, false);
+  let selectionPerformed = false;
+  if (!initial.selected) {
+    selectionPerformed = true;
+    try {
+      await withinDeadline(page.click(`[data-testid=${JSON.stringify(initial.testId)}]`), deadline);
+    } catch {
+      throw await routeError(page, 'Visible wallet session could not select the derived release account', deadline);
+    }
+  }
+
+  await openAccountList(page, deadline);
+  await queryExpectedAccount(page, expectedAddress, deadline, true);
+  return {
+    selectedIdentitySha256: createHash('sha256').update(expectedAddress).digest('hex'),
+    selectedAddressMatched: true,
+    selectionPerformed,
+    accountSurface: 'visible-account-list',
+    redacted: true,
+  };
+}

package/library/actions/mobile/ui/native-navigation.mjs

@@ -22,6 +22,8 @@ const IDS = {
   tutorialSkip: 'perps-tutorial-skip-button',
   modeLite: 'perps-mode-selection-lite-option',
   modePro: 'perps-mode-selection-pro-option',
+  modeToggleLite: 'perps-mode-toggle-lite',
+  modeTogglePro: 'perps-mode-toggle-pro',
   market: 'perps-market-details-view',
   marketBack: 'perps-market-header-back-button',
   marketSubtitle: 'perps-market-header-subtitle',
@@ -109,6 +111,8 @@ export async function navigateOpaqueMobile(input, destination) {
       observedScreen = 'wallet-home';
     } else if (destination.page === 'swap') {
       observedScreen = await navigateSwap({ identifiers, press, wait, back });
+    } else if (destination.page === 'perps') {
+      observedScreen = await navigatePerpsHome({ identifiers, press, wait, back, timeoutMs: Number(input.node?.timeout_ms ?? 30_000), perpsMode });
     } else if (destination.page === 'perps-market-list') {
       observedScreen = await navigatePerpsMarketList({ identifiers, press, wait, back, timeoutMs: Number(input.node?.timeout_ms ?? 30_000), perpsMode });
     } else {
@@ -265,6 +269,47 @@ async function navigatePerps({ identifiers, press, wait, back, timeoutMs, perpsM
   return waitForPerpsDestination(identifiers, timeoutMs, press, perpsMode);
 }
 
+async function navigatePerpsHome({ identifiers, press, wait, back, timeoutMs, perpsMode }) {
+  const deadline = Date.now() + timeoutMs;
+  let observed = await navigatePerps({ identifiers, press, wait, back, timeoutMs, perpsMode });
+  while (Date.now() <= deadline) {
+    let ids = await identifiers();
+    if (ids.has(IDS.perpsHome)) return IDS.perpsHome;
+    if (perpsMode === 'lite' && ids.has(IDS.proMarket)) {
+      if (!ids.has(IDS.modeTogglePro)) {
+        throw new Error('Opaque Mobile navigation reached Pro market details without the visible Pro mode control.');
+      }
+      await press(IDS.modeTogglePro);
+      observed = await waitForPerpsMode(identifiers, press, deadline, 'lite');
+      ids = await identifiers();
+    }
+    if (ids.has(IDS.market)) {
+      await press(IDS.marketBack);
+    } else if (ids.has(IDS.marketList)) {
+      await press(IDS.marketListClose);
+    } else {
+      observed = await navigatePerps({ identifiers, press, wait, back, timeoutMs: Math.max(1, deadline - Date.now()), perpsMode });
+    }
+  }
+  throw new Error(`Opaque Mobile navigation reached ${observed}, but did not converge to Perps Home.`);
+}
+
+async function waitForPerpsMode(identifiers, press, deadline, perpsMode) {
+  let selected = false;
+  while (Date.now() <= deadline) {
+    const ids = await identifiers();
+    const expected = perpsMode === 'pro' ? IDS.proMarket : IDS.market;
+    if (ids.has(expected)) return expected;
+    const option = perpsMode === 'pro' ? IDS.modePro : IDS.modeLite;
+    if (!selected && ids.has(option)) {
+      await press(option);
+      selected = true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error(`Opaque Mobile navigation did not visibly switch Perps to ${perpsMode} mode.`);
+}
+
 async function navigatePerpsMarketList({ identifiers, press, wait, back, timeoutMs, perpsMode }) {
   let ids = await identifiers();
   if (ids.has(IDS.marketList)) return IDS.marketList;

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

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -45,6 +46,18 @@ function selectedAddress(status, input) {
   return String(selectedEntry(status, input)?.account?.address ?? '').toLowerCase();
 }
 
+export function redactedSelectedIdentity(expectedAddress, actualAddress) {
+  const expected = String(expectedAddress ?? '').toLowerCase();
+  const actual = String(actualAddress ?? '').toLowerCase();
+  if (!expected || actual !== expected) {
+    throw new Error('Mobile wallet import did not visibly select the expected account.');
+  }
+  return {
+    selectedIdentitySha256: createHash('sha256').update(expected).digest('hex'),
+    selectedAddressMatched: true,
+  };
+}
+
 function walletReady(observed, input) {
   const route = String(selectedEntry(observed, input)?.route?.name ?? '');
   return Boolean(
@@ -199,9 +212,7 @@ async function importThroughUi(input, timeoutMs, options) {
     observed = await status(input);
   }
   const actualAddress = selectedAddress(observed, input);
-  if (actualAddress !== credentials.expectedAddress) {
-    throw new Error(`Wallet import selected ${actualAddress || 'no address'}, expected ${credentials.expectedAddress}.`);
-  }
+  redactedSelectedIdentity(credentials.expectedAddress, actualAddress);
   const { consent } = await setMobileConsent(
     input,
     metametricsEnabled,
@@ -255,7 +266,7 @@ runAdapter(async (input) => {
       method: proof.alreadyReady ? 'native-profile' : 'native-ui-import',
       credentialSource: credentials.source,
       credentialSourceName: credentials.sourceName,
-      selectedAddress: proof.selectedAddress,
+      ...redactedSelectedIdentity(credentials.expectedAddress, proof.selectedAddress),
       metametricsRequested: metametricsEnabled,
       biometricsRequested: biometricsEnabled,
       biometricPromptDismissed: proof.biometricPromptDismissed ?? false,
@@ -294,7 +305,7 @@ runAdapter(async (input) => {
       method: 'ui-import',
       credentialSource: imported.credentials.source,
       credentialSourceName: imported.credentials.sourceName,
-      selectedAddress: importedEntry.account.address,
+      ...redactedSelectedIdentity(imported.credentials.expectedAddress, importedEntry.account.address),
       route: importedEntry.route ?? null,
       metametricsEnabled: imported.metametricsEnabled,
       interests: imported.interests,
@@ -311,16 +322,12 @@ runAdapter(async (input) => {
       ...(route === 'Login' ? { password: credentials.password } : {}),
     },
   });
-  const actualAddress = String(unlocked.account?.address ?? address).toLowerCase();
-  if (actualAddress !== credentials.expectedAddress) {
-    throw new Error(`Wallet profile selected ${actualAddress || 'no address'}, expected ${credentials.expectedAddress}.`);
-  }
   return {
     action: input.action,
     method: 'profile',
     credentialSource: credentials.source,
     credentialSourceName: credentials.sourceName,
-    selectedAddress: unlocked.account?.address ?? address,
+    ...redactedSelectedIdentity(credentials.expectedAddress, unlocked.account?.address ?? address),
     route: unlocked.route ?? entry.route ?? null,
     redacted: true,
     proofPath: 'mobile-fixture-profile',

package/library/actions/mobile/wallet/native-ui.mjs

@@ -33,6 +33,8 @@ const TEST_IDS = {
   perpsHomeBack: 'perps-home-back-button',
   perpsMarket: 'perps-market-details-view',
   perpsMarketBack: 'perps-market-header-back-button',
+  perpsProMarket: 'perps-pro-market-scroll-view',
+  perpsProMarketBack: 'perps-pro-market-header-back-button',
   hamburger: 'navbar-hamburger-menu-button',
   lock: 'lock-menu-item',
   confirmLock: 'android:id/button1',
@@ -343,7 +345,12 @@ function nativeSession(input) {
         ) {
           return state;
         }
-        if (state.visible.has(TEST_IDS.perpsMarketBack)) {
+        if (
+          state.visible.has(TEST_IDS.perpsProMarket) &&
+          state.visible.has(TEST_IDS.perpsProMarketBack)
+        ) {
+          await this.press(TEST_IDS.perpsProMarketBack, timeoutMs);
+        } else if (state.visible.has(TEST_IDS.perpsMarketBack)) {
           await this.press(TEST_IDS.perpsMarketBack, timeoutMs);
         } else if (state.visible.has(TEST_IDS.perpsHomeBack)) {
           await this.press(TEST_IDS.perpsHomeBack, timeoutMs);
@@ -408,6 +415,13 @@ function nativeSession(input) {
         if (!walletVisible) stableWalletCaptures = 0;
         if (visible.has(TEST_IDS.metricsContinue)) {
           if (!options.metametricsEnabled) {
+            if (!visible.has(TEST_IDS.metricsCheckbox)) {
+              await this.scroll('down', options.timeoutMs);
+              const afterScroll = await this.screenState();
+              if (!afterScroll.visible.has(TEST_IDS.metricsCheckbox)) {
+                throw new Error('Mobile MetaMetrics opt-out checkbox remained unavailable after one bounded onboarding scroll.');
+              }
+            }
             await this.press(TEST_IDS.metricsCheckbox, options.timeoutMs);
           }
           await this.press(TEST_IDS.metricsContinue, options.timeoutMs);
@@ -477,6 +491,12 @@ function nativeSession(input) {
       timeout_ms: timeoutMs,
       settle: false,
     }),
+    scroll: (direction, timeoutMs) => execute('ui.scroll', {
+      direction,
+      amount: 0.75,
+      timeout_ms: timeoutMs,
+      settle: false,
+    }),
     async waitForWallet(timeoutMs) {
       const deadline = Date.now() + timeoutMs;
       let stableCaptures = 0;

package/library/actions/shared/perps/visible-state.mjs

@@ -87,6 +87,7 @@ export function resolveVisibleStateOptions(node = {}) {
     maximumOrderCount: boundedInteger(node.maximum_order_count, 200, 0, 200, 'maximum_order_count'),
     minimumActivityCount: boundedInteger(node.minimum_activity_count, 0, 0, 200, 'minimum_activity_count'),
     requireNoHorizontalOverflow: node.require_no_horizontal_overflow === true,
+    requireNoControlOverlap: node.require_no_control_overlap === true,
     requireFeatures: stringList(node.require_features, 'require_features').map((feature) => {
       if (!FEATURES.has(feature)) {
         throw new Error(
@@ -143,6 +144,9 @@ function marketFromTestId(testId) {
 
 function classifySurface(route, testIds) {
   const joined = [...testIds].join('\n');
+  if (/confirm-transaction\/.*[?&]goBackTo=%2Fperps-home(?:&|$)/u.test(route)) {
+    return 'funds';
+  }
   if (/\/perps\/trade\//u.test(route)) {
     return 'order-entry';
   }
@@ -178,7 +182,7 @@ function visibleFeatures(items) {
   const short = has(/(?:short-cta-button|direction-short|market-details-short-button)$/u);
   return {
     activity: has(/^(?:transaction-card-|perps-(?:recent-activity|activity))/u),
-    balance: has(/^perps-balance-dropdown/u),
+    balance: has(/^(?:perps-balance-dropdown|perps-market-(?:balance-value|available-balance-text))/u),
     chart: has(/^(?:chart_surface|tv_chart_container)$/u) ||
       has(/perps-(?:candlestick-chart|market-detail-chart|market-details-fullscreen-chart|pro-market-chart)/u),
     'long-short': long && short,
@@ -215,20 +219,20 @@ export function normalizeVisiblePerpsState(raw, options, platform) {
     ...(route ? { route } : {}),
     ...(text(raw.title) ? { title: text(raw.title) } : {}),
     balance: compactEntries(
-      selected(unique, (item) => item.testId.startsWith('perps-balance-dropdown'), 1),
+      selected(unique, (item) => /^(?:perps-balance-dropdown|perps-market-balance-value)$/u.test(item.testId), 1),
       1,
     )[0] ?? null,
     markets: marketItems,
     positions: compactEntries(
-      selected(unique, (item) => /^(?:position-card-|perps-position-row-|perps-position-size-value$|perps-pro-market-position-row-)/u.test(item.testId), options.maxItems),
+      selected(unique, (item) => /^(?:position-card-(?!roe-)|perps-position-row-|perps-position-size-value$|perps-pro-market-position-row-|perps-home-position-card-)/u.test(item.testId), options.maxItems),
       options.maxItems,
     ),
     orders: compactEntries(
-      selected(unique, (item) => /^(?:order-card-|perps-order-row-)/u.test(item.testId), options.maxItems),
+      selected(unique, (item) => /^(?:order-card-|perps-order-row-|perps-home-order-card-)/u.test(item.testId), options.maxItems),
       options.maxItems,
     ),
     activity: compactEntries(
-      selected(unique, (item) => /^(?:transaction-card-|perps-activity-row-)/u.test(item.testId), options.maxItems),
+      selected(unique, (item) => /^(?:transaction-card-|transaction-item(?:-|$)|perps-activity-row-)/u.test(item.testId), options.maxItems),
       options.maxItems,
     ),
     orderEntry: raw.orderEntry && typeof raw.orderEntry === 'object' ? {
@@ -269,6 +273,16 @@ export function normalizeVisiblePerpsState(raw, options, platform) {
       clippedTestIds: Array.isArray(raw.layout.clippedTestIds)
         ? raw.layout.clippedTestIds.map(text).filter(Boolean).slice(0, 100)
         : [],
+      obscuredControlTestIds: Array.isArray(raw.layout.obscuredControlTestIds)
+        ? raw.layout.obscuredControlTestIds.map(text).filter(Boolean).slice(0, 100)
+        : [],
+      overlappingControlPairs: Array.isArray(raw.layout.overlappingControlPairs)
+        ? raw.layout.overlappingControlPairs
+          .filter((pair) => Array.isArray(pair) && pair.length === 2)
+          .map((pair) => pair.map(text))
+          .filter((pair) => pair.every(Boolean))
+          .slice(0, 100)
+        : [],
     } : null,
   };
   assertVisibleState(state, options);
@@ -281,6 +295,12 @@ function assertVisibleState(state, options) {
   )) {
     throw new Error(`Visible Perps layout overflows horizontally: ${JSON.stringify(state.layout)}.`);
   }
+  if (options.requireNoControlOverlap && (
+    !state.layout || state.layout.obscuredControlTestIds.length > 0 ||
+    state.layout.overlappingControlPairs.length > 0
+  )) {
+    throw new Error(`Visible Perps controls overlap: ${JSON.stringify(state.layout)}.`);
+  }
   if (options.surface !== 'auto' && state.surface !== options.surface) {
     throw new Error(
       `Expected visible Perps surface ${options.surface}, but observed ${state.surface}.`,