@deeeed/metamask-harness 0.37.0 → 0.38.0

package/library/actions/extension/perps/update_position_tpsl.mjs

@@ -0,0 +1,106 @@
+import { dataTestId, marketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+function displayedPrice(value) {
+  const match = String(value).replace(/,/gu, '').match(/-?\d+(?:\.\d+)?/u);
+  return match ? Number(match[0]) : null;
+}
+
+function matchesRequestedPrice(displayed, requested) {
+  const observed = displayedPrice(displayed);
+  const expected = Number(requested);
+  return observed !== null && Number.isFinite(observed)
+    && Math.abs(observed - expected) <= Math.max(0.005, Math.abs(expected) * 1e-10);
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const market = marketSymbol(input);
+  const takeProfit = input.node?.take_profit_price;
+  const stopLoss = input.node?.stop_loss_price;
+  if (!market) throw new Error('metamask.perps.update_position_tpsl requires market=<symbol>.');
+  if (takeProfit == null && stopLoss == null) {
+    throw new Error('metamask.perps.update_position_tpsl requires take_profit_price and/or stop_loss_price.');
+  }
+  for (const [name, value] of [['take_profit_price', takeProfit], ['stop_loss_price', stopLoss]]) {
+    if (value != null && (!Number.isFinite(Number(value)) || Number(value) <= 0)) {
+      throw new Error(`metamask.perps.update_position_tpsl received invalid ${name}.`);
+    }
+  }
+  if (input.node?.confirm_live !== true) {
+    throw new Error('metamask.perps.update_position_tpsl requires confirm_live=true for live submission.');
+  }
+
+  await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
+  await page.waitForSelector(dataTestId('perps-auto-close-row'), { timeoutMs: 20_000 });
+  const before = await page.evaluate(`(() => ({
+    takeProfit: String(document.querySelector('[data-testid="perps-auto-close-tp-value"]')?.textContent || '').trim(),
+    stopLoss: String(document.querySelector('[data-testid="perps-auto-close-sl-value"]')?.textContent || '').trim(),
+  }))()`);
+  await page.click(dataTestId('perps-auto-close-row'));
+  await page.waitForSelector(dataTestId('perps-update-tpsl-modal'), { timeoutMs: 10_000 });
+  if (takeProfit != null) {
+    await page.setInput('input[data-testid="perps-update-tpsl-tp-price-input"], [data-testid="perps-update-tpsl-tp-price-input"] input', String(takeProfit));
+  }
+  if (stopLoss != null) {
+    await page.setInput('input[data-testid="perps-update-tpsl-sl-price-input"], [data-testid="perps-update-tpsl-sl-price-input"] input', String(stopLoss));
+  }
+
+  const readyDeadline = Date.now() + 10_000;
+  let ready;
+  while (Date.now() <= readyDeadline) {
+    ready = await page.evaluate(`(() => {
+      const value = (testId) => document.querySelector('input[data-testid="' + testId + '"], [data-testid="' + testId + '"] input')?.value ?? null;
+      const submit = document.querySelector('[data-testid="perps-update-tpsl-modal-submit"]');
+      return {
+        takeProfit: value('perps-update-tpsl-tp-price-input'),
+        stopLoss: value('perps-update-tpsl-sl-price-input'),
+        submitEnabled: Boolean(submit && !submit.disabled && submit.getAttribute('aria-disabled') !== 'true'),
+        entry: String(document.querySelector('[data-testid="perps-update-tpsl-entry-price-value"]')?.textContent || '').trim(),
+        current: String(document.querySelector('[data-testid="perps-update-tpsl-current-price-value"]')?.textContent || '').trim(),
+        liquidation: String(document.querySelector('[data-testid="perps-update-tpsl-liquidation-price-value"]')?.textContent || '').trim(),
+        errors: [...document.querySelectorAll('[role="alert"]')]
+          .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim())
+          .filter(Boolean)
+          .slice(0, 20),
+      };
+    })()`);
+    const retained = (takeProfit == null || Number(ready.takeProfit) === Number(takeProfit)) &&
+      (stopLoss == null || Number(ready.stopLoss) === Number(stopLoss));
+    if (retained && ready.submitEnabled) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (!ready?.submitEnabled || ready.errors.length > 0) {
+    throw new Error(`Perps TP/SL update is not ready: ${JSON.stringify(ready)}.`);
+  }
+  await page.click(dataTestId('perps-update-tpsl-modal-submit'));
+
+  const resultDeadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
+  const reconciled = (state) =>
+    (takeProfit == null || matchesRequestedPrice(state.takeProfit, takeProfit)) &&
+    (stopLoss == null || matchesRequestedPrice(state.stopLoss, stopLoss));
+  let after;
+  while (Date.now() <= resultDeadline) {
+    after = await page.evaluate(`(() => ({
+      modalVisible: Boolean(document.querySelector('[data-testid="perps-update-tpsl-modal"]')),
+      takeProfit: String(document.querySelector('[data-testid="perps-auto-close-tp-value"]')?.textContent || '').trim(),
+      stopLoss: String(document.querySelector('[data-testid="perps-auto-close-sl-value"]')?.textContent || '').trim(),
+      errors: [...document.querySelectorAll('[role="alert"]')]
+        .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim())
+        .filter(Boolean)
+        .slice(0, 20),
+    }))()`);
+    if (!after.modalVisible && reconciled(after)) break;
+    if (after.errors.length > 0) throw new Error(`Perps TP/SL update failed: ${after.errors.join(' | ')}`);
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  if (!after || after.modalVisible || !reconciled(after)) {
+    throw new Error(`Perps TP/SL did not reconcile after submission: ${JSON.stringify({ before, after })}.`);
+  }
+  return {
+    action: input.action,
+    market,
+    before,
+    ready,
+    after,
+    proofPath: 'visible-product-controls',
+  };
+}));

package/library/actions/extension/platform/cdp.mjs

@@ -67,7 +67,10 @@ export function extensionTarget(targets, extensionId = null) {
     if (extensionId && extensionIdFromTarget(target) !== extensionId) return false;
     return Boolean(target.webSocketDebuggerUrl);
   });
