@deeeed/metamask-harness 0.38.1 → 0.40.0

package/library/actions/extension/wallet/visible-session.mjs

@@ -0,0 +1,218 @@
+import { createHash } from 'node:crypto';
+
+const ACCOUNT_SEARCH = 'input[data-testid="multichain-account-list-search"], [data-testid="multichain-account-list-search"] input';
+const ONBOARDING_COMPLETE = '[data-testid="onboarding-complete-done"]';
+const HOME_BOUNDARY = '[data-testid="bottom-nav-home"], [data-testid="account-overview__asset-tab"]';
+
+async function hasVisibleSelector(page, selector, deadline) {
+  const expression = `(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return false;
+    const style = getComputedStyle(element);
+    const rect = element.getBoundingClientRect();
+    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+  })()`;
+  if (deadline === undefined) return page.evaluate(expression);
+  const result = await page.session.call('Runtime.evaluate', {
+    expression,
+    awaitPromise: true,
+    returnByValue: true,
+  }, { timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())) });
+  if (result.exceptionDetails) throw new Error('Visible wallet selector probe failed.');
+  return result.result?.value === true;
+}
+
+export async function dismissVisibleOnboardingCompletion(page) {
+  if (!(await hasVisibleSelector(page, ONBOARDING_COMPLETE))) return false;
+  await page.click(ONBOARDING_COMPLETE);
+  return true;
+}
+
+function accountProbeAddress(expectedAddress) {
+  const replacement = expectedAddress.endsWith('0') ? '1' : '0';
+  return `${expectedAddress.slice(0, -1)}${replacement}`;
+}
+
+async function currentRoute(page, deadline) {
+  const history = await page.session.call('Page.getNavigationHistory', {}, {
+    timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())),
+  });
+  const url = String(history.entries?.[history.currentIndex]?.url ?? '');
+  const route = new URL(url).hash.split('?')[0];
+  return route.replace(/0x[0-9a-f]{40}/giu, '<redacted-address>').slice(0, 200);
+}
+
+async function routeError(page, message, deadline) {
+  let route = '<deadline-expired>';
+  if (Date.now() < deadline) {
+    try {
+      route = await currentRoute(page, deadline);
+    } catch {
+      route = '<unavailable>';
+    }
+  }
+  return new Error(`${message} (route ${JSON.stringify(route)}).`);
+}
+
+async function visibleAccountMatch(page, deadline) {
+  const result = await page.session.call('Runtime.evaluate', {
+    expression: `(() => {
+    const input = document.querySelector(${JSON.stringify(ACCOUNT_SEARCH)});
+    const query = String(input?.value || '').trim().toLowerCase();
+    const rows = [...document.querySelectorAll('.multichain-account-cell[data-testid^="multichain-account-cell-"]')]
+      .filter((element) => {
+        const style = getComputedStyle(element);
+        const rect = element.getBoundingClientRect();
+        return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+      });
+    const row = rows.length === 1 ? rows[0] : null;
+    const accountName = String(row?.querySelector('.multichain-account-cell__account-name')?.textContent || '')
+      .trim()
+      .toLowerCase();
+    return {
+      query,
+      count: rows.length,
+      testId: row?.getAttribute('data-testid') || null,
+      selected: Boolean(row?.classList.contains('is-selected')),
+      addressMatchedBySearch: Boolean(/^0x[0-9a-f]{40}$/u.test(query) && !accountName.includes(query)),
+    };
+  })()`,
+    awaitPromise: true,
+    returnByValue: true,
+  }, { timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())) });
+  if (result.exceptionDetails || !result.result?.value) {
+    throw new Error('Visible wallet account probe failed.');
+  }
+  return result.result.value;
+}
+
+async function navigateHashThroughPage(page, hash, deadline) {
+  const pathname = new URL(String(page.target?.url ?? `${page.origin}/home.html`)).pathname;
+  const walletPath = pathname === '/sidepanel.html' ? pathname : '/home.html';
+  await page.session.call('Page.navigate', { url: `${page.origin}${walletPath}${hash}` }, {
+    timeoutMs: Math.min(1000, Math.max(1, deadline - Date.now())),
+  });
+}
+
+async function withinDeadline(promise, deadline) {
+  const timeoutMs = Math.max(1, deadline - Date.now());
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('Visible wallet stage exceeded its shared deadline.')), timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function leavePerpsForWalletHome(page, deadline) {
+  if (!(await currentRoute(page, deadline)).includes('/perps')) return;
+  while (Date.now() <= deadline) {
+    try {
+      await navigateHashThroughPage(page, '#/', deadline);
+      if (await hasVisibleSelector(page, HOME_BOUNDARY, deadline)) return;
+    } catch {
+      // Retry within the shared deadline while the authenticated Home surface settles.
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw await routeError(page, 'Visible wallet session did not reach Home before account-list navigation', deadline);
+}
+
+async function openAccountList(page, deadline) {
+  await leavePerpsForWalletHome(page, deadline);
+  while (Date.now() <= deadline) {
+    try {
+      await navigateHashThroughPage(page, '#/account-list', deadline);
+      if (await hasVisibleSelector(page, ACCOUNT_SEARCH, deadline)) return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  throw await routeError(page, 'Visible wallet session did not reach the authenticated account list', deadline);
+}
+
+async function proveAddressSearchControl(page, expectedAddress, deadline) {
+  const probeAddress = accountProbeAddress(expectedAddress);
+  try {
+    await withinDeadline(page.setInput(ACCOUNT_SEARCH, probeAddress), deadline);
+  } catch {
+    throw await routeError(page, 'Visible wallet account search could not enter the alternate-address control', deadline);
+  }
+  let consecutiveEmpty = 0;
+  while (Date.now() <= deadline) {
+    let observed;
+    try {
+      observed = await visibleAccountMatch(page, deadline);
+    } catch {
+      throw await routeError(page, 'Visible wallet alternate-address result did not become readable', deadline);
+    }
+    if (observed.query === probeAddress && observed.count === 0) {
+      consecutiveEmpty += 1;
+      if (consecutiveEmpty === 2) return;
+    } else {
+      consecutiveEmpty = 0;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw await routeError(page, 'Visible wallet account search did not reject the alternate address control', deadline);
+}
+
+async function queryExpectedAccount(page, expectedAddress, deadline, requireSelected) {
+  await proveAddressSearchControl(page, expectedAddress, deadline);
+  try {
+    await withinDeadline(page.setInput(ACCOUNT_SEARCH, expectedAddress), deadline);
+  } catch {
+    throw await routeError(page, 'Visible wallet account search could not enter the derived release identity', deadline);
+  }
+  let observed;
+  while (Date.now() <= deadline) {
+    try {
+      observed = await visibleAccountMatch(page, deadline);
+    } catch {
+      throw await routeError(page, 'Visible wallet derived-account result did not become readable', deadline);
+    }
+    const exactMatch = observed.query === expectedAddress &&
+      observed.count === 1 &&
+      observed.testId &&
+      observed.addressMatchedBySearch;
+    if (exactMatch && (!requireSelected || observed.selected)) return observed;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (requireSelected) {
+    throw await routeError(page, 'Visible wallet session did not converge to the derived release account', deadline);
+  }
+  throw await routeError(page, 'Visible wallet session did not resolve the derived release account to one rendered account row', deadline);
+}
+
+export async function ensureVisibleSelectedAccount(page, expectedAddress, timeoutMs) {
+  if (!/^0x[0-9a-f]{40}$/u.test(expectedAddress)) {
+    throw new Error('Visible wallet session requires a derived EVM account address.');
+  }
+  const deadline = Date.now() + timeoutMs;
+  await openAccountList(page, deadline);
+  const initial = await queryExpectedAccount(page, expectedAddress, deadline, false);
+  let selectionPerformed = false;
+  if (!initial.selected) {
+    selectionPerformed = true;
+    try {
+      await withinDeadline(page.click(`[data-testid=${JSON.stringify(initial.testId)}]`), deadline);
+    } catch {
+      throw await routeError(page, 'Visible wallet session could not select the derived release account', deadline);
+    }
+  }
+
+  await openAccountList(page, deadline);
+  await queryExpectedAccount(page, expectedAddress, deadline, true);
+  return {
+    selectedIdentitySha256: createHash('sha256').update(expectedAddress).digest('hex'),
+    selectedAddressMatched: true,
+    selectionPerformed,
+    accountSurface: 'visible-account-list',
+    redacted: true,
+  };
+}

package/library/actions/mobile/assets/import_custom_token.mjs

@@ -0,0 +1,181 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+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 openCustomToken(session, timeoutMs) {
+  let snapshot = await session.snapshot();
+  if (nativeNode(snapshot, 'input-token-address')) return snapshot;
+  if (!nativeNode(snapshot, 'add-token-screen')) {
+    if (!nativeNode(snapshot, 'token-list')) {
+      await session.execute('ui.press', {
+        test_id: 'homepage-section-title-tokens',
+        timeout_ms: timeoutMs,
+        settle: false,
+      });
+      await waitForSnapshot(
+        session,
+        timeoutMs,
+        (current) => nativeNode(current, 'token-list'),
+        'The Mobile token list did not open.',
+      );
+    }
+    await session.execute('ui.press', {
+      test_id: 'import-token-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    snapshot = (await waitForSnapshot(
+      session,
+      timeoutMs,
+      (current) => nativeNode(current, 'add-token-screen'),
+      'The Mobile token import screen did not open.',
+    )).snapshot;
+  }
+  if (!nativeNode(snapshot, 'input-token-address')) {
+    await session.execute('ui.press', { text: 'Custom token', timeout_ms: timeoutMs, settle: false });
+    snapshot = (await waitForSnapshot(
+      session,
+      timeoutMs,
+      (current) => nativeNode(current, 'input-token-address'),
+      'The Mobile custom-token form did not open.',
+    )).snapshot;
+  }
+  return snapshot;
+}
+
+async function selectNetwork(session, network, timeoutMs) {
+  let snapshot = await session.snapshot();
+  const selected = (current) =>
+    nativeNode(current, 'select-network-button') &&
+    current.nodes.some((node) => node.visibleToUser !== false && nativeLabel(node) === network);
+  if (selected(snapshot)) return;
+  await session.execute('ui.press', {
+    test_id: 'select-network-button',
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+  await waitForSnapshot(
+    session,
+    timeoutMs,
+    (current) => current.nodes.find((node) =>
+      node.visibleToUser !== false && node.hittable === true && nativeLabel(node) === network
+    ),
+    `${network} was not available in the Mobile token network selector.`,
+  );
+  await session.execute('ui.press', { text: network, timeout_ms: timeoutMs, settle: false });
+  snapshot = (await waitForSnapshot(
+    session,
+    timeoutMs,
+    selected,
+    `The Mobile token importer did not select ${network}.`,
+  )).snapshot;
+  return snapshot;
+}
+
+async function findTokenRow(session, symbol, timeoutMs) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const snapshot = await session.snapshot();
+    const row = nativeNode(snapshot, `asset-${symbol}`);
+    if (row) return row;
+    await session.execute('ui.scroll', {
+      direction: 'down',
+      amount: 0.75,
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+  }
+  throw new Error(`${symbol} did not appear in the Mobile token list after import.`);
+}
+
+runAdapter(async (input) => {
+  const network = String(input.node?.network ?? '').trim();
+  const chainId = Number(input.node?.chain_id);
+  const address = String(input.node?.address ?? '').trim();
+  const expectedSymbol = String(input.node?.expected_symbol ?? '').trim().toUpperCase();
+  const expectedDecimals = input.node?.decimals == null ? null : String(input.node.decimals);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 60_000);
+  if (!network || !Number.isInteger(chainId) || chainId <= 0 || !/^0x[0-9a-f]{40}$/iu.test(address) || !expectedSymbol) {
+    throw new Error('metamask.assets.import_custom_token requires network, positive chain_id, ERC-20 address, and expected_symbol.');
+  }
+
+  const session = createNativeSession(input, 'Assets', `custom-token-${process.pid}`);
+  try {
+    await session.open();
+    await openCustomToken(session, timeoutMs);
+    await selectNetwork(session, network, timeoutMs);
+    await openCustomToken(session, timeoutMs);
+    await session.execute('ui.set_input', {
+      test_id: 'input-token-address',
+      value: address,
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    const metadata = (await waitForSnapshot(
+      session,
+      Math.min(timeoutMs, 20_000),
+      (snapshot) => {
+        const symbol = nativeLabel(nativeNode(snapshot, 'input-token-symbol'));
+        const decimals = nativeLabel(nativeNode(snapshot, 'input-token-decimal'));
+        return symbol ? { symbol, decimals } : null;
+      },
+      'Mobile custom-token metadata did not resolve.',
+    )).value;
+    if (metadata.symbol.toUpperCase() !== expectedSymbol) {
+      throw new Error(`Expected token symbol ${expectedSymbol}, but Mobile metadata resolved ${metadata.symbol}.`);
+    }
+    if (expectedDecimals !== null && metadata.decimals !== expectedDecimals) {
+      throw new Error(`Expected token decimals ${expectedDecimals}, but Mobile metadata resolved ${metadata.decimals}.`);
+    }
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'token-import-next-button')?.enabled === true,
+      'Mobile custom-token metadata did not enable the import action.',
+    );
+    await session.execute('ui.press', {
+      test_id: 'token-import-next-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'add-confirm-custom-asset'),
+      'The Mobile custom-token confirmation did not open.',
+    );
+    await session.execute('ui.press', { text: 'Import', timeout_ms: timeoutMs, settle: false });
+    await waitForSnapshot(
+      session,
+      timeoutMs,
+      (snapshot) => nativeNode(snapshot, 'token-list'),
+      'The Mobile token list did not reopen after import.',
+    );
+    const token = await findTokenRow(session, expectedSymbol, timeoutMs);
+    return {
+      action: input.action,
+      network,
+      chainId,
+      address,
+      metadata,
+      token: nativeLabel(token),
+      proofPath: 'native-accessibility-custom-token-import',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/assets/open_details.mjs

@@ -0,0 +1,43 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+runAdapter(async (input) => {
+  const symbol = String(input.node?.symbol ?? '').trim().toUpperCase();
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!/^[A-Z0-9._-]{2,20}$/u.test(symbol)) {
+    throw new Error('metamask.assets.open_details requires a valid token symbol.');
+  }
+  const session = createNativeSession(input, 'Assets', `details-${process.pid}`);
+  try {
+    await session.open();
+    let snapshot = await session.snapshot();
+    if (!nativeNode(snapshot, 'token-asset-overview')) {
+      await session.execute('ui.press', {
+        test_id: `asset-${symbol}`,
+        timeout_ms: timeoutMs,
+        settle: false,
+      });
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+      snapshot = await session.snapshot();
+      const symbolVisible = snapshot.nodes.some((node) => nativeLabel(node).toUpperCase() === symbol);
+      if (nativeNode(snapshot, 'token-asset-overview') && symbolVisible) {
+        return {
+          action: input.action,
+          symbol,
+          proofPath: 'native-accessibility-token-details-navigation',
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    throw new Error(`Asset details for ${symbol} did not become visible.`);
+  } finally {
+    await closeNativeSession(session);
+  }
+});

package/library/actions/mobile/assets/read_details.mjs

@@ -0,0 +1,96 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import {
+  closeNativeSession,
+  createNativeSession,
+  nativeLabel,
+  nativeNode,
+} from '../platform/native-session.mjs';
+
+const NON_SYMBOL_LABELS = new Set([
+  'BUY',
+  'COPY',
+  'MORE',
+  'RECEIVE',
+  'SEND',
+  'SHARE',
+  'SWAP',
+]);
+
+function observedSymbol(labels, expectedSymbol) {
+  if (expectedSymbol) {
+    return labels.find((label) => label.toUpperCase() === expectedSymbol) ?? null;
+  }
+  return labels.find((label) => {
+    const candidate = label.trim();
+    return candidate === candidate.toUpperCase()
+      && /^[A-Z][A-Z0-9._-]{1,19}$/u.test(candidate)
+      && !NON_SYMBOL_LABELS.has(candidate);
+  }) ?? null;
+}
+
+runAdapter(async (input) => {
+  const expectedSymbol = String(input.node?.expected_symbol ?? '').trim().toUpperCase();
+  const requireChart = input.node?.require_chart === true;
+  const requireMarketCap = input.node?.require_market_cap === true;
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  const session = createNativeSession(input, 'Assets', `read-details-${process.pid}`);
+  try {
+    await session.open();
+    const deadline = Date.now() + timeoutMs;
+    let snapshot;
+    let labels = [];
+    let symbol = null;
+    let price = null;
+    let chartRendered = false;
+    let chartEmpty = false;
+    let marketCap = null;
+    let malformed = false;
+    while (Date.now() <= deadline) {
+      snapshot = await session.snapshot();
+      labels = snapshot.nodes.map(nativeLabel).filter(Boolean);
+      symbol = observedSymbol(labels, expectedSymbol);
+      price = nativeLabel(nativeNode(snapshot, 'token-price')) || null;
+      chartRendered = Boolean(
+        nativeNode(snapshot, 'chart_surface')
+        ?? nativeNode(snapshot, 'tv_chart_container'),
+      );
+      chartEmpty = labels.some((label) => /no chart data/iu.test(label));
+      marketCap = labels.find((label) => /market cap/iu.test(label)) ?? null;
+      malformed = labels.some((label) => /(?:\bNaN\b|\bundefined\b|\bnull\b)/u.test(label));
+      const ready = nativeNode(snapshot, 'token-asset-overview') && symbol && price
+        && (!requireChart || chartRendered || chartEmpty)
+        && (!requireMarketCap || marketCap);
+      if (ready) break;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    if (!nativeNode(snapshot, 'token-asset-overview')) {
+      throw new Error('Expected the visible Mobile token details surface.');
+    }
+    if (expectedSymbol && !symbol) {
+      throw new Error(`Expected ${expectedSymbol} asset details, but the symbol was not visible.`);
+    }
+    if (!price) throw new Error('Expected a formatted current token price.');
+    if (requireChart && (!chartRendered || chartEmpty)) {
+      throw new Error('Expected a rendered asset price chart without an empty state.');
+    }
+    if (requireMarketCap && !marketCap) {
+      throw new Error('Expected a formatted asset market cap.');
+    }
+    if (malformed) throw new Error('Asset details contain a malformed visible value.');
+    return {
+      action: input.action,
+      source: 'visible-ui',
+      platform: 'mobile',
+      surface: 'asset-details',
+      symbol,
+      price,
+      marketCap,
+      chartRendered,
+      chartEmpty,
+      malformed,
+      proofPath: 'native-accessibility-token-details',
+    };
+  } finally {
+    await closeNativeSession(session);
+  }
+});