@deeeed/metamask-harness 0.38.1 → 0.40.0

package/library/actions/mobile/swap_bridge/submit_transaction.mjs

@@ -0,0 +1,141 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+function visibleLabels(snapshot) {
+  return snapshot.nodes
+    .filter((node) => node.visibleToUser !== false)
+    .map(nativeLabel)
+    .filter(Boolean);
+}
+
+function quote(snapshot) {
+  const source = nativeNode(snapshot, 'source-token-area');
+  const destination = nativeNode(snapshot, 'dest-token-area');
+  const sourceAmount = nativeLabel(nativeNode(snapshot, 'source-token-area-input'));
+  const destinationAmount = nativeLabel(nativeNode(snapshot, 'dest-token-area-input'));
+  const button = nativeNode(snapshot, 'bridge-confirm-button');
+  const labels = visibleLabels(snapshot);
+  return {
+    source: nativeLabel(source),
+    destination: nativeLabel(destination),
+    sourceAmount,
+    destinationAmount,
+    buttonEnabled: button?.enabled === true,
+    warning: labels.find((label) => /insufficient|no quotes|unavailable|may fail|might fail/iu.test(label)) ?? null,
+  };
+}
+
+async function waitForQuote(session, expected, timeoutMs) {
+  const deadline = Date.now() + Math.min(timeoutMs, 60_000);
+  let stable = null;
+  let stableSince = 0;
+  while (Date.now() <= deadline) {
+    const snapshot = await session.snapshot();
+    const current = quote(snapshot);
+    const matches = current.source.toUpperCase().includes(expected.sourceSymbol) &&
+      current.destination.toUpperCase().includes(expected.destinationSymbol) &&
+      Number(current.sourceAmount) === expected.amount &&
+      Number(current.destinationAmount) > 0 &&
+      current.buttonEnabled &&
+      !current.warning;
+    const identity = JSON.stringify(current);
+    if (!matches) {
+      stable = null;
+      stableSince = 0;
+    } else if (stable !== identity) {
+      stable = identity;
+      stableSince = Date.now();
+    } else if (Date.now() - stableSince >= 1500) {
+      return current;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error('The Mobile Swap quote did not remain submittable for the requested pair and amount.');
+}
+
+async function pressIfVisible(session, testId, timeoutMs) {
+  if (!nativeNode(await session.snapshot(), testId)) return false;
+  await session.execute('ui.press', { test_id: testId, timeout_ms: timeoutMs, settle: false });
+  return true;
+}
+
+async function waitForTerminalStatus(session, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const snapshot = await session.snapshot();
+    const labels = visibleLabels(snapshot);
+    const failed = labels.find((label) => /^(?:Swap|Bridge) failed$/iu.test(label));
+    if (failed) throw new Error(`Mobile ${failed}.`);
+    const success = labels.find((label) => /^(?:Swap|Bridge) complete$/iu.test(label));
+    if (success) return { snapshot, status: success };
+    if (nativeNode(snapshot, 'price-impact-footer-confirm')) {
+      await session.execute('ui.press', {
+        test_id: 'price-impact-footer-confirm',
+        timeout_ms: Math.max(1, deadline - Date.now()),
+        settle: false,
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  throw new Error('Mobile Swap did not reach a terminal post-trade status.');
+}
+
+runAdapter(async (input) => {
+  const sourceSymbol = String(input.node?.source_symbol ?? '').trim().toUpperCase();
+  const destinationSymbol = String(input.node?.destination_symbol ?? '').trim().toUpperCase();
+  const amount = Number(input.node?.amount);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 300_000);
+  if (!sourceSymbol || !destinationSymbol || !(amount > 0)) {
+    throw new Error('metamask.swap_bridge.submit_transaction requires source_symbol, destination_symbol, and positive amount.');
+  }
+  if (input.node?.confirm_live !== true) {
+    throw new Error('metamask.swap_bridge.submit_transaction requires confirm_live=true.');
+  }
+
+  const session = createNativeSession(input, 'Swap', `submit-${process.pid}`);
+  try {
+    await session.open();
+    const before = await waitForQuote(session, { sourceSymbol, destinationSymbol, amount }, timeoutMs);
+    await session.execute('ui.press', {
+      test_id: 'bridge-confirm-button',
+      timeout_ms: Math.min(timeoutMs, 60_000),
+      settle: false,
+    });
+    const terminal = await waitForTerminalStatus(session, timeoutMs);
+    await pressIfVisible(session, 'post-trade-bottom-sheet-view-activity-button', timeoutMs);
+    let activity = null;
+    const activityDeadline = Date.now() + Math.min(timeoutMs, 60_000);
+    while (Date.now() <= activityDeadline) {
+      const snapshot = await session.snapshot();
+      if (nativeNode(snapshot, 'activity-screen-safe-area-view')) {
+        const labels = visibleLabels(snapshot);
+        activity = labels.find((label) => {
+          const upper = label.toUpperCase();
+          return upper.includes(sourceSymbol) && upper.includes(destinationSymbol);
+        }) ?? labels.find((label) => /swap|bridge/iu.test(label)) ?? null;
+        if (activity) break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 300));
+    }
+    if (!activity) throw new Error('Confirmed Mobile Swap did not appear in visible Activity.');
+    return {
+      action: input.action,
+      sourceSymbol,
+      destinationSymbol,
+      amount,
+      destinationAmount: before.destinationAmount,
+      submitted: true,
+      confirmed: true,
+      status: terminal.status,
+      activity,
+      proofPath: 'native-accessibility-swap-post-trade-activity',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

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

@@ -1,6 +1,9 @@
 import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
 import { createAgentDeviceClient } from 'agent-device';
-import { nativeSessionName } from '../platform/native-session-name.mjs';
+import {
+  nativeAgentDeviceStateDir,
+  nativeSessionName,
+} from '../platform/native-session-name.mjs';
 
 const IDS = {
   wallet: ['wallet-safe-area', 'homepage-container'],
@@ -9,12 +12,18 @@ const IDS = {
   perpsEntry: 'homepage-balance-breakdown-row-perps',
   perpsTradeEntry: 'wallet-perps-action',
   swapTradeEntry: 'wallet-actions-bottom-sheet-swap-button',
+  swapBack: 'button-icon',
   swapSourceInput: 'source-token-area-input',
   swapSourceToken: 'source-token-area',
   swapDestinationToken: 'dest-token-area',
   perpsHome: 'perps-home',
   perpsHomeBack: 'perps-home-back-button',
+  perpsSearch: 'perps-home-search-toggle',
   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',
@@ -23,6 +32,11 @@ const IDS = {
   proMarketList: 'perps-pro-market-header-market-list-button',
   proMarketSubtitle: 'perps-pro-market-header-subtitle',
   marketList: 'perps-market-list',
+  marketListClose: 'perps-market-list-close-button-back-button',
+  tokenList: 'token-list',
+  tokenListBack: 'back-button',
+  tokenDetails: 'token-asset-overview',
+  tokenDetailsBack: 'back-arrow-button',
 };
 
 export async function navigateOpaqueMobile(input, destination) {
@@ -33,8 +47,10 @@ export async function navigateOpaqueMobile(input, destination) {
   }
   const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
   const session = nativeSessionName(env, device, app);
+  const stateDir = nativeAgentDeviceStateDir(env, input.context.projectRoot, device);
   const client = createAgentDeviceClient({
     session,
+    stateDir,
     lockPolicy: 'reject',
     lockPlatform: 'android',
   });
@@ -44,6 +60,7 @@ export async function navigateOpaqueMobile(input, destination) {
     device,
     app,
     session,
+    stateDir,
     client,
   });
   const context = {
@@ -52,9 +69,11 @@ export async function navigateOpaqueMobile(input, destination) {
     artifactsDir: input.context.artifactsDir,
     env,
   };
+  const perpsMode = destination.params?.mode === 'pro' ? 'pro' : 'lite';
   const press = (testId) => transport.execute('ui.press', {
     test_id: testId,
     timeout_ms: Number(input.node?.timeout_ms ?? 30_000),
+    settle: false,
   }, context);
   const wait = (testId) => transport.execute('ui.wait_for', {
     test_id: testId,
@@ -80,7 +99,9 @@ export async function navigateOpaqueMobile(input, destination) {
     forceFull: true,
   });
   const identifiers = async () => new Set(
-    (await snapshot()).nodes.map((node) => String(node.identifier ?? '')),
+    (await snapshot()).nodes
+      .filter((node) => node.visibleToUser !== false)
+      .map((node) => String(node.identifier ?? '')),
   );
 
   try {
@@ -90,26 +111,28 @@ 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) });
+      observedScreen = await navigatePerpsMarketList({ identifiers, press, wait, back, timeoutMs: Number(input.node?.timeout_ms ?? 30_000), perpsMode });
     } else {
       const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
       const initialIds = await identifiers();
       observedScreen = destination.page === 'perps-market' && initialIds.has(IDS.marketList)
-        ? await selectMarket({ destination, identifiers, press, snapshot, timeoutMs })
-        : await navigatePerps({ identifiers, press, wait, back, timeoutMs });
+        ? await selectMarket({ destination, identifiers, press, snapshot, timeoutMs, perpsMode })
+        : await navigatePerps({ identifiers, press, wait, back, timeoutMs, perpsMode });
       if (destination.page === 'perps-market') {
         const market = String(destination.params.market.symbol).toUpperCase();
         const ids = await identifiers();
         if (ids.has(IDS.proMarket) && !await marketMatches(snapshot, market)) {
           await press(IDS.proMarketList);
-          observedScreen = await selectMarket({ destination, identifiers, press, snapshot, timeoutMs });
+          observedScreen = await selectMarket({ destination, identifiers, press, snapshot, timeoutMs, perpsMode });
         } else if (!ids.has(IDS.proMarket) && (!ids.has(IDS.market) || !await marketMatches(snapshot, market))) {
           if (ids.has(IDS.market)) await press(IDS.marketBack);
           await press(`perps-market-row-item-${market}`);
           observedScreen = IDS.market;
         }
-        await waitForPerpsDestination(identifiers, timeoutMs);
+        await waitForPerpsDestination(identifiers, timeoutMs, press, perpsMode);
         if (!await marketMatches(snapshot, market)) {
           throw new Error(`Opaque Mobile navigation opened a different Perps market than ${market}.`);
         }
@@ -147,10 +170,10 @@ async function navigateSwap({ identifiers, press, wait, back }) {
   return IDS.swapSourceInput;
 }
 
-async function selectMarket({ destination, identifiers, press, snapshot, timeoutMs }) {
+async function selectMarket({ destination, identifiers, press, snapshot, timeoutMs, perpsMode }) {
   const market = String(destination.params.market.symbol).toUpperCase();
   await press(`perps-market-row-item-${market}`);
-  const observed = await waitForPerpsDestination(identifiers, timeoutMs);
+  const observed = await waitForPerpsDestination(identifiers, timeoutMs, press, perpsMode);
   if (!await marketMatches(snapshot, market)) {
     throw new Error(`Opaque Mobile navigation opened a different Perps market than ${market}.`);
   }
@@ -162,32 +185,56 @@ async function navigateHome({ identifiers, press, wait, back }) {
     const ids = await identifiers();
     if (IDS.wallet.some((id) => ids.has(id))) return;
     if (ids.has(IDS.walletTab)) {
-      await press(IDS.walletTab);
-      await wait(IDS.wallet[0]);
-      return;
+      if (await pressCurrent(press, IDS.walletTab)) {
+        await wait(IDS.wallet[0]);
+        return;
+      }
+      continue;
     }
     if (ids.has(IDS.marketBack)) {
-      await press(IDS.marketBack);
+      await pressCurrent(press, IDS.marketBack);
       continue;
     }
     if (ids.has(IDS.proMarketBack)) {
-      await press(IDS.proMarketBack);
+      await pressCurrent(press, IDS.proMarketBack);
       continue;
     }
     if (ids.has(IDS.perpsHomeBack)) {
-      await press(IDS.perpsHomeBack);
+      await pressCurrent(press, IDS.perpsHomeBack);
       continue;
     }
-    if (ids.has(IDS.perpsTradeEntry)) {
-      await back();
+    if (ids.has(IDS.marketListClose)) {
+      await pressCurrent(press, IDS.marketListClose);
       continue;
     }
-    throw new Error('Opaque Mobile navigation could not find a visible route back to wallet home.');
+    if (ids.has(IDS.tokenList) && ids.has(IDS.tokenListBack)) {
+      await pressCurrent(press, IDS.tokenListBack);
+      continue;
+    }
+    if (ids.has(IDS.tokenDetails) && ids.has(IDS.tokenDetailsBack)) {
+      await pressCurrent(press, IDS.tokenDetailsBack);
+      continue;
+    }
+    if (ids.has(IDS.swapSourceInput) && ids.has(IDS.swapBack)) {
+      await pressCurrent(press, IDS.swapBack);
+      continue;
+    }
+    await back();
   }
   throw new Error('Opaque Mobile navigation did not reach wallet home.');
 }
 
-async function navigatePerps({ identifiers, press, wait, back, timeoutMs }) {
+async function pressCurrent(press, testId) {
+  try {
+    await press(testId);
+    return true;
+  } catch (error) {
+    if (!/Selector did not match/iu.test(String(error?.message ?? error))) throw error;
+    return false;
+  }
+}
+
+async function navigatePerps({ identifiers, press, wait, back, timeoutMs, perpsMode }) {
   let ids = await identifiers();
   if (ids.has(IDS.proMarket)) return IDS.proMarket;
   if (ids.has(IDS.market)) {
@@ -219,15 +266,61 @@ async function navigatePerps({ identifiers, press, wait, back, timeoutMs }) {
     ids = await identifiers();
   }
   if (ids.has(IDS.tutorialSkip)) await press(IDS.tutorialSkip);
-  return waitForPerpsDestination(identifiers, timeoutMs);
+  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 navigatePerpsMarketList({ identifiers, press, wait, back, timeoutMs }) {
+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;
-  const observed = await navigatePerps({ identifiers, press, wait, back, timeoutMs });
+  const observed = await navigatePerps({ identifiers, press, wait, back, timeoutMs, perpsMode });
   ids = await identifiers();
   if (ids.has(IDS.marketList)) return IDS.marketList;
+  if (ids.has(IDS.perpsSearch)) {
+    await press(IDS.perpsSearch);
+    await wait(IDS.marketList);
+    return IDS.marketList;
+  }
   if (ids.has(IDS.proMarketList)) {
     await press(IDS.proMarketList);
     await wait(IDS.marketList);
@@ -236,10 +329,14 @@ async function navigatePerpsMarketList({ identifiers, press, wait, back, timeout
   throw new Error(`Opaque Mobile navigation reached ${observed}, but no visible market-list control was available.`);
 }
 
-async function waitForPerpsDestination(identifiers, timeoutMs) {
+async function waitForPerpsDestination(identifiers, timeoutMs, press, perpsMode = 'lite') {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
     const ids = await identifiers();
+    if (ids.has(IDS.modeLite) || ids.has(IDS.modePro)) {
+      await press(perpsMode === 'pro' ? IDS.modePro : IDS.modeLite);
+      continue;
+    }
     for (const id of [IDS.perpsHome, IDS.market, IDS.proMarket]) {
       if (ids.has(id)) return id;
     }

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

@@ -15,11 +15,22 @@ function text(value) {
 function pageRoute(node) {
   const page = text(node?.page);
   if (!page) return undefined;
-  if (PAGE_ROUTES[page]) return { page, ...PAGE_ROUTES[page] };
+  const mode = text(node?.mode)?.toLowerCase() ?? 'lite';
+  if (!['lite', 'pro'].includes(mode)) {
+    throw new Error('mobile ui.navigate mode must be lite or pro.');
+  }
+  if (PAGE_ROUTES[page]) {
+    const route = PAGE_ROUTES[page];
+    return {
+      page,
+      ...route,
+      params: page.startsWith('perps') ? { ...route.params, mode } : route.params,
+    };
+  }
   if (page === 'perps-market') {
     const market = text(node.market) ?? text(node.symbol) ?? text(node.params?.market?.symbol);
     if (!market) throw new Error('mobile ui.navigate page=perps-market requires market or symbol.');
-    return { page, route: 'PerpsMarketDetails', params: { market: { symbol: market } } };
+    return { page, route: 'PerpsMarketDetails', params: { market: { symbol: market }, mode } };
   }
   throw new Error('mobile ui.navigate supported page intents: home, perps, perps-market-list, perps-market, swap.');
 }

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/lock.mjs

@@ -0,0 +1,14 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { isOpaqueMobileRuntime, lockWalletThroughNativeUi } from './native-ui.mjs';
+
+runAdapter(async (input) => {
+  if (!isOpaqueMobileRuntime(input)) {
+    throw new Error('metamask.wallet.lock requires an opaque Mobile runtime.');
+  }
+  return {
+    action: input.action,
+    ...await lockWalletThroughNativeUi(input),
+    locked: true,
+    proofPath: 'mobile-visible-wallet-lock-native',
+  };
+});