-  const home = candidates.find((target) => String(target.url).includes('/home.html'));
+  const home = candidates.find((target) =>
+    String(target.url).includes('/home.html') &&
+    !String(target.url).includes('/onboarding/')
+  ) ?? candidates.find((target) => String(target.url).includes('/home.html'));
   const sidepanel = candidates.find((target) => String(target.url).includes('/sidepanel.html'));
   if (home && String(home.url).includes('/onboarding/completion') && sidepanel) {
     return sidepanel;
@@ -729,6 +732,106 @@ export class ExtensionPage extends CdpWebPage {
     this.port = port;
   }
 
+  async click(selector) {
+    const target = await this.evaluate(`(() => {
+      const selector = ${JSON.stringify(selector)};
+      const element = document.querySelector(selector);
+      if (!element) throw new Error('Clickable element not found: ' + selector);
+      element.scrollIntoView({ block: 'center', inline: 'center' });
+      const rect = element.getBoundingClientRect();
+      const style = getComputedStyle(element);
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) {
+        throw new Error('Clickable element is not visible: ' + selector);
+      }
+      return {
+        x: rect.left + (rect.width / 2),
+        y: rect.top + (rect.height / 2),
+        tagName: element.tagName,
+      };
+    })()`);
+    await this.session.call('Input.dispatchMouseEvent', {
+      type: 'mouseMoved',
+      x: target.x,
+      y: target.y,
+    });
+    await this.session.call('Input.dispatchMouseEvent', {
+      type: 'mousePressed',
+      x: target.x,
+      y: target.y,
+      button: 'left',
+      buttons: 1,
+      clickCount: 1,
+    });
+    await this.session.call('Input.dispatchMouseEvent', {
+      type: 'mouseReleased',
+      x: target.x,
+      y: target.y,
+      button: 'left',
+      buttons: 0,
+      clickCount: 1,
+    });
+    return { clicked: true, selector, tagName: target.tagName };
+  }
+
+  async setInput(selector, value) {
+    const input = String(value ?? '');
+    const target = await this.evaluate(`(() => {
+      const selector = ${JSON.stringify(selector)};
+      const element = document.querySelector(selector);
+      if (!element) throw new Error('Input element not found: ' + selector);
+      if (!('value' in element)) throw new Error('Target is not an input: ' + selector);
+      element.focus();
+      if (typeof element.select === 'function') element.select();
+      return { tagName: element.tagName, previousLength: String(element.value ?? '').length };
+    })()`);
+    await this.session.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace' });
+    await this.session.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace' });
+    for (const character of input) {
+      const upper = character.toUpperCase();
+      const isLetter = /^[A-Z]$/u.test(upper);
+      const isDigit = /^[0-9]$/u.test(character);
+      const virtualKeyCode = isLetter || isDigit ? upper.charCodeAt(0) : character === ' ' ? 32 : 0;
+      await this.session.call('Input.dispatchKeyEvent', {
+        type: 'keyDown',
+        key: character,
+        ...(isLetter ? { code: `Key${upper}` } : {}),
+        ...(isDigit ? { code: `Digit${character}` } : {}),
+        ...(virtualKeyCode ? {
+          windowsVirtualKeyCode: virtualKeyCode,
+          nativeVirtualKeyCode: virtualKeyCode,
+        } : {}),
+        text: character,
+        unmodifiedText: character,
+      });
+      await this.session.call('Input.dispatchKeyEvent', {
+        type: 'keyUp',
+        key: character,
+        ...(isLetter ? { code: `Key${upper}` } : {}),
+        ...(isDigit ? { code: `Digit${character}` } : {}),
+        ...(virtualKeyCode ? {
+          windowsVirtualKeyCode: virtualKeyCode,
+          nativeVirtualKeyCode: virtualKeyCode,
+        } : {}),
+      });
+    }
+    const retainedLength = await this.evaluate(`(() => {
+      const element = document.querySelector(${JSON.stringify(selector)});
+      if (!element || !('value' in element)) return -1;
+      element.dispatchEvent(new Event('change', { bubbles: true }));
+      return String(element.value ?? '').length;
+    })()`);
+    if (retainedLength !== input.length) {
+      throw new Error(`Input did not retain the supplied value length: ${selector}`);
+    }
+    return {
+      set: true,
+      selector,
+      tagName: target.tagName,
+      previousLength: target.previousLength,
+      retainedLength,
+    };
+  }
+
   async navigateHash(hash, timeoutMs = 10000) {
     const normalizedHash = String(hash || '').startsWith('#') ? hash : `#${hash || '/'}`;
     const navigation = await this.evaluate(`(() => {

package/library/actions/extension/settings/set_basic_functionality.mjs

@@ -0,0 +1,58 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+const TOGGLE_SELECTOR = dataTestId('basic-functionality-toggle');
+const TOGGLE_LABEL_SELECTOR = `label.toggle-button:has(${TOGGLE_SELECTOR})`;
+
+async function readState(page) {
+  return page.evaluate(`(() => {
+    const input = document.querySelector(${JSON.stringify(TOGGLE_SELECTOR)});
+    const label = input?.closest('label.toggle-button');
+    if (!input || !label) return null;
+    return {
+      enabled: label.classList.contains('toggle-button--on'),
+      route: String(location.hash),
+      toggleClass: String(label.className),
+    };
+  })()`);
+}
+
+async function waitForState(page, enabled, timeoutMs = 15_000) {
+  const deadline = Date.now() + timeoutMs;
+  let state;
+  while (Date.now() <= deadline) {
+    state = await readState(page);
+    if (state?.enabled === enabled) return state;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Basic Functionality did not become ${enabled ? 'enabled' : 'disabled'}.`);
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  if (typeof input.node?.enabled !== 'boolean') {
+    throw new Error('metamask.settings.set_basic_functionality requires enabled=true or enabled=false.');
+  }
+  const requested = input.node.enabled;
+  await page.navigateHash('#/settings/privacy');
+  await page.waitForSelector(TOGGLE_LABEL_SELECTOR);
+  const before = await readState(page);
+  if (!before) throw new Error('Basic Functionality toggle is not visible in Privacy settings.');
+
+  if (before.enabled !== requested) {
+    await page.click(TOGGLE_LABEL_SELECTOR);
+    if (!requested) {
+      await page.waitForSelector(dataTestId('basic-configuration-checkbox'));
+      await page.click(dataTestId('basic-configuration-checkbox'));
+      await page.click(dataTestId('basic-configuration-modal-toggle-button'));
+    }
+  }
+
+  const after = await waitForState(page, requested);
+  return {
+    action: input.action,
+    requested,
+    changed: before.enabled !== after.enabled,
+    before,
+    after,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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

@@ -0,0 +1,71 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  normalizeVisibleSwapBridgeState,
+  resolveVisibleSwapBridgeOptions,
+} from '../../shared/swap-bridge/visible-state.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const options = resolveVisibleSwapBridgeOptions(input.node);
+  const raw = await page.evaluate(`(() => {
+    const testIds = [
+      'from-amount',
+      'to-amount',
+      'bridge-source-button',
+      'bridge-destination-button',
+      'bridge__header-settings-button',
+      'prepare-swap-page-error',
+      'bridge-missing-price-banner',
+    ];
+    const items = testIds.map((testId) => {
+      const element = document.querySelector('[data-testid="' + testId + '"]');
+      if (!element) return null;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) return null;
+      const input = element.matches('input, textarea') ? element : element.querySelector('input, textarea');
+      return {
+        testId,
+        label: String(element.getAttribute('aria-label') || element.innerText || '').replace(/\\s+/gu, ' ').trim(),
+        value: input ? String(input.value ?? '') : null,
+        enabled: !(input ?? element).disabled,
+        visible: true,
+      };
+    }).filter(Boolean);
+    const text = (selector) => String(document.querySelector(selector)?.innerText || '').replace(/\\s+/gu, ' ').trim();
+    const slippageButton = document.querySelector('[data-testid="slippage-edit-button"]');
+    const cta = document.querySelector('[data-testid="bridge-cta-button"]');
+    const body = String(document.body.innerText || '').replace(/\\s+/gu, ' ').trim();
+    return {
+      route: location.hash,
+      title: document.title,
+      items,
+      quote: {
+        slippage: String(slippageButton?.parentElement?.innerText || '').replace(/\\s+/gu, ' ').trim() || null,
+        networkFee: text('[data-testid="network-fees-sponsored"], [data-testid="network-fees-included"], [data-testid="network-fees"]') || null,
+        minimumReceived: text('[data-testid="minimum-received"]') || null,
+        metaMaskFee: text('[data-testid="bridge-cta-info-text"]') || null,
+        cta: cta ? String(cta.innerText || '').replace(/\\s+/gu, ' ').trim() : null,
+        ctaEnabled: cta ? !cta.disabled : false,
+        warning: body.match(/(?:might be reverted|may fail|likely to fail|insufficient funds|trade route isn't available)[^.]{0,300}/iu)?.[0] || null,
+      },
+    };
+  })()`);
+  const state = normalizeVisibleSwapBridgeState(raw, options, 'extension');
+  const requireQuote = input.node?.require_quote === true;
+  const expectedSlippage = input.node?.expected_slippage == null
+    ? null
+    : Number(input.node.expected_slippage);
+  if (requireQuote && (!raw.quote.ctaEnabled || !(Number(state.destinationAmount) > 0)
+    || !/^(?:Swap|Bridge)$/iu.test(String(raw.quote.cta)))) {
+    throw new Error('Swap quote is not ready for review.');
+  }
+  if (expectedSlippage !== null && raw.quote.slippage !== `${expectedSlippage}%`) {
+    throw new Error(`Swap slippage mismatch: expected ${expectedSlippage}%, observed ${raw.quote.slippage ?? 'none'}.`);
+  }
+  return {
+    action: input.action,
+    ...state,
+    quote: raw.quote,
+    proofPath: 'visible-dom-accessibility',
+  };
+}));

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

