@deeeed/metamask-harness 0.38.0 → 0.39.0

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

@@ -0,0 +1,55 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { resolveAmountOptions } from '../../shared/swap-bridge/transaction.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+runAdapter(async (input) => {
+  const options = resolveAmountOptions({
+    amount: '1',
+    wait_for_quote: input.node?.wait_for_quote,
+    timeout_ms: input.node?.timeout_ms,
+  });
+  const session = createNativeSession(input, 'Swap', `max-${process.pid}`);
+  try {
+    await session.open();
+    await session.execute('ui.press', {
+      test_id: 'token-input-area-max-button',
+      timeout_ms: options.timeoutMs,
+      settle: false,
+    });
+    const deadline = Date.now() + options.timeoutMs;
+    let observed;
+    do {
+      const snapshot = await session.snapshot();
+      const cta = nativeNode(snapshot, 'bridge-confirm-button')
+        ?? nativeNode(snapshot, 'bridge-confirm-button-keypad');
+      observed = {
+        sourceAmount: nativeLabel(nativeNode(snapshot, 'source-token-area-input')),
+        destinationAmount: nativeLabel(nativeNode(snapshot, 'dest-token-area-input')),
+        cta: nativeLabel(cta) || null,
+        ctaEnabled: cta?.enabled !== false,
+        noQuote: Boolean(nativeNode(snapshot, 'bridge-no-quotes')),
+      };
+      if (Number(observed.sourceAmount) > 0 && (
+        !options.waitForQuote
+        || observed.noQuote
+        || (Number(observed.destinationAmount) > 0 && cta)
+      )) break;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    } while (Date.now() < deadline);
+    if (!(Number(observed?.sourceAmount) > 0)) {
+      throw new Error('Swap Max did not populate a positive source amount.');
+    }
+    if (options.waitForQuote && !observed.noQuote
+      && (!(Number(observed.destinationAmount) > 0) || !observed.cta)) {
+      throw new Error(`Swap Max quote did not resolve within ${options.timeoutMs}ms.`);
+    }
+    return { action: input.action, ...observed, proofPath: 'native-accessibility-max-quote' };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

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

@@ -0,0 +1,96 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+async function waitForNode(session, testId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let snapshot;
+  while (Date.now() <= deadline) {
+    snapshot = await session.snapshot();
+    const node = nativeNode(snapshot, testId);
+    if (node) return { node, snapshot };
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error(`Swap control ${testId} did not become visible.`);
+}
+
+async function replaceSlippage(session, percent, timeoutMs) {
+  const inputId = 'input-stepper-input';
+  await waitForNode(session, inputId, timeoutMs);
+  await session.execute('ui.press', { test_id: inputId, timeout_ms: timeoutMs, settle: false });
+  let current = nativeLabel(nativeNode(await session.snapshot(), inputId));
+  for (let index = 0; index < Math.min(20, current.length + 2); index += 1) {
+    await session.execute('ui.press', {
+      test_id: 'keypad-delete-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+  }
+  current = nativeLabel(nativeNode(await session.snapshot(), inputId));
+  const value = String(percent);
+  const keys = value.startsWith('0.') && current === '0' ? value.slice(1) : value;
+  for (const key of keys) {
+    if (!/[0-9.]/u.test(key)) {
+      throw new Error(`Swap slippage contains unsupported keypad character ${JSON.stringify(key)}.`);
+    }
+    await session.execute('ui.press', {
+      test_id: key === '.' ? 'keypad-key-dot' : `keypad-key-${key}`,
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+  }
+  const observed = nativeLabel(nativeNode(await session.snapshot(), inputId));
+  if (Number(observed) !== percent) {
+    throw new Error(`Swap slippage input mismatch: expected ${percent}, observed ${JSON.stringify(observed)}.`);
+  }
+}
+
+runAdapter(async (input) => {
+  const percent = Number(input.node?.percent);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!Number.isFinite(percent) || percent <= 0 || percent > 50) {
+    throw new Error('metamask.swap_bridge.set_slippage requires percent greater than 0 and at most 50.');
+  }
+  const session = createNativeSession(input, 'Swap', `slippage-${process.pid}`);
+  try {
+    await session.open();
+    const initial = await session.snapshot();
+    const opener = nativeNode(initial, 'edit-slippage-button')
+      ? 'edit-slippage-button'
+      : 'bridge-slippage-settings-button';
+    await session.execute('ui.press', { test_id: opener, timeout_ms: timeoutMs, settle: false });
+    await session.execute('ui.press', { text: 'Custom', timeout_ms: timeoutMs, settle: false });
+    await replaceSlippage(session, percent, timeoutMs);
+    await session.execute('ui.press', { text: 'Confirm', timeout_ms: timeoutMs, settle: false });
+
+    const deadline = Date.now() + timeoutMs;
+    let observed = null;
+    let destinationAmount = null;
+    while (Date.now() <= deadline) {
+      const snapshot = await session.snapshot();
+      observed = nativeLabel(nativeNode(snapshot, 'edit-slippage-button')) || null;
+      destinationAmount = nativeLabel(nativeNode(snapshot, 'dest-token-area-input')) || null;
+      if (Number.parseFloat(observed) === percent && Number(destinationAmount) > 0) break;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    if (Number.parseFloat(observed) !== percent) {
+      throw new Error(`Swap quote did not display Slippage: ${percent}%; observed ${JSON.stringify(observed)}.`);
+    }
+    if (!(Number(destinationAmount) > 0)) {
+      throw new Error('Swap quote did not finish refreshing after custom slippage was applied.');
+    }
+    return {
+      action: input.action,
+      percent,
+      observed,
+      destinationAmount,
+      proofPath: 'native-accessibility-custom-slippage',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

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,16 @@ 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',
   market: 'perps-market-details-view',
   marketBack: 'perps-market-header-back-button',
   marketSubtitle: 'perps-market-header-subtitle',
@@ -23,6 +30,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 +45,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 +58,7 @@ export async function navigateOpaqueMobile(input, destination) {
     device,
     app,
     session,
+    stateDir,
     client,
   });
   const context = {
@@ -52,9 +67,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 +97,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 {
@@ -91,25 +110,25 @@ export async function navigateOpaqueMobile(input, destination) {
     } 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) });
+      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 +166,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 +181,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;
+    }
+    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;
     }
-    throw new Error('Opaque Mobile navigation could not find a visible route back to wallet home.');
+    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 +262,20 @@ 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 navigatePerpsMarketList({ identifiers, press, wait, back, timeoutMs }) {
+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 +284,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/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',
+  };
+});