@deeeed/metamask-harness 0.37.0 → 0.38.0

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

@@ -0,0 +1,227 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+const OPTIONS = dataTestId('asset-list-control-bar-action-button');
+const MANAGE = dataTestId('manageTokens__button');
+const ADD = dataTestId('token-management-add-custom-token-button');
+const PAGE = dataTestId('custom-token-import-page');
+const NETWORK = dataTestId('network-selector');
+const ADDRESS = dataTestId('custom-token-import-address-input');
+const SYMBOL = dataTestId('custom-token-import-symbol-input');
+const DECIMALS = dataTestId('custom-token-import-decimal-input');
+const SUBMIT = dataTestId('custom-token-import-submit-button');
+const SUCCESS = dataTestId('token-management-custom-token-success-toast');
+const BACK = dataTestId('token-management-header-back-button');
+const LOW_VALUE = dataTestId('low-value-assets-toggle');
+
+async function visible(page, selector) {
+  return page.evaluate(`(() => {
+    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;
+  })()`);
+}
+
+async function waitFor(page, predicate, message, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const value = await predicate();
+    if (value) return value;
+    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 150))');
+  }
+  throw new Error(message);
+}
+
+async function visibleButton(page, label) {
+  const marker = `mm-harness-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const found = await page.evaluate(`(() => {
+    const label = ${JSON.stringify(label)};
+    const marker = ${JSON.stringify(marker)};
+    for (const element of document.querySelectorAll('button')) {
+      const text = String(element.innerText || element.textContent || '').replace(/\\s+/gu, ' ').trim();
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      if (text === label && style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0) {
+        element.setAttribute('data-mm-harness-target', marker);
+        return true;
+      }
+    }
+    return false;
+  })()`);
+  if (!found) throw new Error(`Visible button ${JSON.stringify(label)} was not found.`);
+  return `[data-mm-harness-target="${marker}"]`;
+}
+
+async function networkOption(page, network, chainId) {
+  return page.evaluate(`(() => {
+    const network = ${JSON.stringify(network.toLowerCase())};
+    const chainIds = new Set(${JSON.stringify([
+      String(chainId),
+      `0x${chainId.toString(16)}`,
+      `eip155:${chainId}`,
+    ].map((value) => value.toLowerCase()))});
+    for (const element of document.querySelectorAll('[data-testid^="network-list-item-"]')) {
+      const testId = String(element.getAttribute('data-testid') || '');
+      const suffix = testId.slice('network-list-item-'.length).toLowerCase();
+      const label = String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500);
+      if (chainIds.has(suffix) || label.toLowerCase().includes(network)) return { testId, label };
+    }
+    return null;
+  })()`);
+}
+
+async function homeToken(page, symbol) {
+  return page.evaluate(`(() => {
+    const symbol = ${JSON.stringify(symbol.toLowerCase())};
+    for (const row of document.querySelectorAll('[data-testid="multichain-token-list-button"]')) {
+      const name = String(row.querySelector('[data-testid="multichain-token-list-item-token-name"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
+      const amount = String(row.querySelector('[data-testid="multichain-token-list-item-value"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
+      const observed = amount.match(/\\b([A-Za-z][A-Za-z0-9]{1,11})$/u)?.[1] || '';
+      if (observed.toLowerCase() === symbol) return { name, symbol: observed.toUpperCase(), amount };
+    }
+    return null;
+  })()`);
+}
+
+async function importedTokenIdentity(page, chainId, address, expectedSymbol) {
+  return page.evaluate(`(async () => {
+    const hooks = globalThis.stateHooks || {};
+    const root = (await hooks.getCleanAppState?.()) || hooks.store?.getState?.() || {};
+    const state = root.metamask || root;
+    const allTokens = state.allTokens;
+    const selectedAddress = String(state.selectedAddress || '').toLowerCase();
+    if (!allTokens || typeof allTokens !== 'object' || !selectedAddress) {
+      return { available: false, token: null };
+    }
+    const expectedChainId = ${JSON.stringify(chainId)};
+    const chainEntry = Object.entries(allTokens).find(([key]) => {
+      const normalized = String(key).toLowerCase();
+      const value = normalized.startsWith('eip155:')
+        ? Number(normalized.slice('eip155:'.length))
+        : normalized.startsWith('0x')
+          ? Number.parseInt(normalized.slice(2), 16)
+          : Number(normalized);
+      return value === expectedChainId;
+    });
+    const accountEntry = chainEntry && Object.entries(chainEntry[1] || {})
+      .find(([account]) => String(account).toLowerCase() === selectedAddress);
+    const tokens = Array.isArray(accountEntry?.[1]) ? accountEntry[1] : [];
+    const expectedAddress = ${JSON.stringify(address.toLowerCase())};
+    const expectedSymbol = ${JSON.stringify(expectedSymbol)};
+    const token = tokens.find((entry) => {
+      const tokenAddress = String(entry?.address || entry?.contractAddress || '').toLowerCase();
+      return tokenAddress === expectedAddress && String(entry?.symbol || '').toUpperCase() === expectedSymbol;
+    });
+    return {
+      available: true,
+      token: token ? {
+        address: String(token.address || token.contractAddress),
+        symbol: String(token.symbol),
+        decimals: token.decimals == null ? null : String(token.decimals),
+        chainId: chainEntry?.[0] || null,
+      } : null,
+    };
+  })()`, { awaitPromise: true });
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  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 existingToken = await homeToken(page, expectedSymbol);
+  const existingIdentity = existingToken
+    ? await importedTokenIdentity(page, chainId, address, expectedSymbol)
+    : null;
+  if (existingToken && existingIdentity?.token) {
+    return {
+      action: input.action,
+      network,
+      chainId,
+      address,
+      alreadyImported: true,
+      token: existingToken,
+      identity: existingIdentity.token,
+      proofPath: 'trusted-pointer-visible-ui',
+    };
+  }
+
+  if (!(await visible(page, MANAGE))) await page.click(OPTIONS);
+  await waitFor(page, () => visible(page, MANAGE), 'Manage tokens did not become visible.', timeoutMs);
+  await page.click(await visibleButton(page, 'Manage tokens'));
+  await waitFor(page, () => visible(page, ADD), 'Add a custom token did not become visible.', timeoutMs);
+  await page.click(await visibleButton(page, 'Add a custom token'));
+  await waitFor(page, () => visible(page, PAGE), 'Custom token import did not open.', timeoutMs);
+  await page.click(NETWORK);
+  const selectedNetwork = await waitFor(
+    page,
+    () => networkOption(page, network, chainId),
+    `${network} (${chainId}) was not available in the custom token network selector.`,
+    timeoutMs,
+  );
+  await page.click(dataTestId(selectedNetwork.testId));
+  await waitFor(page, () => visible(page, ADDRESS), 'Custom token address input did not become visible.', timeoutMs);
+  await page.evaluate('new Promise((resolve) => setTimeout(resolve, 2000))');
+  await page.setInput(ADDRESS, address);
+
+  let metadataSource = 'network';
+  let metadata;
+  try {
+    metadata = await waitFor(page, async () => {
+      const state = await page.evaluate(`(() => ({
+        symbol: document.querySelector(${JSON.stringify(SYMBOL)})?.value || null,
+        decimals: document.querySelector(${JSON.stringify(DECIMALS)})?.value || null,
+        enabled: !document.querySelector(${JSON.stringify(SUBMIT)})?.disabled,
+      }))()`);
+      return state.symbol && state.enabled ? state : null;
+    }, 'Custom token metadata did not resolve to an enabled import.', Math.min(timeoutMs, 15_000));
+  } catch (error) {
+    if (expectedDecimals === null) throw error;
+    metadataSource = 'manual';
+    await page.setInput(SYMBOL, expectedSymbol);
+    await page.setInput(DECIMALS, expectedDecimals);
+    metadata = await waitFor(page, async () => {
+      const state = await page.evaluate(`(() => ({
+        symbol: document.querySelector(${JSON.stringify(SYMBOL)})?.value || null,
+        decimals: document.querySelector(${JSON.stringify(DECIMALS)})?.value || null,
+        enabled: !document.querySelector(${JSON.stringify(SUBMIT)})?.disabled,
+      }))()`);
+      return state.enabled ? state : null;
+    }, 'Manually supplied token metadata did not enable the import.', timeoutMs);
+  }
+  if (String(metadata.symbol).toUpperCase() !== expectedSymbol) {
+    throw new Error(`Expected token symbol ${expectedSymbol}, but metadata resolved ${metadata.symbol}.`);
+  }
+  await page.click(SUBMIT);
+  await waitFor(page, () => visible(page, SUCCESS), 'Custom token success confirmation did not appear.', timeoutMs);
+  await page.click(BACK);
+  await waitFor(page, () => visible(page, OPTIONS), 'Token list did not reopen.', timeoutMs);
+  if (await visible(page, LOW_VALUE)) {
+    const expanded = await page.evaluate(`document.querySelector(${JSON.stringify(LOW_VALUE)})?.getAttribute('aria-expanded') === 'true'`);
+    if (!expanded) await page.click(LOW_VALUE);
+  }
+  const token = await waitFor(
+    page,
+    () => homeToken(page, expectedSymbol),
+    `${expectedSymbol} did not appear in the token list after import.`,
+    timeoutMs,
+  );
+
+  return {
+    action: input.action,
+    network: selectedNetwork.label || network,
+    chainId,
+    address,
+    metadata,
+    metadataSource,
+    token,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

package/library/actions/extension/assets/prepare_send.mjs

@@ -0,0 +1,53 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { selectors, tokenRow, visible, waitFor } from './send.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const symbol = String(input.node?.symbol || '').trim().toUpperCase();
+  const recipient = String(input.node?.recipient || '').trim();
+  const amount = input.node?.amount == null ? null : String(input.node.amount).trim();
+  const useMax = input.node?.max === true;
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!symbol || !/^0x[0-9a-f]{40}$/iu.test(recipient) || (useMax === (amount !== null))) {
+    throw new Error('metamask.assets.prepare_send requires symbol, EVM recipient, and exactly one of amount or max=true.');
+  }
+  const token = await waitFor(page, () => tokenRow(page, symbol), `${symbol} was not visible for send.`, timeoutMs);
+  await page.click(token.selector);
+  await waitFor(page, async () => {
+    const route = await page.evaluate('location.hash');
+    return /^#\/(?:asset|token)\//u.test(route) ? route : null;
+  }, `${symbol} asset details did not open.`, timeoutMs);
+  const sendControl = await waitFor(page, async () => {
+    for (const selector of [selectors.nativeSend, selectors.send]) {
+      if (await visible(page, selector)) return selector;
+    }
+    return null;
+  }, 'Asset Send did not become visible.', timeoutMs);
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  for (let attempt = 0; attempt < 3 && !(await visible(page, selectors.recipient)); attempt += 1) {
+    await page.click(sendControl);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  await waitFor(page, () => visible(page, selectors.recipient), 'Send recipient input did not become visible.', timeoutMs);
+  await page.setInput(selectors.recipient, recipient);
+  if (useMax) {
+    await page.clickText('Max');
+  } else {
+    await page.setInput(selectors.amount, amount);
+  }
+  const prepared = await waitFor(page, () => page.evaluate(`(() => {
+    const button = document.querySelector(${JSON.stringify(selectors.continue)});
+    const amount = document.querySelector(${JSON.stringify(selectors.amount)})?.value || '';
+    const balance = document.querySelector('[data-testid="send-amount-balance"]')?.innerText || '';
+    return button && !button.disabled ? { amount, balance } : null;
+  })()`), 'Prepared send did not enable Continue.', timeoutMs);
+  return {
+    action: input.action,
+    symbol,
+    recipient,
+    requestedAmount: amount,
+    max: useMax,
+    tokenBefore: token,
+    prepared,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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

@@ -0,0 +1,57 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+function clean(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.replace(/\s+/gu, ' ').trim();
+  return normalized ? normalized.slice(0, 500) : null;
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const expectedSymbol = clean(input.node?.expected_symbol)?.toUpperCase() ?? null;
+  const requireChart = input.node?.require_chart === true;
+  const requireMarketCap = input.node?.require_market_cap === true;
+  const raw = await page.evaluate(`(() => {
+    const text = (selector) => {
+      const value = document.querySelector(selector)?.innerText;
+      return typeof value === 'string' ? value.replace(/\\s+/gu, ' ').trim().slice(0, 500) : null;
+    };
+    const body = String(document.body?.innerText || '').replace(/\\s+/gu, ' ').trim();
+    const name = text('[data-testid="asset-name"]');
+    return {
+      route: String(location.hash),
+      name,
+      symbol: name?.match(/\\b[A-Za-z][A-Za-z0-9]{1,11}\\b/u)?.[0]?.toUpperCase() || null,
+      network: text('[data-testid="asset-network"]'),
+      marketCap: text('[data-testid="asset-market-cap"]'),
+      chartRendered: Boolean(document.querySelector('[data-testid="asset-price-chart"] canvas')),
+      chartEmpty: Boolean(document.querySelector('[data-testid="asset-chart-empty-state"]')),
+      malformed: /(?:\\bNaN\\b|\\bundefined\\b|\\bnull\\b)/u.test(body),
+      hasActivity: /\\bYour activity\\b/u.test(body),
+    };
+  })()`);
+
+  if (!raw.route.startsWith('#/asset/')) {
+    throw new Error(`Expected an asset details route, but observed ${raw.route || 'no route'}.`);
+  }
+  if (expectedSymbol && raw.symbol !== expectedSymbol) {
+    throw new Error(`Expected ${expectedSymbol} asset details, but observed ${raw.symbol || 'no symbol'}.`);
+  }
+  if (requireChart && (!raw.chartRendered || raw.chartEmpty)) {
+    throw new Error('Expected a rendered asset price chart without an empty state.');
+  }
+  if (requireMarketCap && !raw.marketCap) {
+    throw new Error('Expected a formatted asset market cap.');
+  }
+  if (raw.malformed) {
+    throw new Error('Asset details contain a malformed visible value.');
+  }
+
+  return {
+    action: input.action,
+    source: 'visible-ui',
+    platform: 'extension',
+    surface: 'asset-details',
+    ...raw,
+    proofPath: 'visible-dom-accessibility',
+  };
+}));

package/library/actions/extension/assets/read_visible_state.mjs

@@ -0,0 +1,50 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  normalizeVisibleAssetsState,
+  resolveVisibleAssetsOptions,
+} from '../../shared/assets/visible-state.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const options = resolveVisibleAssetsOptions(input.node);
+  const raw = await page.evaluate(`(() => {
+    const maximum = ${JSON.stringify(options.maxItems)};
+    const rows = [...document.querySelectorAll('[data-testid="multichain-token-list-button"]')]
+      .filter((element) => {
+        const style = getComputedStyle(element);
+        const rect = element.getBoundingClientRect();
+        return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+      })
+      .slice(0, maximum)
+      .map((element) => {
+        const change = element.querySelector('[data-testid^="token-increase-decrease-percentage-"]');
+        const changeClass = String(change?.className || '');
+        const priceChangeTone = changeClass.includes('color-error')
+          ? 'negative'
+          : changeClass.includes('color-success')
+            ? 'positive'
+            : changeClass.includes('color-text-default')
+              ? 'neutral'
+              : null;
+        return {
+        testId: element.getAttribute('data-testid'),
+        label: String(element.getAttribute('aria-label') || element.innerText || '').replace(/\\s+/gu, ' ').trim(),
+        name: element.querySelector('[data-testid="multichain-token-list-item-token-name"]')?.innerText,
+        fiat: element.querySelector('[data-testid="multichain-token-list-item-secondary-value"]')?.innerText,
+        amount: element.querySelector('[data-testid="multichain-token-list-item-value"]')?.innerText,
+        priceChange: change?.innerText,
+        priceChangeTone,
+        };
+      });
+    return {
+      route: location.hash,
+      title: document.title,
+      items: rows,
+      truncated: document.querySelectorAll('[data-testid="multichain-token-list-button"]').length > rows.length,
+    };
+  })()`);
+  return {
+    action: input.action,
+    ...normalizeVisibleAssetsState(raw, options, 'extension'),
+    proofPath: 'visible-dom-accessibility',
+  };
+}));

package/library/actions/extension/assets/review_send.mjs

@@ -0,0 +1,23 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { bodyState, selectors, visible, waitFor } from './send.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  await waitFor(page, () => visible(page, selectors.continue), 'Send Continue was not visible.', timeoutMs);
+  await page.click(selectors.continue);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline && !(await visible(page, selectors.confirm))) {
+    if (await visible(page, selectors.alert)) await page.click(selectors.alert);
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  await waitFor(page, () => visible(page, selectors.confirm), 'Send confirmation did not open.', timeoutMs);
+  const state = await bodyState(page);
+  if (!/\b(network fee|gas)\b/iu.test(state.text)) {
+    throw new Error('Send confirmation did not show a network fee.');
+  }
+  return {
+    action: input.action,
+    ...state,
+    proofPath: 'visible-dom-accessibility',
+  };
+}));

package/library/actions/extension/assets/select_network_scope.mjs

@@ -0,0 +1,30 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { openHome } from '../ui/navigate.mjs';
+import { visible, waitFor } from './send.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const scope = String(input.node?.scope || 'all').trim().toLowerCase();
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (scope !== 'all') {
+    throw new Error('metamask.assets.select_network_scope currently requires scope=all.');
+  }
+  await openHome(page, timeoutMs);
+  const filter = dataTestId('sort-by-networks');
+  const all = dataTestId('home-network-filter-all-default');
+  const selected = await waitFor(page, async () => {
+    const label = await page.evaluate(`String(document.querySelector(${JSON.stringify(filter)})?.innerText || '')`);
+    if (/All (?:default )?networks/iu.test(label)) return label;
+    if (await visible(page, all)) {
+      await page.click(all);
+    } else if (await visible(page, filter)) {
+      await page.click(filter);
+    }
+    return null;
+  }, 'All networks did not become selected.', timeoutMs);
+  return {
+    action: input.action,
+    scope,
+    selected,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

package/library/actions/extension/assets/send.mjs

@@ -0,0 +1,104 @@
+import { dataTestId } from '../platform/cdp.mjs';
+
+export async function visible(page, selector) {
+  return page.evaluate(`(() => {
+    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;
+  })()`);
+}
+
+export async function waitFor(page, predicate, message, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const value = await predicate();
+    if (value) return value;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error(message);
+}
+
+export async function tokenRow(page, symbol) {
+  const marker = `mm-harness-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return page.evaluate(`(() => {
+    const symbol = ${JSON.stringify(symbol.toUpperCase())};
+    const marker = ${JSON.stringify(marker)};
+    for (const row of document.querySelectorAll('[data-testid="multichain-token-list-button"]')) {
+      const amount = String(row.querySelector('[data-testid="multichain-token-list-item-value"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
+      const observed = amount.match(/\\b([A-Za-z][A-Za-z0-9]{1,11})$/u)?.[1]?.toUpperCase();
+      if (observed !== symbol) continue;
+      const style = getComputedStyle(row);
+      const rect = row.getBoundingClientRect();
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) continue;
+      row.setAttribute('data-mm-harness-target', marker);
+      return {
+        selector: '[data-mm-harness-target="' + marker + '"]',
+        name: String(row.querySelector('[data-testid="multichain-token-list-item-token-name"]')?.innerText || '').trim(),
+        amount,
+        fiat: String(row.querySelector('[data-testid="multichain-token-list-item-secondary-value"]')?.innerText || '').trim(),
+      };
+    }
+    return null;
+  })()`);
+}
+
+export async function bodyState(page) {
+  return page.evaluate(`(() => ({
+    route: location.hash,
+    text: String(document.body?.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 20_000),
+  }))()`);
+}
+
+export async function transactionState(page) {
+  return page.evaluate(`(async () => {
+    const hooks = globalThis.stateHooks || {};
+    const root = (await hooks.getCleanAppState?.()) || hooks.store?.getState?.() || null;
+    const transactions = root?.metamask?.transactions;
+    if (!Array.isArray(transactions)) return { available: false, transactions: [] };
+    return {
+      available: true,
+      transactions: transactions.slice(0, 500).map((transaction) => ({
+        id: transaction?.id == null ? null : String(transaction.id),
+        hash: transaction?.hash == null ? null : String(transaction.hash),
+        status: transaction?.status == null ? null : String(transaction.status),
+        chainId: transaction?.chainId == null ? null : String(transaction.chainId),
+        recipient: transaction?.txParams?.to == null ? null : String(transaction.txParams.to),
+        time: Number(transaction?.time ?? 0),
+      })).filter((transaction) => transaction.id),
+    };
+  })()`);
+}
+
+export async function activityItem(page, symbol, amount) {
+  const marker = `mm-harness-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return page.evaluate(`(() => {
+    const symbol = ${JSON.stringify(symbol.toUpperCase())};
+    const amount = ${JSON.stringify(String(amount))};
+    const marker = ${JSON.stringify(marker)};
+    for (const row of document.querySelectorAll('[data-testid="activity-list-item"]')) {
+      const label = String(row.innerText || row.textContent || '').replace(/\\s+/gu, ' ').trim();
+      if (!label.toUpperCase().includes(symbol) || (amount.toLowerCase() !== 'max' && !label.includes(amount))) continue;
+      const style = getComputedStyle(row);
+      const rect = row.getBoundingClientRect();
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) continue;
+      row.setAttribute('data-mm-harness-target', marker);
+      return { selector: '[data-mm-harness-target="' + marker + '"]', label: label.slice(0, 1000) };
+    }
+    return null;
+  })()`);
+}
+
+export const selectors = {
+  send: dataTestId('eth-overview-send'),
+  nativeSend: dataTestId('coin-overview-send'),
+  recipient: dataTestId('recipient-address-input'),
+  amount: dataTestId('send-amount-input'),
+  continue: dataTestId('send-continue-button'),
+  alert: dataTestId('send-alert-modal-acknowledge-button'),
+  confirm: dataTestId('confirm-footer-button'),
+  cancel: dataTestId('confirm-footer-cancel-button'),
+  activity: dataTestId('bottom-nav-activity'),
+  home: dataTestId('bottom-nav-home'),
+};

package/library/actions/extension/assets/set_custom_gas.mjs

@@ -0,0 +1,56 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { bodyState, visible, waitFor } from './send.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const gasLimit = String(input.node?.gas_limit || '').trim();
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!/^\d+$/u.test(gasLimit) || Number(gasLimit) <= 0) {
+    throw new Error('metamask.assets.set_custom_gas requires a positive integer gas_limit.');
+  }
+  const edit = dataTestId('edit-gas-fee-icon');
+  const advanced = dataTestId('gas-option-advanced');
+  const modal = dataTestId('gas-fee-advanced-eip1559-modal');
+  const gasInput = '#gas-input';
+  const maxFeeInput = '#max-base-fee-input';
+  const priorityFeeInput = '#priority-fee-input';
+  const save = dataTestId('gas-fee-modal-save-button');
+  if (!(await visible(page, modal))) {
+    await waitFor(page, async () => {
+      if (await visible(page, modal)) return true;
+      const control = (await visible(page, advanced)) ? advanced : (await visible(page, edit)) ? edit : null;
+      if (control) {
+        try {
+          await page.click(control);
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    }, 'Advanced gas editor did not become visible.', timeoutMs);
+  }
+  await waitFor(page, () => visible(page, gasInput), 'Gas limit input did not become visible.', timeoutMs);
+  const fees = await page.evaluate(`(() => ({
+    maxFee: document.querySelector(${JSON.stringify(maxFeeInput)})?.value || '',
+    priorityFee: document.querySelector(${JSON.stringify(priorityFeeInput)})?.value || '',
+  }))()`);
+  if (!(Number(fees.priorityFee) > 0)) {
+    const maxFee = Number(fees.maxFee);
+    if (!(maxFee > 0)) throw new Error('Advanced gas editor did not expose a positive max base fee.');
+    await page.setInput(priorityFeeInput, String(Math.min(maxFee / 2, 0.01)));
+  }
+  await page.setInput(gasInput, gasLimit);
+  await waitFor(page, () => page.evaluate(`document.querySelector(${JSON.stringify(save)})?.disabled === false`), 'Custom gas values did not enable Save.', timeoutMs);
+  await page.click(save);
+  const state = await waitFor(page, async () => {
+    const current = await bodyState(page);
+    return !(await visible(page, modal)) && /Speed Advanced/u.test(current.text) ? current : null;
+  }, 'Custom gas was not applied to the confirmation.', timeoutMs);
+  return {
+    action: input.action,
+    gasLimit,
+    maxFeeGwei: fees.maxFee,
+    priorityFeeGwei: Number(fees.priorityFee) > 0 ? fees.priorityFee : String(Math.min(Number(fees.maxFee) / 2, 0.01)),
+    ...state,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));