@@ -0,0 +1,103 @@
+import { runAdapter, withExtensionPage, dataTestId } from '../platform/cdp.mjs';
+import { openSwap } from '../ui/navigate.mjs';
+import { resolveAssetSelectionOptions } from '../../shared/swap-bridge/transaction.mjs';
+
+async function pause(page) {
+  await page.evaluate('new Promise((resolve) => setTimeout(resolve, 200))');
+}
+
+async function isVisible(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 findAsset(page, { chain, symbol, assetId }, deadline) {
+  if (assetId) {
+    const testId = `bridge-asset--${assetId}`;
+    await page.waitForSelector(dataTestId(testId), { timeoutMs: Math.max(1, deadline - Date.now()) });
+    return testId;
+  }
+  while (Date.now() < deadline) {
+    const candidates = await page.evaluate(`(() => {
+      const prefix = ${JSON.stringify(`bridge-asset--`)} + ${JSON.stringify(`${chain}/`)};
+      const expected = ${JSON.stringify(symbol)};
+      return [...document.querySelectorAll('[data-testid^="bridge-asset--"]')]
+        .filter((row) => String(row.getAttribute('data-testid') || '').startsWith(prefix))
+        .filter((row) => String(row.querySelector('[data-testid="bridge-asset-symbol"]')?.textContent || '').trim().toUpperCase() === expected)
+        .map((row) => row.getAttribute('data-testid'))
+        .filter(Boolean);
+    })()`);
+    if (candidates.length === 1) return candidates[0];
+    if (candidates.length > 1) {
+      throw new Error(`Swap asset selection is ambiguous for ${symbol} on ${chain}: ${candidates.join(', ')}.`);
+    }
+    await pause(page);
+  }
+  throw new Error(`Swap asset ${symbol} on ${chain} did not appear after search.`);
+}
+
+async function selectAsset(page, role, asset, deadline) {
+  const button = dataTestId(role === 'source' ? 'bridge-source-button' : 'bridge-destination-button');
+  const search = dataTestId('bridge-asset-picker-search-input');
+  while (Date.now() < deadline && !(await isVisible(page, search))) {
+    if (await isVisible(page, button)) {
+      try {
+        await page.click(button);
+      } catch {
+        await pause(page);
+      }
+    }
+    await pause(page);
+  }
+  if (!(await isVisible(page, search))) {
+    throw new Error(`Swap ${role} asset picker did not open.`);
+  }
+  await page.setInput(search, asset.query);
+  const testId = await findAsset(page, asset, deadline);
+  await page.click(dataTestId(testId));
+  while (Date.now() < deadline) {
+    const selected = await page.evaluate(`String(document.querySelector(${JSON.stringify(button)})?.innerText || '').trim()`);
+    if (selected.toUpperCase().includes(asset.symbol)) return { role, testId, symbol: asset.symbol, chain: asset.chain };
+    await pause(page);
+  }
+  throw new Error(`Swap ${role} asset ${asset.symbol} was not selected.`);
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const options = resolveAssetSelectionOptions(input.node);
+  const deadline = Date.now() + options.timeoutMs;
+  await openSwap(page, Math.max(1, deadline - Date.now()));
+  const source = await selectAsset(page, 'source', {
+    chain: options.sourceChain,
+    symbol: options.sourceSymbol,
+    query: options.sourceQuery,
+    assetId: options.sourceAssetId,
+  }, deadline);
+  await page.evaluate('new Promise((resolve) => setTimeout(resolve, 1000))');
+  const destination = await selectAsset(page, 'destination', {
+    chain: options.destinationChain,
+    symbol: options.destinationSymbol,
+    query: options.destinationQuery,
+    assetId: options.destinationAssetId,
+  }, deadline);
+  await page.evaluate('new Promise((resolve) => setTimeout(resolve, 1000))');
+  const stable = await page.evaluate(`(() => ({
+    source: String(document.querySelector('[data-testid="bridge-source-button"]')?.innerText || '').trim(),
+    destination: String(document.querySelector('[data-testid="bridge-destination-button"]')?.innerText || '').trim(),
+  }))()`);
+  if (!stable.source.toUpperCase().includes(options.sourceSymbol)
+    || !stable.destination.toUpperCase().includes(options.destinationSymbol)) {
+    throw new Error(`Swap pair did not remain selected: observed ${stable.source} to ${stable.destination}.`);
+  }
+  return {
+    action: input.action,
+    source,
+    destination,
+    proofPath: 'visible-ui-selection',
+  };
+}));

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

