@deeeed/metamask-harness 0.35.0 → 0.37.0

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

@@ -0,0 +1,225 @@
+import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
+import { createAgentDeviceClient } from 'agent-device';
+
+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',
+  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 = `mm-harness-navigation-${process.pid}-${String(input.context?.nodeId ?? 'navigate')}`
+    .replace(/[^A-Za-z0-9._-]/gu, '-');
+  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 {
+      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(transport, client, selection);
+  }
+}
+
+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 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(transport, client, selection) {
+  await transport.close();
+  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,4 +1,5 @@
 import { navigate, runAdapter } from '../platform/bridge.mjs';
+import { navigateOpaqueMobile } from './native-navigation.mjs';
 
 const PAGE_ROUTES = {
   home: { route: 'WalletView', params: {} },
@@ -24,6 +25,12 @@ function pageRoute(node) {
 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/import.mjs

@@ -0,0 +1,328 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { resolveWalletImportCredentials, validateWalletImportOptions, walletImportMethod } from '../../shared/wallet/import-source.mjs';
+import {
+  bridgeCommand,
+  runAdapter,
+  selectBridgeStatusEntry,
+} 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',
+  importSeed: 'onboarding-sheet-import-seed-button-id',
+  srp: 'phrase-input-id',
+  continue: 'import-from-seed-screen-continue-button-id',
+  password: 'create-password-first-input-field',
+  confirmPassword: 'create-password-second-input-field',
+  passwordTerms: 'password-understand-box',
+  createPassword: 'submit-button',
+  metricsCheckbox: 'optin-metrics-metrics-checkbox',
+  metricsContinue: 'optin-metrics-continue-button-id',
+  interestSkip: 'onboarding-interest-skip-button',
+  interestContinue: 'onboarding-interest-continue-button',
+  successDone: 'onboarding-success-done-button',
+};
+
+const INTEREST_IDS = new Set([
+  'swap_tokens',
+  'trade_perpetuals',
+  'prediction_markets',
+  'send_receive_crypto',
+  'earn_and_spend',
+  'use_other_crypto_apps',
+]);
+
+function selectedEntry(status, input) {
+  return selectBridgeStatusEntry(status, input) ?? {};
+}
+
+function selectedAddress(status, input) {
+  return String(selectedEntry(status, input)?.account?.address ?? '').toLowerCase();
+}
+
+function walletReady(observed, input) {
+  const route = String(selectedEntry(observed, input)?.route?.name ?? '');
+  return Boolean(
+    selectedAddress(observed, input) &&
+    route &&
+    route !== 'Login' &&
+    route !== 'Onboarding' &&
+    route !== 'OptinMetrics' &&
+    route !== 'OnboardingInterestQuestionnaire'
+    && route !== 'OnboardingSuccess'
+  );
+}
+
+async function waitForPostPasswordScreen(input, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let observed;
+  while (Date.now() <= deadline) {
+    observed = await status(input);
+    const route = String(selectedEntry(observed, input)?.route?.name ?? '');
+    if (
+      route === 'OptinMetrics' ||
+      route === 'OnboardingInterestQuestionnaire' ||
+      route === 'OnboardingSuccess' ||
+      walletReady(observed, input)
+    ) return { route, observed };
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  const route = String(selectedEntry(observed, input)?.route?.name ?? 'unknown');
+  throw new Error(`Mobile onboarding did not advance after password creation from ${route}.`);
+}
+
+async function status(input) {
+  return bridgeCommand(input, ['status-selected']);
+}
+
+async function waitForCommand(input, args, timeoutMs, label) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() <= deadline) {
+    try {
+      const result = await bridgeCommand(input, args);
+      if (result?.ok !== false) return result;
+      lastError = result?.error;
+    } catch (error) {
+      lastError = error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error(`${label} was not available before the wallet import timeout: ${String(lastError?.message ?? lastError ?? 'unknown')}`);
+}
+
+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');
+  try {
+    await writeFile(file, value, { mode: 0o600 });
+    return await waitForCommand(
+      input,
+      ['set-input-file', testId, file],
+      timeoutMs,
+      testId,
+    );
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+async function waitForInterestDecision(input, timeoutMs) {
+  const deadline = Date.now() + Math.min(timeoutMs, 10000);
+  let observed;
+  while (Date.now() <= deadline) {
+    observed = await status(input);
+    const route = String(selectedEntry(observed, input)?.route?.name ?? '');
+    if (route === 'OnboardingInterestQuestionnaire') return { available: true, observed };
+    if (route === 'OnboardingSuccess') return { available: false, observed };
+    if (walletReady(observed, input)) return { available: false, observed };
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  const route = String(selectedEntry(observed, input)?.route?.name ?? 'unknown');
+  throw new Error(`Mobile onboarding did not reach the interests screen or wallet home from ${route}.`);
+}
+
+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)
+    ? 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}.`);
+  await press(input, TEST_IDS.existingWallet, timeoutMs);
+  try {
+    await setSecretInput(input, TEST_IDS.srp, credentials.mnemonic, 3000);
+  } catch {
+    await press(input, TEST_IDS.importSeed, timeoutMs);
+    await setSecretInput(input, TEST_IDS.srp, credentials.mnemonic, timeoutMs);
+  }
+  await press(input, TEST_IDS.continue, timeoutMs);
+  await setSecretInput(input, TEST_IDS.password, credentials.password, timeoutMs);
+  await setSecretInput(input, TEST_IDS.confirmPassword, credentials.password, timeoutMs);
+  await press(input, TEST_IDS.passwordTerms, timeoutMs);
+  await press(input, TEST_IDS.createPassword, timeoutMs);
+
+  const postPassword = await waitForPostPasswordScreen(input, timeoutMs);
+  if (postPassword.route === 'OptinMetrics') {
+    if (!metametricsEnabled) await press(input, TEST_IDS.metricsCheckbox, timeoutMs);
+    await press(input, TEST_IDS.metricsContinue, timeoutMs);
+  }
+
+  const interestDecision = await waitForInterestDecision(input, timeoutMs);
+  if (!interestDecision.available && interests.length > 0) {
+    throw new Error('Mobile onboarding interests were requested, but the questionnaire is not enabled for this build.');
+  }
+  if (interestDecision.available && interests.length > 0) {
+    for (const interest of interests) {
+      await press(input, `onboarding-interest-option-${interest}`, timeoutMs);
+    }
+    await press(input, TEST_IDS.interestContinue, timeoutMs);
+  } else if (interestDecision.available) {
+    await press(input, TEST_IDS.interestSkip, timeoutMs);
+  }
+
+  const afterInterests = await status(input);
+  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);
+  while (Date.now() <= deadline) {
+    if (walletReady(observed, input)) break;
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    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}.`);
+  }
+  const { consent } = await setMobileConsent(
+    input,
+    metametricsEnabled,
+    false,
+    Math.min(timeoutMs, 30000),
+  );
+  const actualMetametricsEnabled = consent.optedIn === true;
+  await bridgeCommand(input, ['navigate', 'WalletView']);
+  observed = await status(input);
+  if (!walletReady(observed, input)) {
+    throw new Error('Mobile wallet import could not return to wallet home after applying MetaMetrics consent.');
+  }
+  return { credentials, observed, metametricsEnabled: actualMetametricsEnabled, interests };
+}
+
+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);
+  const route = String(entry?.route?.name ?? '');
+  const onboarding = route === 'Onboarding' || (!address && route !== 'Login');
+
+  if (method === 'ui' && !onboarding) {
+    throw new Error('metamask.wallet.import method=ui requires a fresh Mobile onboarding state.');
+  }
+  if (onboarding) {
+    if (method === 'profile') {
+      throw new Error('metamask.wallet.import method=profile found a fresh Mobile onboarding state.');
+    }
+    const imported = await importThroughUi(input, timeoutMs, {
+      notificationsEnabled,
+      skipWalletTour,
+    });
+    const importedEntry = selectedEntry(imported.observed, input);
+    return {
+      action: input.action,
+      method: 'ui-import',
+      credentialSource: imported.credentials.source,
+      credentialSourceName: imported.credentials.sourceName,
+      selectedAddress: importedEntry.account.address,
+      route: importedEntry.route ?? null,
+      metametricsEnabled: imported.metametricsEnabled,
+      interests: imported.interests,
+      redacted: true,
+      proofPath: 'mobile-visible-onboarding-import',
+    };
+  }
+
+  const credentials = await resolveWalletImportCredentials(input);
+  const unlocked = await ensureUnlocked({
+    ...input,
+    node: {
+      ...input.node,
+      ...(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,
+    route: unlocked.route ?? entry.route ?? null,
+    redacted: true,
+    proofPath: 'mobile-fixture-profile',
+  };
+});