@deeeed/metamask-harness 0.36.0 → 0.38.0

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

@@ -0,0 +1,265 @@
+import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
+import { createAgentDeviceClient } from 'agent-device';
+import { nativeSessionName } from '../platform/native-session-name.mjs';
+
+const IDS = {
+  wallet: ['wallet-safe-area', 'homepage-container'],
+  walletTab: 'tab-bar-item-Wallet',
+  tradeTab: 'tab-bar-item-Trade',
+  perpsEntry: 'homepage-balance-breakdown-row-perps',
+  perpsTradeEntry: 'wallet-perps-action',
+  swapTradeEntry: 'wallet-actions-bottom-sheet-swap-button',
+  swapSourceInput: 'source-token-area-input',
+  swapSourceToken: 'source-token-area',
+  swapDestinationToken: 'dest-token-area',
+  perpsHome: 'perps-home',
+  perpsHomeBack: 'perps-home-back-button',
+  tutorialSkip: 'perps-tutorial-skip-button',
+  market: 'perps-market-details-view',
+  marketBack: 'perps-market-header-back-button',
+  marketSubtitle: 'perps-market-header-subtitle',
+  proMarket: 'perps-pro-market-scroll-view',
+  proMarketBack: 'perps-pro-market-header-back-button',
+  proMarketList: 'perps-pro-market-header-market-list-button',
+  proMarketSubtitle: 'perps-pro-market-header-subtitle',
+  marketList: 'perps-market-list',
+};
+
+export async function navigateOpaqueMobile(input, destination) {
+  const env = { ...process.env, ...(input.context?.env ?? {}) };
+  const device = String(env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? '').trim();
+  if (!device) {
+    throw new Error('Opaque Mobile navigation requires one explicit Android device serial.');
+  }
+  const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
+  const session = nativeSessionName(env, device, app);
+  const client = createAgentDeviceClient({
+    session,
+    lockPolicy: 'reject',
+    lockPlatform: 'android',
+  });
+  const selection = { platform: 'android', target: 'mobile', serial: device, session };
+  const transport = createAgentDeviceUiTransport({
+    platform: 'android',
+    device,
+    app,
+    session,
+    client,
+  });
+  const context = {
+    nodeId: String(input.context?.nodeId ?? 'navigate'),
+    projectRoot: input.context.projectRoot,
+    artifactsDir: input.context.artifactsDir,
+    env,
+  };
+  const press = (testId) => transport.execute('ui.press', {
+    test_id: testId,
+    timeout_ms: Number(input.node?.timeout_ms ?? 30_000),
+  }, context);
+  const wait = (testId) => transport.execute('ui.wait_for', {
+    test_id: testId,
+    expected: 'visible',
+    timeout_ms: Number(input.node?.timeout_ms ?? 30_000),
+    settle: false,
+  }, context);
+  const back = () => client.command.back({
+    platform: 'android',
+    target: 'mobile',
+    serial: device,
+    session,
+    mode: 'system',
+    responseLevel: 'digest',
+  });
+  const snapshot = () => client.capture.snapshot({
+    platform: 'android',
+    target: 'mobile',
+    serial: device,
+    session,
+    app,
+    interactiveOnly: false,
+    forceFull: true,
+  });
+  const identifiers = async () => new Set(
+    (await snapshot()).nodes.map((node) => String(node.identifier ?? '')),
+  );
+
+  try {
+    let observedScreen;
+    if (destination.page === 'home') {
+      await navigateHome({ identifiers, press, wait, back });
+      observedScreen = 'wallet-home';
+    } else if (destination.page === 'swap') {
+      observedScreen = await navigateSwap({ identifiers, press, wait, back });
+    } else if (destination.page === 'perps-market-list') {
+      observedScreen = await navigatePerpsMarketList({ identifiers, press, wait, back, timeoutMs: Number(input.node?.timeout_ms ?? 30_000) });
+    } 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 });
+      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 });
+        } 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);
+        if (!await marketMatches(snapshot, market)) {
+          throw new Error(`Opaque Mobile navigation opened a different Perps market than ${market}.`);
+        }
+      }
+    }
+    return {
+      page: destination.page,
+      route: destination.route,
+      params: destination.params,
+      provider: 'android-native-accessibility',
+      proofPath: 'visible-native-navigation',
+      observedScreen,
+    };
+  } finally {
+    await closeNativeSession(client, selection);
+  }
+}
+
+async function navigateSwap({ identifiers, press, wait, back }) {
+  let ids = await identifiers();
+  if (ids.has(IDS.swapSourceInput)) return IDS.swapSourceInput;
+  if (!ids.has(IDS.swapTradeEntry)) {
+    await navigateHome({ identifiers, press, wait, back });
+    await press(IDS.tradeTab);
+    await wait(IDS.swapTradeEntry);
+    ids = await identifiers();
+  }
+  if (!ids.has(IDS.swapTradeEntry)) {
+    throw new Error('Opaque Mobile navigation could not find the visible Swap entry.');
+  }
+  await press(IDS.swapTradeEntry);
+  await wait(IDS.swapSourceInput);
+  await wait(IDS.swapSourceToken);
+  await wait(IDS.swapDestinationToken);
+  return IDS.swapSourceInput;
+}
+
+async function selectMarket({ destination, identifiers, press, snapshot, timeoutMs }) {
+  const market = String(destination.params.market.symbol).toUpperCase();
+  await press(`perps-market-row-item-${market}`);
+  const observed = await waitForPerpsDestination(identifiers, timeoutMs);
+  if (!await marketMatches(snapshot, market)) {
+    throw new Error(`Opaque Mobile navigation opened a different Perps market than ${market}.`);
+  }
+  return observed;
+}
+
+async function navigateHome({ identifiers, press, wait, back }) {
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    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 (ids.has(IDS.marketBack)) {
+      await press(IDS.marketBack);
+      continue;
+    }
+    if (ids.has(IDS.proMarketBack)) {
+      await press(IDS.proMarketBack);
+      continue;
+    }
+    if (ids.has(IDS.perpsHomeBack)) {
+      await press(IDS.perpsHomeBack);
+      continue;
+    }
+    if (ids.has(IDS.perpsTradeEntry)) {
+      await back();
+      continue;
+    }
+    throw new Error('Opaque Mobile navigation could not find a visible route back to wallet home.');
+  }
+  throw new Error('Opaque Mobile navigation did not reach wallet home.');
+}
+
+async function navigatePerps({ identifiers, press, wait, back, timeoutMs }) {
+  let ids = await identifiers();
+  if (ids.has(IDS.proMarket)) return IDS.proMarket;
+  if (ids.has(IDS.market)) {
+    await press(IDS.marketBack);
+    ids = await identifiers();
+  }
+  if (!ids.has(IDS.perpsHome)) {
+    if (ids.has(IDS.perpsTradeEntry)) {
+      await press(IDS.perpsTradeEntry);
+    } else if (ids.has(IDS.perpsEntry)) {
+      await press(IDS.perpsEntry);
+    } else {
+      if (!ids.has(IDS.tradeTab)) {
+        await navigateHome({ identifiers, press, wait, back });
+        ids = await identifiers();
+      }
+      if (ids.has(IDS.tradeTab)) {
+        await press(IDS.tradeTab);
+        ids = await identifiers();
+      }
+      if (ids.has(IDS.perpsTradeEntry)) {
+        await press(IDS.perpsTradeEntry);
+      } else if (ids.has(IDS.perpsEntry)) {
+        await press(IDS.perpsEntry);
+      } else {
+        throw new Error('Opaque Mobile navigation could not find the visible Perps entry.');
+      }
+    }
+    ids = await identifiers();
+  }
+  if (ids.has(IDS.tutorialSkip)) await press(IDS.tutorialSkip);
+  return waitForPerpsDestination(identifiers, timeoutMs);
+}
+
+async function navigatePerpsMarketList({ identifiers, press, wait, back, timeoutMs }) {
+  let ids = await identifiers();
+  if (ids.has(IDS.marketList)) return IDS.marketList;
+  const observed = await navigatePerps({ identifiers, press, wait, back, timeoutMs });
+  ids = await identifiers();
+  if (ids.has(IDS.marketList)) return IDS.marketList;
+  if (ids.has(IDS.proMarketList)) {
+    await press(IDS.proMarketList);
+    await wait(IDS.marketList);
+    return IDS.marketList;
+  }
+  throw new Error(`Opaque Mobile navigation reached ${observed}, but no visible market-list control was available.`);
+}
+
+async function waitForPerpsDestination(identifiers, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const ids = await identifiers();
+    for (const id of [IDS.perpsHome, IDS.market, IDS.proMarket]) {
+      if (ids.has(id)) return id;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error('Opaque Mobile navigation did not reach a visible Perps destination.');
+}
+
+async function closeNativeSession(client, selection) {
+  try {
+    await client.sessions.close({ ...selection, responseLevel: 'digest' });
+  } catch (error) {
+    if (!/No active session|SESSION_NOT_FOUND/iu.test(String(error?.message ?? error))) throw error;
+  }
+}
+
+async function marketMatches(snapshot, market) {
+  const nodes = (await snapshot()).nodes;
+  return nodes.some((node) =>
+    (node.identifier === IDS.marketSubtitle || node.identifier === IDS.proMarketSubtitle) &&
+    String(node.label ?? node.value ?? '').toUpperCase().includes(`${market}-USD`)
+  );
+}

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

@@ -1,8 +1,11 @@
 import { navigate, runAdapter } from '../platform/bridge.mjs';
+import { navigateOpaqueMobile } from './native-navigation.mjs';
 
 const PAGE_ROUTES = {
   home: { route: 'WalletView', params: {} },
   perps: { route: 'PerpsMarketListView', params: {} },
+  'perps-market-list': { route: 'PerpsMarketListView', params: {} },
+  swap: { route: 'BridgeView', params: {} },
 };
 
 function text(value) {
@@ -18,12 +21,18 @@ function pageRoute(node) {
     if (!market) throw new Error('mobile ui.navigate page=perps-market requires market or symbol.');
     return { page, route: 'PerpsMarketDetails', params: { market: { symbol: market } } };
   }
-  throw new Error('mobile ui.navigate supported page intents: home, perps, perps-market.');
+  throw new Error('mobile ui.navigate supported page intents: home, perps, perps-market-list, perps-market, swap.');
 }
 
 runAdapter(async (input) => {
   const alias = pageRoute(input.node);
   if (alias) {
+    if (
+      input.context?.env?.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === '1' ||
+      process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === '1'
+    ) {
+      return navigateOpaqueMobile(input, alias);
+    }
     const navigation = await navigate(input, alias.route, alias.params);
     return { action: input.action, ...alias, navigation, proofPath: 'agentic-navigation' };
   }

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

@@ -6,6 +6,7 @@ import {
   selectBridgeStatusEntry,
 } from '../platform/bridge.mjs';
 import { walletFixturePath } from '../../harness-exports.mjs';
+import { isOpaqueMobileRuntime, unlockWalletThroughNativeUi } from './native-ui.mjs';
 
 async function fixturePassword(projectRoot) {
   const candidates = [
@@ -156,6 +157,22 @@ async function waitForStableUnlocked(input, initialStatus, stableMs = 750) {
 }
 
 export async function ensureUnlocked(input) {
+  if (isOpaqueMobileRuntime(input)) {
+    const timeoutMs = Number(input.node?.unlock_timeout_ms ?? 30_000);
+    const password = input.node?.password ?? await fixturePassword(input.context.projectRoot);
+    const proof = await unlockWalletThroughNativeUi(input, String(password), timeoutMs);
+    return {
+      action: input.action,
+      unlocked: true,
+      alreadyUnlocked: proof.alreadyReady,
+      account: proof.selectedAddress || proof.selectedAddressObserved
+        ? { address: proof.selectedAddress ?? proof.selectedAddressObserved }
+        : null,
+      redacted: true,
+      provider: proof.provider,
+      proofPath: proof.proofPath,
+    };
+  }
   const targetTimeoutMs = Number(input.node?.target_timeout_ms ?? 20000);
   const targetDeadline = Date.now() + targetTimeoutMs;
   const targetStatus = await waitForTargetStatus(input, targetTimeoutMs);

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

@@ -10,6 +10,7 @@ import {
 } from '../platform/bridge.mjs';
 import { setMobileConsent } from '../analytics/consent-settings.mjs';
 import { ensureUnlocked } from './ensure_unlocked.mjs';
+import { importWalletThroughNativeUi, isOpaqueMobileRuntime } from './native-ui.mjs';
 
 const TEST_IDS = {
   existingWallet: 'wallet-setup-screen-have-an-existing-wallet-button-id',
@@ -99,6 +100,15 @@ async function press(input, testId, timeoutMs) {
   return waitForCommand(input, ['press-test-id', testId], timeoutMs, testId);
 }
 
+async function pressIfPresent(input, testId, timeoutMs = 2000) {
+  try {
+    await press(input, testId, Math.min(timeoutMs, 2000));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function setSecretInput(input, testId, value, timeoutMs) {
   const directory = await mkdtemp(path.join(os.tmpdir(), 'mm-harness-wallet-import-'));
   const file = path.join(directory, 'value');
@@ -130,7 +140,7 @@ async function waitForInterestDecision(input, timeoutMs) {
   throw new Error(`Mobile onboarding did not reach the interests screen or wallet home from ${route}.`);
 }
 
-async function importThroughUi(input, timeoutMs) {
+async function importThroughUi(input, timeoutMs, options) {
   const credentials = await resolveWalletImportCredentials(input);
   const metametricsEnabled = input.node?.metametrics === true || input.node?.metametrics === 'true';
   const interests = Array.isArray(input.node?.interests)
@@ -174,6 +184,12 @@ async function importThroughUi(input, timeoutMs) {
   if (String(selectedEntry(afterInterests, input)?.route?.name ?? '') === 'OnboardingSuccess') {
     await press(input, TEST_IDS.successDone, timeoutMs);
   }
+  if (!options.notificationsEnabled) {
+    await pressIfPresent(input, 'push-notification-new-user-sheet-button-not-now');
+  }
+  if (options.skipWalletTour) {
+    await pressIfPresent(input, 'wallet-home-onboarding-steps-skip');
+  }
 
   const deadline = Date.now() + timeoutMs;
   let observed = await status(input);
@@ -205,6 +221,56 @@ runAdapter(async (input) => {
   validateWalletImportOptions('mobile', input.node);
   const method = walletImportMethod(input);
   const timeoutMs = Number(input.node?.timeout_ms ?? 60000);
+  const biometricsEnabled = input.node?.biometrics === true || input.node?.biometrics === 'true';
+  const notificationsEnabled = input.node?.notifications === true || input.node?.notifications === 'true';
+  const skipWalletTour = input.node?.skip_wallet_tour !== false && input.node?.skip_wallet_tour !== 'false';
+  if (biometricsEnabled) {
+    throw new Error('Mobile biometrics=true requires manual device authentication and is not supported by an unattended recipe.');
+  }
+  if (isOpaqueMobileRuntime(input)) {
+    if (method === 'profile') {
+      throw new Error('metamask.wallet.import method=profile requires the Mobile development bridge; use method=auto or ui for a release artifact.');
+    }
+    const credentials = await resolveWalletImportCredentials(input);
+    const metametricsEnabled = input.node?.metametrics === true || input.node?.metametrics === 'true';
+    const interests = Array.isArray(input.node?.interests)
+      ? input.node.interests.map((value) => String(value))
+      : [];
+    const invalidInterest = interests.find((value) => !INTEREST_IDS.has(value));
+    if (invalidInterest) throw new Error(`Unsupported Mobile onboarding interest: ${invalidInterest}.`);
+    const proof = await importWalletThroughNativeUi(input, credentials, {
+      timeoutMs,
+      metametricsEnabled,
+      biometricsEnabled,
+      notificationsEnabled,
+      skipWalletTour,
+      interests,
+      requireFresh: method === 'ui',
+    });
+    if (!proof.addressVisible) {
+      throw new Error('Visible Mobile onboarding reached wallet home, but the imported account address was not observable through native accessibility.');
+    }
+    return {
+      action: input.action,
+      method: proof.alreadyReady ? 'native-profile' : 'native-ui-import',
+      credentialSource: credentials.source,
+      credentialSourceName: credentials.sourceName,
+      selectedAddress: proof.selectedAddress,
+      metametricsRequested: metametricsEnabled,
+      biometricsRequested: biometricsEnabled,
+      biometricPromptDismissed: proof.biometricPromptDismissed ?? false,
+      notificationsRequested: notificationsEnabled,
+      notificationPromptHandled: proof.notificationPromptHandled ?? false,
+      walletTourSkipped: proof.walletTourSkipped ?? false,
+      interests,
+      provider: proof.provider,
+      redacted: true,
+      proofPath: proof.proofPath,
+    };
+  }
+  if (notificationsEnabled) {
+    throw new Error('Mobile notifications=true requires native system-permission handling and is supported only for an Android release artifact.');
+  }
   const before = await status(input);
   const entry = selectedEntry(before, input);
   const address = selectedAddress(before, input);
@@ -218,7 +284,10 @@ runAdapter(async (input) => {
     if (method === 'profile') {
       throw new Error('metamask.wallet.import method=profile found a fresh Mobile onboarding state.');
     }
-    const imported = await importThroughUi(input, timeoutMs);
+    const imported = await importThroughUi(input, timeoutMs, {
+      notificationsEnabled,
+      skipWalletTour,
+    });
     const importedEntry = selectedEntry(imported.observed, input);
     return {
       action: input.action,