@@ -0,0 +1,36 @@
+import { runAdapter, withExtensionPage, dataTestId } from '../platform/cdp.mjs';
+import { resolveAmountOptions } from '../../shared/swap-bridge/transaction.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const options = resolveAmountOptions(input.node);
+  const source = dataTestId('from-amount');
+  await page.setInput(source, options.amount);
+  const deadline = Date.now() + options.timeoutMs;
+  let observed;
+  do {
+    observed = await page.evaluate(`(() => {
+      const value = (testId) => {
+        const root = document.querySelector('[data-testid="' + testId + '"]');
+        const input = root?.matches('input, textarea') ? root : root?.querySelector('input, textarea');
+        return String(input?.value ?? '').trim();
+      };
+      const cta = document.querySelector('[data-testid="bridge-cta-button"]');
+      return {
+        sourceAmount: value('from-amount'),
+        destinationAmount: value('to-amount'),
+        cta: cta ? String(cta.innerText || '').trim() : null,
+        ctaEnabled: cta ? !cta.disabled : false,
+        noQuote: document.body.innerText.includes("This trade route isn't available right now"),
+      };
+    })()`);
+    if (!options.waitForQuote || observed.noQuote || (Number(observed.destinationAmount) > 0 && observed.cta && observed.ctaEnabled)) break;
+    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 250))');
+  } while (Date.now() < deadline);
+  if (observed.sourceAmount !== 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 && observed.ctaEnabled)) {
+    throw new Error(`Swap quote did not resolve within ${options.timeoutMs}ms.`);
+  }
+  return { action: input.action, ...observed, proofPath: 'visible-ui-amount' };
+}));

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

