@deeeed/metamask-harness 0.38.0 → 0.39.0

package/library/actions/mobile/networks/network-management.mjs

@@ -0,0 +1,132 @@
+import { nativeLabel, nativeNode } from '../platform/native-session.mjs';
+
+const IDS = {
+  add: 'networks-settings-add-custom-network-button',
+  details: 'network-details-view-container',
+  hamburger: 'navbar-hamburger-menu-button',
+  menu: 'networks-menu-item',
+  manager: 'networks-settings-container',
+  search: 'networks-settings-search-input',
+  wallet: ['wallet-safe-area', 'homepage-container'],
+};
+
+export function networkItemId(chainId) {
+  return `networks-settings-network-item-0x${chainId.toString(16)}`;
+}
+
+export function visibleNode(snapshot, identifier) {
+  return snapshot.nodes.find((node) =>
+    node.identifier === identifier &&
+    node.visibleToUser !== false &&
+    node.hittable !== false
+  );
+}
+
+export async function waitForSnapshot(session, timeoutMs, predicate, message) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const snapshot = await session.snapshot();
+    const value = predicate(snapshot);
+    if (value) return { snapshot, value };
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error(message);
+}
+
+async function systemBack(session) {
+  await session.client.command.back({
+    ...session.selection,
+    mode: 'system',
+    responseLevel: 'digest',
+  });
+}
+
+export async function openNetworkManager(session, timeoutMs) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const snapshot = await session.snapshot();
+    if (visibleNode(snapshot, IDS.manager)) return snapshot;
+    if (visibleNode(snapshot, IDS.details)) {
+      await systemBack(session);
+      continue;
+    }
+    if (visibleNode(snapshot, IDS.menu)) {
+      await session.execute('ui.press', { test_id: IDS.menu, timeout_ms: timeoutMs, settle: false });
+      continue;
+    }
+    if (IDS.wallet.some((identifier) => nativeNode(snapshot, identifier))) {
+      await session.execute('ui.press', { test_id: IDS.hamburger, timeout_ms: timeoutMs, settle: false });
+      continue;
+    }
+    await systemBack(session);
+  }
+  return (await waitForSnapshot(
+    session,
+    timeoutMs,
+    (snapshot) => visibleNode(snapshot, IDS.manager),
+    'The Mobile Networks settings screen did not open.',
+  )).snapshot;
+}
+
+export async function findNetwork(session, network, chainId, timeoutMs) {
+  const itemId = networkItemId(chainId);
+  let snapshot = await session.snapshot();
+  let item = visibleNode(snapshot, itemId);
+  if (!item) {
+    await session.execute('ui.set_input', {
+      test_id: IDS.search,
+      value: network,
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    snapshot = (await waitForSnapshot(
+      session,
+      timeoutMs,
+      (current) => visibleNode(current, itemId) ?? current.nodes.find((node) =>
+        nativeLabel(node).toLowerCase() === 'no networks found'
+      ),
+      `Mobile Networks search did not settle for ${network}.`,
+    )).snapshot;
+    item = visibleNode(snapshot, itemId);
+  }
+  if (!item) return null;
+  const label = nativeLabel(item);
+  if (label && !label.toLowerCase().includes(network.toLowerCase())) {
+    throw new Error(`${itemId} did not identify ${network}; observed ${JSON.stringify(label)}.`);
+  }
+  return { id: itemId, label: label || network };
+}
+
+export async function clearNetworkSearch(session, timeoutMs) {
+  const snapshot = await session.snapshot();
+  const search = nativeNode(snapshot, IDS.search);
+  const searchValue = nativeLabel(search);
+  if (!search || !searchValue || searchValue.toLowerCase() === 'search networks') return;
+  const clear = snapshot.nodes.find((node) =>
+    node.parentIndex === search.parentIndex &&
+    node.index > search.index &&
+    node.hittable === true &&
+    node.ref
+  );
+  if (!clear?.ref) {
+    throw new Error('Mobile Networks search did not expose a semantic clear control.');
+  }
+  await session.client.interactions.press({
+    ...session.selection,
+    ref: `@${clear.ref}`,
+    settle: true,
+    verify: true,
+    timeoutMs,
+    responseLevel: 'digest',
+  });
+  await waitForSnapshot(
+    session,
+    timeoutMs,
+    (current) => {
+      const value = nativeLabel(nativeNode(current, IDS.search));
+      return !value || value.toLowerCase() === 'search networks' ? true : null;
+    },
+    'Mobile Networks search did not clear.',
+  );
+}
+
+export { IDS };

package/library/actions/mobile/networks/read_visible_state.mjs

@@ -0,0 +1,43 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+} from '../platform/native-session.mjs';
+import { resolveVisibleNetworkOptions } from '../../shared/networks/visible-state.mjs';
+import { findNetwork, openNetworkManager } from './network-management.mjs';
+
+runAdapter(async (input) => {
+  const options = resolveVisibleNetworkOptions(input.node);
+  if (!options.chainId) {
+    throw new Error('metamask.networks.read_visible_state requires chain_id on Mobile.');
+  }
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  const session = createNativeSession(input, 'Networks', `read-${process.pid}`);
+  try {
+    await session.open();
+    await openNetworkManager(session, timeoutMs);
+    const item = await findNetwork(session, options.network, options.chainId, timeoutMs);
+    if (!item) {
+      throw new Error(`${options.network}${options.chainId ? ` (${options.chainId})` : ''} was absent from Mobile Networks settings.`);
+    }
+    if (options.settleMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, options.settleMs));
+      if (!await findNetwork(session, options.network, options.chainId, timeoutMs)) {
+        throw new Error(`${options.network} did not persist across the settle window.`);
+      }
+    }
+    return {
+      action: input.action,
+      source: 'visible-ui',
+      platform: 'mobile',
+      network: options.network,
+      ...(options.chainId ? { chainId: options.chainId } : {}),
+      item,
+      settleMs: options.settleMs,
+      stable: true,
+      proofPath: 'native-accessibility-network-settings',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/networks/remove_custom.mjs

@@ -0,0 +1,100 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+import {
+  findNetwork,
+  openNetworkManager,
+  waitForSnapshot,
+} from './network-management.mjs';
+
+runAdapter(async (input) => {
+  const network = String(input.node?.network ?? '').trim();
+  const chainId = Number(input.node?.chain_id);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!network || !Number.isInteger(chainId) || chainId <= 0) {
+    throw new Error('metamask.networks.remove_custom requires network and positive chain_id.');
+  }
+
+  const session = createNativeSession(input, 'Networks', `remove-${process.pid}`);
+  try {
+    await session.open();
+    await openNetworkManager(session, timeoutMs);
+    const item = await findNetwork(session, network, chainId, timeoutMs);
+    if (!item) throw new Error(`${network} (${chainId}) is not present for removal.`);
+    await session.execute('ui.press', { test_id: item.id, timeout_ms: timeoutMs, settle: false });
+    const details = await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => {
+        const container = nativeNode(snapshot, 'network-details-view-container');
+        if (!container) return null;
+        const labeled = snapshot.nodes.find((node) =>
+          node.hittable === true && /delete|remove|trash/iu.test(nativeLabel(node))
+        );
+        if (labeled) return labeled;
+        const unlabeled = snapshot.nodes.filter((node) =>
+          node.parentIndex === container.index &&
+          node.hittable === true &&
+          /ViewGroup$/u.test(String(node.type)) &&
+          !node.identifier &&
+          !nativeLabel(node) &&
+          node.ref
+        );
+        return unlabeled.length === 1 ? unlabeled[0] : null;
+      },
+      `${network} details did not expose one unambiguous delete control.`,
+    );
+    const deleteControl = details.value;
+    if (deleteControl?.identifier) {
+      await session.execute('ui.press', {
+        test_id: deleteControl.identifier,
+        timeout_ms: timeoutMs,
+        settle: false,
+      });
+    } else if (deleteControl?.ref) {
+      await session.client.interactions.press({
+        ...session.selection,
+        ref: `@${deleteControl.ref}`,
+        settle: true,
+        verify: true,
+        timeoutMs,
+        responseLevel: 'digest',
+      });
+    } else {
+      throw new Error('The custom-network details header did not expose one unambiguous delete control.');
+    }
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'networks-settings-delete-confirm-button'),
+      `The ${network} delete confirmation did not open.`,
+    );
+    await session.execute('ui.press', {
+      test_id: 'networks-settings-delete-confirm-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'networks-settings-container'),
+      'Mobile Networks settings did not reopen after deletion.',
+    );
+    if (await findNetwork(session, network, chainId, timeoutMs)) {
+      throw new Error(`${network} (${chainId}) remained after deletion.`);
+    }
+    return {
+      action: input.action,
+      network,
+      chainId,
+      removed: true,
+      proofPath: 'native-accessibility-network-settings-removal',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/perps/search_markets.mjs

@@ -0,0 +1,46 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+runAdapter(async (input) => {
+  const query = String(input.node?.query ?? '').trim();
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!query) throw new Error('metamask.perps.search_markets requires a non-empty query.');
+  const session = createNativeSession(input, 'Perps', `market-search-${process.pid}`);
+  try {
+    await session.open();
+    await session.execute('ui.set_input', {
+      test_id: 'perps-market-list-search-bar',
+      value: query,
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    const deadline = Date.now() + timeoutMs;
+    let snapshot;
+    let marketIds = [];
+    while (Date.now() <= deadline) {
+      snapshot = await session.snapshot();
+      marketIds = snapshot.nodes
+        .map((node) => String(node.identifier ?? ''))
+        .filter((id) => /^perps-market-row-item-(?!.*(?:-asset-label|-token-logo)$)/u.test(id));
+      const field = nativeNode(snapshot, 'perps-market-list-search-bar');
+      if (nativeLabel(field).toLowerCase().includes(query.toLowerCase()) && marketIds.length > 0) break;
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    if (marketIds.length === 0) {
+      throw new Error(`Perps market search returned no visible rows for ${JSON.stringify(query)}.`);
+    }
+    return {
+      action: input.action,
+      query,
+      marketIds: marketIds.slice(0, 100),
+      proofPath: 'native-accessibility-search',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/perps/set_market_favorite.mjs

@@ -0,0 +1,117 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+const FAVORITE_IDS = [
+  'perps-market-header-favorite-button',
+  'perps-pro-market-header-favorite-button',
+];
+
+function favoriteControl(snapshot) {
+  for (const testId of FAVORITE_IDS) {
+    const node = nativeNode(snapshot, testId);
+    if (/(?:add to|remove from) watchlist/iu.test(nativeLabel(node))) {
+      return { node, testId };
+    }
+  }
+  return null;
+}
+
+function favoriteState(control) {
+  const label = nativeLabel(control?.node);
+  if (/remove from watchlist/iu.test(label)) return true;
+  if (/add to watchlist/iu.test(label)) return false;
+  throw new Error(`Perps favorite control has an unsupported label: ${JSON.stringify(label)}.`);
+}
+
+runAdapter(async (input) => {
+  const market = String(input.node?.market ?? '').trim().toUpperCase();
+  const desired = input.node?.favorite;
+  const requireUnchanged = input.node?.require_unchanged === true;
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!/^[A-Z0-9:_-]{2,20}$/u.test(market)) {
+    throw new Error('metamask.perps.set_market_favorite requires a valid market symbol.');
+  }
+  if (typeof desired !== 'boolean') {
+    throw new Error('metamask.perps.set_market_favorite requires favorite=true or false.');
+  }
+  let session = createNativeSession(input, 'Perps', `favorite-${process.pid}`);
+  try {
+    await session.open();
+    let snapshot = await session.snapshot();
+    const subtitle = nativeLabel(
+      nativeNode(snapshot, 'perps-market-header-subtitle')
+      ?? nativeNode(snapshot, 'perps-pro-market-header-subtitle'),
+    ).toUpperCase();
+    if (!subtitle.startsWith(`${market}-`)) {
+      throw new Error(`Visible Perps market ${JSON.stringify(subtitle)} does not match ${market}.`);
+    }
+    let control = favoriteControl(snapshot);
+    if (!control && nativeNode(snapshot, 'perps-mode-toggle-lite')?.enabled !== false) {
+      try {
+        await session.execute('ui.press', {
+          test_id: 'perps-mode-toggle-lite',
+          timeout_ms: timeoutMs,
+          settle: false,
+        });
+      } catch (error) {
+        if (!/Selector did not match/iu.test(String(error?.message ?? error))) throw error;
+      }
+    }
+    const controlDeadline = Date.now() + timeoutMs;
+    let lastControls = [];
+    while (Date.now() <= controlDeadline && !control) {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      snapshot = await session.snapshot();
+      lastControls = snapshot.nodes
+        .filter((node) => /(?:favorite|mode-toggle|market-header)/iu.test(String(node.identifier ?? '')))
+        .map((node) => ({ id: String(node.identifier ?? ''), label: nativeLabel(node) }))
+        .slice(0, 20);
+      control = favoriteControl(snapshot);
+    }
+    if (!control) {
+      throw new Error(`Perps favorite control is not visible in Lite or Pro mode; observed ${JSON.stringify(lastControls)}.`);
+    }
+    const before = favoriteState(control);
+    if (before !== desired) {
+      await session.execute('ui.press', {
+        test_id: control.testId,
+        timeout_ms: timeoutMs,
+        settle: false,
+      });
+      await closeNativeSession(session);
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      session = createNativeSession(input, 'Perps', `favorite-proof-${process.pid}`);
+      await session.open();
+    }
+    const deadline = Date.now() + timeoutMs;
+    let after = before;
+    while (Date.now() <= deadline) {
+      snapshot = await session.snapshot();
+      control = favoriteControl(snapshot);
+      if (control) after = favoriteState(control);
+      if (after === desired) break;
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    if (after !== desired) throw new Error(`Perps favorite state did not become ${desired}.`);
+    const changed = before !== after;
+    if (requireUnchanged && changed) {
+      throw new Error(`Perps favorite state for ${market} did not persist across navigation.`);
+    }
+    return {
+      action: input.action,
+      market,
+      requestedFavorite: desired,
+      changed,
+      before,
+      after,
+      proofPath: 'native-accessibility-watchlist',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/platform/native-session-name.mjs

@@ -1,5 +1,19 @@
+import path from 'node:path';
+
 export function nativeSessionName(env, device, app = 'io.metamask') {
   const configured = String(env.METAMASK_RECIPE_MOBILE_SESSION ?? '').trim();
   const source = configured || `mm-harness-${app}-${device}`;
   return source.replace(/[^A-Za-z0-9._-]/gu, '-').slice(0, 120);
 }
+
+export function nativeAgentDeviceStateDir(env, projectRoot, device) {
+  const configured = String(
+    env.FARMSLOT_AGENT_DEVICE_STATE_DIR ?? env.AGENT_DEVICE_STATE_DIR ?? '',
+  ).trim();
+  if (configured) return path.resolve(configured);
+  if (!String(projectRoot ?? '').trim()) {
+    throw new Error('Opaque Mobile UI execution requires a project root for Agent Device isolation.');
+  }
+  const deviceKey = String(device).replace(/[^A-Za-z0-9._-]/gu, '-');
+  return path.join(path.resolve(projectRoot), 'temp', 'recipe', 'runtime', 'agent-device', deviceKey);
+}

package/library/actions/mobile/platform/native-session.mjs

@@ -0,0 +1,59 @@
+import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
+import { createAgentDeviceClient } from 'agent-device';
+
+import {
+  nativeAgentDeviceStateDir,
+  nativeSessionName,
+} from './native-session-name.mjs';
+
+export function createNativeSession(input, domain, sessionSuffix = '') {
+  const env = { ...process.env, ...(input.context?.env ?? {}) };
+  const device = String(env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? '').trim();
+  if (!device) throw new Error(`Opaque Mobile ${domain} actions require one explicit Android device serial.`);
+  const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
+  const baseSession = nativeSessionName(env, device, app);
+  const session = sessionSuffix
+    ? `${baseSession}-${String(sessionSuffix).replace(/[^A-Za-z0-9._-]/gu, '-')}`.slice(0, 120)
+    : baseSession;
+  const stateDir = nativeAgentDeviceStateDir(env, input.context.projectRoot, device);
+  const client = createAgentDeviceClient({ session, stateDir, lockPolicy: 'reject', lockPlatform: 'android' });
+  const selection = { platform: 'android', target: 'mobile', serial: device, session };
+  const transport = createAgentDeviceUiTransport({ platform: 'android', device, app, session, stateDir, client });
+  const context = {
+    nodeId: String(input.context?.nodeId ?? 'action'),
+    projectRoot: input.context.projectRoot,
+    artifactsDir: input.context.artifactsDir,
+    env,
+  };
+  return {
+    client,
+    transport,
+    selection,
+    context,
+    app,
+    open: () => client.apps.open({ ...selection, app, noRecord: true }),
+    execute: (action, node) => transport.execute(action, node, context),
+    snapshot: () => client.capture.snapshot({ ...selection, app, interactiveOnly: false, forceFull: true }),
+  };
+}
+
+export async function closeNativeSession(session) {
+  try {
+    await session.transport.close();
+  } catch (error) {
+    if (!/No active session|SESSION_NOT_FOUND/iu.test(String(error?.message ?? error))) throw error;
+  }
+  try {
+    await session.client.sessions.close();
+  } catch (error) {
+    if (!/No active session|SESSION_NOT_FOUND/iu.test(String(error?.message ?? error))) throw error;
+  }
+}
+
+export function nativeNode(snapshot, identifier) {
+  return snapshot.nodes.find((node) => String(node.identifier ?? '') === identifier);
+}
+
+export function nativeLabel(node) {
+  return String(node?.label ?? node?.value ?? '').replace(/\s+/gu, ' ').trim();
+}

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

@@ -3,7 +3,10 @@ import { promisify } from 'node:util';
 import { createAgentDeviceClient } from 'agent-device';
 
 import { bridgeCommand } from './bridge.mjs';
-import { nativeSessionName } from './native-session-name.mjs';
+import {
+  nativeAgentDeviceStateDir,
+  nativeSessionName,
+} from './native-session-name.mjs';
 import { mobileToolRecovery, resolveMobileToolPath } from './tool-paths.mjs';
 
 const execFileAsync = promisify(execFile);
@@ -67,6 +70,9 @@ async function readNativeHierarchy(payload, context) {
     ...process.env,
     ...record(context?.env),
   };
+  if (String(context?.projectRoot ?? '').trim()) {
+    env.METAMASK_RECIPE_PROJECT_ROOT = String(context.projectRoot);
+  }
   const platform = resolvePlatform(node, env);
   if (platform === 'android') return readAndroidHierarchy(node, env);
   return readIosHierarchy(node, env);
@@ -143,8 +149,10 @@ async function readAndroidHierarchy(node, env) {
 async function readAndroidAgentDeviceHierarchy(serial, env) {
   const app = text(env.ANDROID_PACKAGE_ID) ?? 'io.metamask';
   const session = nativeSessionName(env, serial, app);
+  const stateDir = nativeAgentDeviceStateDir(env, env.METAMASK_RECIPE_PROJECT_ROOT ?? process.cwd(), serial);
   const client = createAgentDeviceClient({
     session,
+    stateDir,
     lockPolicy: 'reject',
     lockPlatform: 'android',
   });

package/library/actions/mobile/swap_bridge/native-session.mjs

@@ -1,45 +1,10 @@
-import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
-import { createAgentDeviceClient } from 'agent-device';
-import { nativeSessionName } from '../platform/native-session-name.mjs';
-
-export function createSwapNativeSession(input) {
-  const env = { ...process.env, ...(input.context?.env ?? {}) };
-  const device = String(env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? '').trim();
-  if (!device) throw new Error('Opaque Mobile Swap actions require 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 ?? 'action'),
-    projectRoot: input.context.projectRoot,
-    artifactsDir: input.context.artifactsDir,
-    env,
-  };
-  return {
-    client,
-    transport,
-    selection,
-    context,
-    app,
-    execute: (action, node) => transport.execute(action, node, context),
-    snapshot: () => client.capture.snapshot({ ...selection, app, interactiveOnly: false, forceFull: true }),
-  };
-}
-
-export async function closeSwapNativeSession(session) {
-  try {
-    await session.transport.close();
-  } catch (error) {
-    if (!/No active session|SESSION_NOT_FOUND/iu.test(String(error?.message ?? error))) throw error;
-  }
-}
-
-export function nativeNode(snapshot, identifier) {
-  return snapshot.nodes.find((node) => String(node.identifier ?? '') === identifier);
-}
-
-export function nativeLabel(node) {
-  return String(node?.label ?? node?.value ?? '').replace(/\s+/gu, ' ').trim();
-}
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+export { nativeLabel, nativeNode };
+export const createSwapNativeSession = (input) => createNativeSession(input, 'Swap');
+export const closeSwapNativeSession = closeNativeSession;

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

@@ -21,11 +21,17 @@ function androidChainId(chain) {
   return match ? `0x${Number(match[1]).toString(16)}` : String(chain);
 }
 
+function chainFilter(chain) {
+  return {
+    'eip155:1': 'Ethereum',
+    'eip155:42161': 'Arbitrum',
+  }[chain] ?? 'All';
+}
+
 async function selectAsset(session, role, asset, timeoutMs, pickerAlreadyOpen = false) {
   const picker = role === 'source' ? 'source-token-area' : 'dest-token-area';
   if (!pickerAlreadyOpen) await session.execute('ui.press', { test_id: picker, timeout_ms: timeoutMs });
   await waitFor(session, 'bridge-token-search-input', timeoutMs);
-  await session.execute('ui.press', { text: 'All', timeout_ms: timeoutMs });
   await session.execute('ui.set_input', {
     test_id: 'bridge-token-search-input',
     value: asset.query,
@@ -33,6 +39,14 @@ async function selectAsset(session, role, asset, timeoutMs, pickerAlreadyOpen =
   });
   const row = `asset-${androidChainId(asset.chain)}-${asset.symbol}`;
   await session.execute('ui.key_press', { key: 'BACK', timeout_ms: timeoutMs });
+  let snapshot = await session.snapshot();
+  const filter = chainFilter(asset.chain);
+  if (
+    !nativeNode(snapshot, row) &&
+    snapshot.nodes.some((node) => node.visibleToUser !== false && nativeLabel(node) === filter)
+  ) {
+    await session.execute('ui.press', { text: filter, timeout_ms: timeoutMs });
+  }
   await revealAssetRow(session, row, timeoutMs);
   await session.execute('ui.press', { test_id: row, timeout_ms: timeoutMs });
   await waitFor(session, picker, timeoutMs);

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

@@ -60,7 +60,7 @@ runAdapter(async (input) => {
       if (!options.waitForQuote || observed.noQuote || (Number(destinationAmount) > 0 && cta)) break;
       await new Promise((resolve) => setTimeout(resolve, 250));
     } while (Date.now() < deadline);
-    if (observed.sourceAmount !== options.amount) {
+    if (Number(observed.sourceAmount) !== Number(options.amount)) {
       throw new Error(`Swap source amount mismatch: expected ${options.amount}, observed ${observed.sourceAmount}.`);
     }
     if (options.waitForQuote && !observed.noQuote && !(Number(observed.destinationAmount) > 0 && observed.cta)) {