@deeeed/metamask-harness 0.36.0 → 0.37.0

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

@@ -1,5 +1,6 @@
 import { resolveWalletImportCredentials, validateWalletImportOptions, walletImportMethod } from '../../shared/wallet/import-source.mjs';
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { pasteSecretRecoveryPhrase, setSecretInput } from './secret-input.mjs';
 import { readWalletStateExpression } from './state.mjs';
 
 const SELECTORS = {
@@ -54,42 +55,6 @@ async function waitForFirstSelector(page, selectors, timeoutMs) {
   throw new Error('Wallet import timed out waiting for the next onboarding screen.');
 }
 
-async function setSecretInput(page, selector, value) {
-  await page.evaluate(`(() => {
-    const element = document.querySelector(${JSON.stringify(selector)});
-    if (!element) throw new Error('Wallet import secret input was not found.');
-    element.focus();
-    if (typeof element.select === 'function') element.select();
-  })()`);
-  await page.session.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace' });
-  await page.session.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace' });
-  await page.session.call('Input.insertText', { text: value });
-  const matches = await page.evaluate(`(() => {
-    const element = document.querySelector(${JSON.stringify(selector)});
-    if (!element) return false;
-    element.dispatchEvent(new Event('change', { bubbles: true }));
-    return element.value === ${JSON.stringify(value)};
-  })()`);
-  if (!matches) throw new Error('Wallet import secret input did not retain the supplied value.');
-}
-
-async function pasteSecretInput(page, selector, value) {
-  const pasted = await page.evaluate(`(() => {
-    const element = document.querySelector(${JSON.stringify(selector)});
-    if (!element) return false;
-    const clipboardData = new DataTransfer();
-    clipboardData.setData('text', ${JSON.stringify(value)});
-    element.focus();
-    element.dispatchEvent(new ClipboardEvent('paste', {
-      bubbles: true,
-      cancelable: true,
-      clipboardData,
-    }));
-    return true;
-  })()`);
-  if (!pasted) throw new Error('Wallet import Secret Recovery Phrase input was not found.');
-}
-
 async function waitForEnabled(page, selector, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
@@ -120,17 +85,19 @@ async function importThroughUi(page, input, timeoutMs) {
   if (interests.length > 0) {
     throw new Error('metamask.wallet.import interests are supported only on Mobile.');
   }
-  await page.click(SELECTORS.importWallet);
-  const importChoice = await waitForFirstSelector(
-    page,
-    [SELECTORS.importWithSrp, SELECTORS.srp],
-    timeoutMs,
-  );
-  if (importChoice === SELECTORS.importWithSrp) {
-    await page.click(SELECTORS.importWithSrp);
+  if (!(await hasSelector(page, SELECTORS.srp))) {
+    await page.click(SELECTORS.importWallet);
+    const importChoice = await waitForFirstSelector(
+      page,
+      [SELECTORS.importWithSrp, SELECTORS.srp],
+      timeoutMs,
+    );
+    if (importChoice === SELECTORS.importWithSrp) {
+      await page.click(SELECTORS.importWithSrp);
+    }
+    await waitForSelector(page, SELECTORS.srp, timeoutMs);
   }
-  await waitForSelector(page, SELECTORS.srp, timeoutMs);
-  await pasteSecretInput(page, SELECTORS.srp, credentials.mnemonic);
+  await pasteSecretRecoveryPhrase(page, SELECTORS.srp, credentials.mnemonic, timeoutMs);
   await waitForEnabled(page, SELECTORS.confirmSrp, timeoutMs);
   await page.click(SELECTORS.confirmSrp);
   await waitForSelector(page, SELECTORS.password, timeoutMs);

package/library/actions/extension/wallet/secret-input.mjs

@@ -0,0 +1,98 @@
+export async function setSecretInput(page, selector, value) {
+  const found = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return false;
+    element.focus();
+    if (typeof element.select === 'function') element.select();
+    return true;
+  })()`);
+  if (!found) throw new Error('Wallet import secret input was not found.');
+
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace' });
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace' });
+  await page.session.call('Input.insertText', { text: value });
+
+  const retainedLength = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return -1;
+    element.dispatchEvent(new Event('change', { bubbles: true }));
+    return typeof element.value === 'string' ? element.value.length : -1;
+  })()`);
+  if (retainedLength !== value.length) {
+    throw new Error('Wallet import secret input did not retain the supplied value.');
+  }
+}
+
+export async function pasteSecretRecoveryPhrase(page, selector, value, timeoutMs) {
+  const bridgeKey = 'mm-harness.wallet.recovery-phrase-paste';
+  const preload = await page.session.call('Page.addScriptToEvaluateOnNewDocument', {
+    source: `(() => {
+      const bridgeKey = Symbol.for(${JSON.stringify(bridgeKey)});
+      const NativeDataTransfer = globalThis.DataTransfer;
+      const NativeClipboardEvent = globalThis.ClipboardEvent;
+      Object.defineProperty(globalThis, bridgeKey, {
+        configurable: true,
+        value(selector) {
+          const element = document.querySelector(selector);
+          if (!element || typeof element.value !== 'string') return false;
+          const clipboardData = new NativeDataTransfer();
+          clipboardData.setData('text', element.value);
+          element.focus();
+          element.dispatchEvent(new NativeClipboardEvent('paste', {
+            bubbles: true,
+            cancelable: true,
+            clipboardData,
+          }));
+          return true;
+        },
+      });
+    })();`,
+  });
+  if (typeof preload?.identifier !== 'string' || preload.identifier.length === 0) {
+    throw new Error('Wallet import recovery phrase preload was not installed.');
+  }
+
+  let actionError;
+  try {
+    await page.session.call('Page.reload', { ignoreCache: false });
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+      const found = await page.evaluate(
+        `Boolean(document.querySelector(${JSON.stringify(selector)}))`,
+      ).catch(() => false);
+      if (found) break;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    await setSecretInput(page, selector, value);
+    const pasted = await page.evaluate(`(() => {
+      const bridge = globalThis[Symbol.for(${JSON.stringify(bridgeKey)})];
+      return typeof bridge === 'function' && bridge(${JSON.stringify(selector)});
+    })()`);
+    if (!pasted) throw new Error('Wallet import Secret Recovery Phrase input was not found.');
+  } catch (error) {
+    actionError = error;
+  }
+
+  const cleanupErrors = [];
+  try {
+    const removed = await page.evaluate(`(() => {
+      const key = Symbol.for(${JSON.stringify(bridgeKey)});
+      delete globalThis[key];
+      return !(key in globalThis);
+    })()`);
+    if (removed !== true) cleanupErrors.push('page bridge removal was not confirmed');
+  } catch (error) {
+    cleanupErrors.push(error instanceof Error ? error.message : String(error));
+  }
+  try {
+    await page.session.call('Page.removeScriptToEvaluateOnNewDocument', {
+      identifier: preload.identifier,
+    });
+  } catch (error) {
+    cleanupErrors.push(error instanceof Error ? error.message : String(error));
+  }
+  if (cleanupErrors.length > 0) {
+    throw new Error(`Wallet import recovery phrase bridge cleanup failed: ${cleanupErrors.join('; ')}.`);
+  }
+  if (actionError) throw actionError;
+}

package/library/actions/mobile/platform/observe-ui.mjs

@@ -1,12 +1,13 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { createAgentDeviceClient } from 'agent-device';
 
 import { bridgeCommand } from './bridge.mjs';
 import { mobileToolRecovery, resolveMobileToolPath } from './tool-paths.mjs';
 
 const execFileAsync = promisify(execFile);
-const VISIBLE_LIMIT = 50;
-const HIDDEN_LIMIT = 50;
+const VISIBLE_LIMIT = 200;
+const HIDDEN_LIMIT = 100;
 
 export async function observeNativeUi(payload, context) {
   await hideAccessibilityMaskingHud(payload, context);
@@ -111,6 +112,9 @@ async function readAndroidHierarchy(node, env) {
     );
   }
   const serial = await resolveAndroidSerial(adbPath, node, env);
+  if (isOpaqueRuntime(env)) {
+    return readAndroidAgentDeviceHierarchy(serial, env);
+  }
   const { stdout } = await execFileAsync(
     adbPath,
     ['-s', serial, 'exec-out', 'uiautomator', 'dump', '/dev/tty'],
@@ -135,6 +139,84 @@ async function readAndroidHierarchy(node, env) {
   );
 }
 
+async function readAndroidAgentDeviceHierarchy(serial, env) {
+  const session = `mm-harness-observe-${process.pid}-${Date.now()}`;
+  const client = createAgentDeviceClient({
+    session,
+    lockPolicy: 'reject',
+    lockPlatform: 'android',
+  });
+  try {
+    const snapshot = await client.capture.snapshot({
+      platform: 'android',
+      target: 'mobile',
+      serial,
+      session,
+      app: text(env.ANDROID_PACKAGE_ID) ?? 'io.metamask',
+      interactiveOnly: false,
+      forceFull: true,
+    });
+    const hierarchy = flattenAgentDeviceHierarchy(
+      snapshot.nodes,
+      text(env.ANDROID_PACKAGE_ID) ?? 'io.metamask',
+    );
+    if (hierarchy.nodeCount === 0) {
+      throw new Error('Agent Device returned an empty Android accessibility hierarchy.');
+    }
+    return normalizedHierarchy(
+      'agent-device-accessibility',
+      'android',
+      serial,
+      hierarchy.visible,
+      hierarchy.hidden,
+      hierarchy,
+    );
+  } finally {
+    await client.sessions.close({ session, shutdown: false });
+  }
+}
+
+function flattenAgentDeviceHierarchy(nodes, appId) {
+  const visible = [];
+  const hidden = [];
+  let screenName;
+  for (const source of Array.isArray(nodes) ? nodes : []) {
+    const node = record(source);
+    const bundleId = text(node.bundleId);
+    if (bundleId && bundleId !== appId) continue;
+    const bounds = normalizeBounds(node.rect ?? node.bounds);
+    const label = text(node.label) ?? text(node.value);
+    const role = text(node.type)?.toLowerCase();
+    const testId = text(node.identifier);
+    if (!isActionableRole(role) && !testId) continue;
+    screenName ??= label;
+    const item = compactItem({
+      role,
+      label,
+      test_id: testId,
+      enabled: boolean(node.enabled),
+      selected: boolean(node.selected),
+      focused: boolean(node.focused),
+      bounds,
+    });
+    if (hasVisibleBounds(bounds)) {
+      visible.push(item);
+    } else {
+      hidden.push({ ...item, reason: 'hidden_or_offscreen' });
+    }
+  }
+  return {
+    visible,
+    hidden,
+    nodeCount: Array.isArray(nodes) ? nodes.length : 0,
+    screenName,
+  };
+}
+
+function isOpaqueRuntime(env) {
+  return env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === '1';
+}
+
 function normalizedHierarchy(
   provider,
   platform,

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

@@ -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,