@@ -0,0 +1,58 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { resolveAmountOptions } from '../../shared/swap-bridge/transaction.mjs';
+
+async function pause(page) {
+  await page.evaluate('new Promise((resolve) => setTimeout(resolve, 250))');
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const options = resolveAmountOptions({
+    amount: '1',
+    wait_for_quote: input.node?.wait_for_quote,
+    timeout_ms: input.node?.timeout_ms,
+  });
+  const marker = `mm-harness-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const selector = await page.evaluate(`(() => {
+    const marker = ${JSON.stringify(marker)};
+    for (const element of document.querySelectorAll('button, [role="button"]')) {
+      const label = String(element.innerText || element.textContent || '').replace(/\\s+/gu, ' ').trim();
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      if (label !== 'Max' || style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) continue;
+      element.setAttribute('data-mm-harness-target', marker);
+      return '[data-mm-harness-target="' + marker + '"]';
+    }
+    return null;
+  })()`);
+  if (!selector) throw new Error('Swap Max control was not visible.');
+  await page.click(selector);
+  const deadline = Date.now() + options.timeoutMs;
+  let observed = null;
+  while (Date.now() < deadline) {
+    observed = await page.evaluate(`(() => {
+      const value = (testId) => {
+        const root = document.querySelector('[data-testid="' + testId + '"]');
+        const input = root?.matches('input, textarea') ? root : root?.querySelector('input, textarea');
+        return String(input?.value ?? '').trim();
+      };
+      const cta = document.querySelector('[data-testid="bridge-cta-button"]');
+      return {
+        sourceAmount: value('from-amount'),
+        destinationAmount: value('to-amount'),
+        cta: cta ? String(cta.innerText || '').replace(/\\s+/gu, ' ').trim() : null,
+        ctaEnabled: Boolean(cta && !cta.disabled),
+        loading: Boolean(document.querySelector('[data-testid="multichain-bridge-quote-card-loading"]')),
+        noQuote: document.body.innerText.includes("This trade route isn't available right now"),
+      };
+    })()`);
+    if (Number(observed.sourceAmount) > 0
+      && (!options.waitForQuote || observed.noQuote || (!observed.loading && Number(observed.destinationAmount) > 0 && observed.ctaEnabled))) break;
+    await pause(page);
+  }
+  if (!(Number(observed?.sourceAmount) > 0)) throw new Error('Swap Max did not populate a positive source amount.');
+  if (options.waitForQuote && !observed.noQuote
+    && (observed.loading || !(Number(observed.destinationAmount) > 0) || !observed.ctaEnabled)) {
+    throw new Error(`Swap Max quote did not resolve within ${options.timeoutMs}ms.`);
+  }
+  return { action: input.action, ...observed, proofPath: 'trusted-pointer-visible-ui' };
+}));