@deeeed/metamask-harness 0.36.0 → 0.38.0

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

@@ -0,0 +1,128 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { activityItem, bodyState, selectors, tokenRow, transactionState, visible, waitFor } from './send.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const decision = String(input.node?.decision || '').trim();
+  const symbol = String(input.node?.symbol || '').trim().toUpperCase();
+  const amount = String(input.node?.amount || '').trim();
+  const resumeSubmitted = input.node?.resume_submitted === true;
+  const resumedHash = String(input.node?.transaction_hash || '').trim();
+  const timeoutMs = Number(input.node?.timeout_ms ?? 120_000);
+  if (!['confirm', 'cancel'].includes(decision) || !symbol || !amount) {
+    throw new Error('metamask.assets.finish_send requires decision=confirm|cancel, symbol, and amount.');
+  }
+  if (decision === 'confirm' && input.node?.confirm_live !== true) {
+    throw new Error('metamask.assets.finish_send decision=confirm requires confirm_live=true.');
+  }
+  const control = decision === 'confirm' ? selectors.confirm : selectors.cancel;
+  let state = await bodyState(page);
+  let submittedTransaction = null;
+  let submittedNow = false;
+  if (await visible(page, control)) {
+    const beforeTransactions = decision === 'confirm' ? await transactionState(page) : null;
+    if (decision === 'confirm' && !beforeTransactions?.available) {
+      throw new Error('Transaction state is unavailable; refusing to submit without proof binding.');
+    }
+    const beforeById = new Map((beforeTransactions?.transactions ?? []).map((transaction) => [transaction.id, transaction]));
+    await page.click(control);
+    submittedNow = decision === 'confirm';
+    state = await waitFor(page, async () => {
+      const current = await bodyState(page);
+      return current.route === '' || current.route === '#/' ? current : null;
+    }, 'Wallet did not return after send decision.', timeoutMs);
+    if (decision === 'confirm') {
+      submittedTransaction = await waitFor(page, async () => {
+        const current = await transactionState(page);
+        const changed = current.transactions.filter((transaction) => {
+          const before = beforeById.get(transaction.id);
+          if (!before) return true;
+          const wasAwaitingApproval = ['unapproved', 'approved'].includes(String(before.status).toLowerCase());
+          return wasAwaitingApproval && (before.status !== transaction.status || before.hash !== transaction.hash);
+        });
+        if (changed.length > 1) {
+          throw new Error(`Send submission changed multiple transaction records: ${changed.map((transaction) => transaction.id).join(', ')}.`);
+        }
+        return changed[0] ?? null;
+      }, 'Send confirmation did not change one transaction record.', timeoutMs);
+    }
+  } else if (decision === 'cancel') {
+    throw new Error('Send cancel control was not visible.');
+  } else if (!resumeSubmitted) {
+    throw new Error('Send confirm control was not visible. Next: rerun with resume_submitted=true only if this exact transaction was already submitted.');
+  } else if (!resumedHash) {
+    throw new Error('metamask.assets.finish_send resume_submitted=true requires transaction_hash.');
+  } else if (!/^0x[0-9a-f]{64}$/iu.test(resumedHash)) {
+    throw new Error('metamask.assets.finish_send transaction_hash must be a full EVM transaction hash.');
+  }
+  if (decision === 'cancel') {
+    return { action: input.action, decision, cancelled: true, proofPath: 'trusted-pointer-visible-ui' };
+  }
+  submittedTransaction = await waitFor(page, async () => {
+    const current = await transactionState(page);
+    const transaction = submittedNow
+      ? current.transactions.find((entry) => entry.id === submittedTransaction?.id)
+      : current.transactions.find((entry) => entry.hash?.toLowerCase() === resumedHash.toLowerCase());
+    if (!transaction) return null;
+    if (['failed', 'rejected', 'dropped'].includes(String(transaction.status).toLowerCase())) {
+      throw new Error(`Send transaction ${transaction.id} reached ${transaction.status}.`);
+    }
+    return String(transaction.status).toLowerCase() === 'confirmed' && /^0x[0-9a-f]{64}$/iu.test(transaction.hash || '')
+      ? transaction
+      : null;
+  }, `Sent ${amount} ${symbol} did not produce one confirmed transaction record.`, timeoutMs);
+  let tokenAfter = null;
+  if (!state.route.includes('/tx/')) {
+    if (state.route.includes('/activity')) {
+      await page.click(selectors.home);
+    }
+    tokenAfter = await waitFor(page, () => tokenRow(page, symbol), `${symbol} did not reappear after send.`, timeoutMs);
+    await waitFor(page, async () => {
+      const current = await bodyState(page);
+      if (current.route.includes('/activity') || current.route.includes('/tx/')) return current;
+      await page.click(selectors.activity);
+      return null;
+    }, 'Activity did not open after send.', timeoutMs);
+  }
+  let activity = null;
+  if (!state.route.includes('/tx/')) {
+    activity = await waitFor(page, () => activityItem(page, symbol, amount), `Sent ${amount} ${symbol} did not appear in Activity.`, timeoutMs);
+    await waitFor(page, async () => {
+      const current = await bodyState(page);
+      if (current.route.includes('/tx/')) return current;
+      const currentActivity = await activityItem(page, symbol, amount);
+      if (currentActivity) {
+        activity = currentActivity;
+        await page.click(currentActivity.selector);
+      }
+      return null;
+    }, `Sent ${amount} ${symbol} transaction details did not open.`, timeoutMs);
+  }
+  const details = await waitFor(page, async () => {
+    const current = await bodyState(page);
+    if (!current.route.includes('/tx/') || !/\bConfirmed\b/u.test(current.text)) return null;
+    return current;
+  }, `Sent ${amount} ${symbol} did not reach Confirmed.`, timeoutMs);
+  const explorerUrl = await page.evaluate(`document.querySelector('[data-testid="transaction-details-block-explorer"]')?.getAttribute('data-explorer-url') || null`);
+  const transactionHash = details.route.match(/\/(0x[0-9a-f]{64})(?:\?|$)/iu)?.[1]
+    ?? details.text.match(/\b0x[0-9a-f]{64}\b/iu)?.[0]
+    ?? String(explorerUrl || '').match(/\/(0x[0-9a-f]{64})(?:[/?#]|$)/iu)?.[1]
+    ?? null;
+  if (!transactionHash) throw new Error('Confirmed transaction details did not expose a full transaction hash.');
+  if (transactionHash.toLowerCase() !== submittedTransaction.hash.toLowerCase()) {
+    throw new Error(`Confirmed Activity details opened ${transactionHash}, expected ${submittedTransaction.hash}.`);
+  }
+  return {
+    action: input.action,
+    decision,
+    symbol,
+    amount,
+    activity,
+    tokenAfter,
+    details,
+    explorerUrl,
+    transactionHash,
+    transactionId: submittedTransaction.id,
+    resumed: !submittedNow,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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',
+  };
+}));