@deeeed/metamask-harness 0.36.0 → 0.38.0

package/library/actions/extension/networks/custom_network.mjs

@@ -0,0 +1,103 @@
+import { dataTestId } from '../platform/cdp.mjs';
+
+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 page.evaluate('new Promise((resolve) => setTimeout(resolve, 150))');
+  }
+  throw new Error(message);
+}
+
+export async function semanticButtonOrNull(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.getAttribute('aria-label') || element.innerText || element.textContent || '').replace(/\\s+/gu, ' ').trim();
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      if (text === label && !element.disabled && element.getAttribute('aria-disabled') !== 'true' && style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0) {
+        element.setAttribute('data-mm-harness-target', marker);
+        return true;
+      }
+    }
+    return false;
+  })()`);
+  return found ? `[data-mm-harness-target="${marker}"]` : null;
+}
+
+export async function semanticButton(page, label) {
+  const selector = await semanticButtonOrNull(page, label);
+  if (!selector) throw new Error(`Visible button ${JSON.stringify(label)} was not found.`);
+  return selector;
+}
+
+export async function openNetworkManager(page, timeoutMs) {
+  const menu = dataTestId('account-options-menu-button');
+  const networks = dataTestId('global-menu-networks');
+  await page.click(menu);
+  await waitFor(page, () => visible(page, networks), 'Networks did not become visible in the account menu.', timeoutMs);
+  await page.click(networks);
+  await waitFor(
+    page,
+    () => visible(page, dataTestId('networks-page-add-custom-network-button')),
+    'Network manager did not open.',
+    timeoutMs,
+  );
+}
+
+export async function findNetworkItem(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') || '');
+      if (testId.includes('-options-')) continue;
+      const suffix = testId.slice('network-list-item-'.length).toLowerCase();
+      const label = String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500);
+      const nameMatches = [...element.querySelectorAll('[data-testid]')]
+        .some((child) => String(child.getAttribute('data-testid') || '').toLowerCase() === network);
+      if (chainIds.has(suffix) && nameMatches) return { testId, label, suffix };
+    }
+    return null;
+  })()`);
+}
+
+export async function selectHomeNetwork(page, network, chainId, timeoutMs) {
+  const sort = dataTestId('sort-by-networks');
+  const chainHex = `0x${chainId.toString(16)}`;
+  const choices = [
+    dataTestId(`home-network-filter-network-${chainHex}`),
+    dataTestId(`home-network-filter-custom-${chainHex}`),
+    dataTestId(`home-network-filter-additional-${chainHex}`),
+  ];
+  await page.click(sort);
+  const choice = await waitFor(page, async () => {
+    for (const candidate of choices) {
+      if (await visible(page, candidate)) return candidate;
+    }
+    return null;
+  }, `${network} did not appear in the home network filter.`, timeoutMs);
+  await page.click(choice);
+  await waitFor(page, async () => {
+    const label = await page.evaluate(`String(document.querySelector(${JSON.stringify(sort)})?.innerText || '')`);
+    return label.toLowerCase().includes(network.toLowerCase());
+  }, `${network} did not become the selected home network.`, timeoutMs);
+}

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

@@ -0,0 +1,50 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  normalizeVisibleNetworkState,
+  resolveVisibleNetworkOptions,
+} from '../../shared/networks/visible-state.mjs';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function capture(page, maximum) {
+  return page.evaluate(`(() => {
+    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, ${JSON.stringify(maximum)})
+      .map((element) => {
+        const change = element.querySelector('[data-testid^="token-increase-decrease-percentage-"]');
+        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,
+        };
+      });
+    return {
+      network: document.querySelector('[data-testid="sort-by-networks"]')?.innerText,
+      errorText: document.body?.innerText,
+      items: rows,
+      truncated: document.querySelectorAll('[data-testid="multichain-token-list-button"]').length > rows.length,
+    };
+  })()`);
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const options = resolveVisibleNetworkOptions(input.node);
+  const before = await capture(page, options.assets.maxItems);
+  if (options.settleMs > 0) await sleep(options.settleMs);
+  const after = options.settleMs > 0 ? await capture(page, options.assets.maxItems) : before;
+  return {
+    action: input.action,
+    ...normalizeVisibleNetworkState(before, after, options, 'extension'),
+    proofPath: 'visible-dom-accessibility',
+  };
+}));

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

@@ -0,0 +1,68 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  findNetworkItem,
+  openNetworkManager,
+  selectHomeNetwork,
+  semanticButtonOrNull,
+  waitFor,
+} from './custom_network.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const network = String(input.node?.network || '').trim();
+  const chainId = Number(input.node?.chain_id);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30_000);
+  if (!network || !Number.isInteger(chainId) || chainId <= 0) {
+    throw new Error('metamask.networks.remove_custom requires network and positive chain_id.');
+  }
+  await selectHomeNetwork(page, 'Ethereum', 1, timeoutMs);
+  await openNetworkManager(page, timeoutMs);
+  const item = await findNetworkItem(page, network, chainId);
+  if (!item) throw new Error(`${network} (${chainId}) is not present for removal.`);
+  await page.click(dataTestId(`network-list-item-options-button-${item.suffix}`));
+  const remove = await waitFor(
+    page,
+    () => semanticButtonOrNull(page, 'Delete'),
+    'Custom network Delete action did not become visible.',
+    timeoutMs,
+  );
+  await page.click(remove);
+  await waitFor(
+    page,
+    () => page.evaluate(`Boolean(document.querySelector(${JSON.stringify(dataTestId('confirm-delete-network-modal'))}))`),
+    'Custom network delete confirmation did not appear.',
+    timeoutMs,
+  );
+  await page.click(dataTestId('confirm-delete-network-modal-delete-button'));
+  await waitFor(
+    page,
+    () => page.evaluate(`!document.querySelector(${JSON.stringify(dataTestId('confirm-delete-network-modal'))})`),
+    'Custom network delete confirmation did not close.',
+    timeoutMs,
+  );
+  await waitFor(
+    page,
+    async () => !(await findNetworkItem(page, network, chainId)),
+    `${network} remained in the network manager after deletion.`,
+    timeoutMs,
+  );
+  const back = await waitFor(
+    page,
+    () => semanticButtonOrNull(page, 'Back'),
+    'Network manager Back button did not become visible.',
+    timeoutMs,
+  );
+  await page.click(back);
+  await waitFor(
+    page,
+    () => page.evaluate(`Boolean(document.querySelector(${JSON.stringify(dataTestId('sort-by-networks'))}))`),
+    'Wallet home did not reopen after network deletion.',
+    timeoutMs,
+  );
+  return {
+    action: input.action,
+    network,
+    chainId,
+    removed: true,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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

@@ -3,6 +3,7 @@ import { assertOrders, closeOrders } from './perps.mjs';
 
 runAdapter(async (input) => {
   const close = await closeOrders(input);
+  if (close.proofPath === 'visible-product-controls') return close;
   const assertion = await assertOrders(input, false);
   return { ...assertion, close };
 });

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

@@ -0,0 +1,133 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+function marketSymbol(value) {
+  const result = String(value ?? '').trim().toUpperCase();
+  if (!/^[A-Z0-9:_-]{2,20}$/u.test(result)) {
+    throw new Error('metamask.perps.close_visible_position requires a valid market symbol.');
+  }
+  return result;
+}
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const market = marketSymbol(input.node?.market);
+  const partialAmount = input.node?.amount == null ? null : Number(input.node.amount);
+  if (partialAmount != null && (!Number.isFinite(partialAmount) || partialAmount <= 0)) {
+    throw new Error('metamask.perps.close_visible_position amount must be positive.');
+  }
+  if (input.node?.confirm_live !== true) {
+    throw new Error('metamask.perps.close_visible_position requires confirm_live=true.');
+  }
+  await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
+  await page.waitForSelector(dataTestId('perps-position-size-value'), { timeoutMs: 20_000 });
+  const before = await page.evaluate(`(() => {
+    const market = ${JSON.stringify(market)};
+    const route = String(location.hash);
+    const symbol = String(document.querySelector('[data-testid="perps-market-detail-pair"]')?.innerText || '')
+      .trim()
+      .toUpperCase();
+    if (!route.includes('/perps/market/') || !symbol.startsWith(market + '-')) {
+      throw new Error('Visible Perps market does not match the requested close market.');
+    }
+    const read = (testId) => String(document.querySelector('[data-testid="' + testId + '"]')?.innerText || '')
+      .replace(/\\s+/gu, ' ')
+      .trim()
+      .slice(0, 500);
+    const size = read('perps-position-size-value');
+    if (!size) throw new Error('No visible Perps position is available to close.');
+    return {
+      route,
+      market,
+      size,
+      direction: read('perps-position-leverage'),
+      margin: read('perps-position-margin-value'),
+      entryPrice: read('perps-position-entry-value'),
+      liquidationPrice: read('perps-position-liquidation-value'),
+    };
+  })()`);
+  let confirmation;
+  for (let attempt = 0; attempt < 3 && !confirmation; attempt += 1) {
+    await page.click(dataTestId('perps-close-cta-button'));
+    const deadline = Date.now() + 3_000;
+    while (Date.now() <= deadline) {
+      confirmation = await page.evaluate(`(() => {
+        const modal = document.querySelector('[data-testid="perps-close-position-modal"]');
+        const submit = document.querySelector('[data-testid="perps-close-position-modal-submit"]');
+        if (!modal || !submit) return null;
+        const read = (testId) => String(document.querySelector('[data-testid="' + testId + '"]')?.innerText || '')
+          .replace(/\\s+/gu, ' ')
+          .trim()
+          .slice(0, 500);
+        return {
+          amount: String(document.querySelector('[data-testid="close-amount-value"] input')?.value || read('close-amount-value')),
+          fullSizeSelected: Boolean(document.querySelector('[data-testid="close-amount-slider-pct-100"]')),
+          margin: read('perps-close-summary-margin-value'),
+          fees: read('perps-close-summary-fees-value'),
+          receive: read('perps-close-summary-receive-value'),
+          submitEnabled: !submit.disabled && submit.getAttribute('aria-disabled') !== 'true',
+        };
+      })()`);
+      if (confirmation) break;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  if (!confirmation) throw new Error('Perps close confirmation did not become visible.');
+  if (partialAmount != null) {
+    await page.setInput('input[data-testid="close-amount-value"], [data-testid="close-amount-value"] input', String(partialAmount));
+    const readyDeadline = Date.now() + 10_000;
+    while (Date.now() <= readyDeadline) {
+      confirmation = await page.evaluate(`(() => {
+        const submit = document.querySelector('[data-testid="perps-close-position-modal-submit"]');
+        return {
+          amount: document.querySelector('input[data-testid="close-amount-value"], [data-testid="close-amount-value"] input')?.value ?? null,
+          margin: String(document.querySelector('[data-testid="perps-close-summary-margin-value"]')?.innerText || '').trim(),
+          fees: String(document.querySelector('[data-testid="perps-close-summary-fees-value"]')?.innerText || '').trim(),
+          receive: String(document.querySelector('[data-testid="perps-close-summary-receive-value"]')?.innerText || '').trim(),
+          submitEnabled: Boolean(submit && !submit.disabled && submit.getAttribute('aria-disabled') !== 'true'),
+          warnings: [...document.querySelectorAll('[role="alert"]')]
+            .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim())
+            .filter(Boolean)
+            .slice(0, 20),
+        };
+      })()`);
+      if (Number(confirmation.amount) === partialAmount && confirmation.submitEnabled) break;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  if (!confirmation.submitEnabled) throw new Error('Perps close confirmation is not submit-ready.');
+  await page.click(dataTestId('perps-close-position-modal-submit'));
+  const closeDeadline = Date.now() + 45_000;
+  let finalState;
+  while (Date.now() <= closeDeadline) {
+    finalState = await page.evaluate(`(() => ({
+      route: String(location.hash),
+      positionVisible: Boolean(document.querySelector('[data-testid="perps-position-size-value"]')),
+      positionSize: String(document.querySelector('[data-testid="perps-position-size-value"]')?.innerText || '').trim(),
+      modalVisible: Boolean(document.querySelector('[data-testid="perps-close-position-modal"]')),
+      error: String(document.querySelector('[data-testid="perps-order-submit-error"]')?.innerText || '').trim(),
+      activity: [...document.querySelectorAll('[data-testid^="transaction-card-"]')]
+        .slice(0, 5)
+        .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500)),
+    }))()`);
+    if (finalState.error) throw new Error(`Perps close failed: ${finalState.error}`);
+    if (partialAmount != null) {
+      if (!finalState.modalVisible && finalState.positionVisible && finalState.positionSize !== before.size) break;
+    } else if (!finalState.positionVisible && !finalState.modalVisible) break;
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  const incomplete = partialAmount != null
+    ? finalState?.modalVisible || !finalState?.positionVisible || finalState?.positionSize === before.size
+    : finalState?.positionVisible || finalState?.modalVisible;
+  if (incomplete) {
+    throw new Error('Perps position did not reach the requested close state after the timeout.');
+  }
+  return {
+    action: input.action,
+    market,
+    closed: partialAmount == null,
+    partial: partialAmount != null,
+    positionBefore: before,
+    confirmation,
+    finalState,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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

@@ -0,0 +1,109 @@
+import { dataTestId, marketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+function numeric(value) {
+  const match = String(value ?? '').replace(/[$,]/gu, '').match(/-?[0-9]+(?:\.[0-9]+)?/u);
+  if (!match) return null;
+  const parsed = Number(match[0]);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function compactUsd(value) {
+  const parsed = numeric(value);
+  if (parsed == null) return null;
+  const suffix = String(value).trim().match(/[KMBT](?=$|\s)/u)?.[0];
+  return parsed * ({ K: 1e3, M: 1e6, B: 1e9, T: 1e12 }[suffix] ?? 1);
+}
+
+function relativeDifference(actual, expected) {
+  return Math.abs(actual - expected) / Math.max(Math.abs(expected), 1e-12);
+}
+
+runAdapter(async (input) => {
+  const market = marketSymbol(input);
+  if (!market) throw new Error('metamask.perps.compare_provider_market requires market=<symbol>.');
+  const endpoint = String(input.node?.endpoint ?? 'https://api.hyperliquid.xyz/info');
+  if (endpoint !== 'https://api.hyperliquid.xyz/info') {
+    throw new Error('metamask.perps.compare_provider_market endpoint must be the Hyperliquid production info API.');
+  }
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ type: 'metaAndAssetCtxs' }),
+    signal: AbortSignal.timeout(Number(input.node?.timeout_ms ?? 15_000)),
+  });
+  if (!response.ok) throw new Error(`Hyperliquid market request failed with HTTP ${response.status}.`);
+  const payload = await response.json();
+  const universe = payload?.[0]?.universe;
+  const contexts = payload?.[1];
+  const index = Array.isArray(universe) ? universe.findIndex((entry) => entry?.name === market) : -1;
+  if (index < 0 || !Array.isArray(contexts) || !contexts[index]) {
+    throw new Error(`Hyperliquid production response did not contain ${market}.`);
+  }
+  const metadata = universe[index];
+  const context = contexts[index];
+
+  return withExtensionPage(input, async (page) => {
+    await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
+    await page.waitForSelector(dataTestId('perps-market-detail-pair'), { timeoutMs: 20_000 });
+    const visible = await page.evaluate(`(() => {
+      const read = (testId) => String(document.querySelector('[data-testid="' + testId + '"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
+      const text = read('perps-market-detail-page');
+      const after = (label) => text.match(new RegExp(label + '\\\\s+([^\\\\s]+)', 'u'))?.[1] ?? null;
+      return {
+        route: String(location.hash),
+        name: read('perps-market-detail-name'),
+        pair: read('perps-market-detail-pair'),
+        maxLeverage: read('perps-market-max-leverage'),
+        price: read('perps-market-detail-price'),
+        volume: after('24h Volume'),
+        openInterest: after('Open interest'),
+        fundingRate: after('Funding rate'),
+        oraclePrice: read('perps-market-detail-oracle-price'),
+        favoriteLabel: String(document.querySelector('[data-testid="perps-market-detail-favorite-button"]')?.getAttribute('aria-label') || '').trim(),
+      };
+    })()`);
+    const provider = {
+      symbol: metadata.name,
+      maxLeverage: Number(metadata.maxLeverage),
+      markPrice: Number(context.markPx),
+      oraclePrice: Number(context.oraclePx),
+      volume24hUsd: Number(context.dayNtlVlm),
+      openInterestUsd: Number(context.openInterest) * Number(context.markPx),
+      fundingRate: Number(context.funding),
+    };
+    const observed = {
+      price: numeric(visible.price),
+      oraclePrice: numeric(visible.oraclePrice),
+      volume24hUsd: compactUsd(visible.volume),
+      openInterestUsd: compactUsd(visible.openInterest),
+      fundingRate: numeric(visible.fundingRate) == null ? null : numeric(visible.fundingRate) / 100,
+      maxLeverage: numeric(visible.maxLeverage),
+    };
+    const checks = {
+      route: visible.route === `#/perps/market/${market}`,
+      symbol: visible.pair.startsWith(`${market}-`),
+      name: visible.name.length > 0,
+      maxLeverage: observed.maxLeverage === provider.maxLeverage,
+      price: observed.price != null && relativeDifference(observed.price, provider.markPrice) <= 0.02,
+      oraclePrice: observed.oraclePrice != null && relativeDifference(observed.oraclePrice, provider.oraclePrice) <= 0.02,
+      volume24hUsd: observed.volume24hUsd != null && relativeDifference(observed.volume24hUsd, provider.volume24hUsd) <= 0.05,
+      openInterestUsd: observed.openInterestUsd != null && relativeDifference(observed.openInterestUsd, provider.openInterestUsd) <= 0.05,
+      fundingRate: observed.fundingRate != null && Math.abs(observed.fundingRate - provider.fundingRate) <= 0.00001,
+      favoriteState: /favorites?/iu.test(visible.favoriteLabel),
+    };
+    const failed = Object.entries(checks).filter(([, passed]) => !passed).map(([name]) => name);
+    if (failed.length > 0) {
+      throw new Error(`Visible ${market} market differs from the production provider for: ${failed.join(', ')}.`);
+    }
+    return {
+      action: input.action,
+      market,
+      endpoint,
+      visible,
+      observed,
+      provider,
+      checks,
+      proofPath: 'visible-ui-plus-live-provider',
+    };
+  });
+});

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

@@ -0,0 +1,82 @@
+import { dataTestId, marketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const market = marketSymbol(input);
+  const mode = String(input.node?.margin_action ?? 'add').trim().toLowerCase();
+  const amount = Number(input.node?.amount);
+  if (!market) throw new Error('metamask.perps.edit_margin requires market=<symbol>.');
+  if (mode !== 'add' && mode !== 'remove') {
+    throw new Error(`metamask.perps.edit_margin received unsupported margin_action ${JSON.stringify(mode)}.`);
+  }
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error('metamask.perps.edit_margin requires a positive amount.');
+  }
+  if (input.node?.confirm_live !== true) {
+    throw new Error('metamask.perps.edit_margin requires confirm_live=true for live submission.');
+  }
+
+  await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
+  await page.waitForSelector(dataTestId('perps-position-margin-value'), { timeoutMs: 20_000 });
+  const before = await page.evaluate(`(() => ({
+    margin: String(document.querySelector('[data-testid="perps-position-margin-value"]')?.textContent || '').trim(),
+    liquidation: String(document.querySelector('[data-testid="perps-position-liquidation-value"]')?.textContent || '').trim(),
+  }))()`);
+  await page.click(dataTestId('perps-margin-card'));
+  const menuItem = mode === 'add' ? 'perps-margin-menu-add' : 'perps-margin-menu-remove';
+  await page.waitForSelector(dataTestId(menuItem), { timeoutMs: 10_000 });
+  await page.click(dataTestId(menuItem));
+  const modal = mode === 'add' ? 'perps-add-margin-modal' : 'perps-decrease-margin-modal';
+  await page.waitForSelector(dataTestId(modal), { timeoutMs: 10_000 });
+  await page.setInput(`${dataTestId('perps-edit-margin-amount-input')} input`, String(amount));
+
+  const saveDeadline = Date.now() + 10_000;
+  let ready;
+  while (Date.now() <= saveDeadline) {
+    ready = await page.evaluate(`(() => {
+      const input = document.querySelector('[data-testid="perps-edit-margin-amount-input"] input');
+      const save = document.querySelector('[data-testid="perps-edit-margin-modal-save"]');
+      return {
+        amount: input?.value ?? null,
+        saveEnabled: Boolean(save && !save.disabled && save.getAttribute('aria-disabled') !== 'true'),
+        available: String(document.querySelector('[data-testid="perps-edit-margin-available-value"]')?.textContent || '').trim(),
+        liquidation: String(document.querySelector('[data-testid="perps-edit-margin-liquidation-price-value"]')?.textContent || '').trim(),
+      };
+    })()`);
+    if (ready.saveEnabled) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (Number(ready?.amount) !== amount || !ready?.saveEnabled) {
+    throw new Error(`Perps margin update is not ready: ${JSON.stringify(ready)}.`);
+  }
+  await page.click(dataTestId('perps-edit-margin-modal-save'));
+
+  const resultDeadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
+  let after;
+  while (Date.now() <= resultDeadline) {
+    after = await page.evaluate(`(() => ({
+      modalVisible: Boolean(document.querySelector(${JSON.stringify(dataTestId(modal))})),
+      margin: String(document.querySelector('[data-testid="perps-position-margin-value"]')?.textContent || '').trim(),
+      liquidation: String(document.querySelector('[data-testid="perps-position-liquidation-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 && after.margin && after.margin !== before.margin) break;
+    if (after.errors.length > 0) throw new Error(`Perps margin update failed: ${after.errors.join(' | ')}`);
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  if (!after || after.modalVisible || after.margin === before.margin) {
+    throw new Error(`Perps margin did not reconcile after submission: ${JSON.stringify({ before, after })}.`);
+  }
+  return {
+    action: input.action,
+    market,
+    marginAction: mode,
+    amount,
+    before,
+    ready,
+    after,
+    proofPath: 'visible-product-controls',
+  };
+}));

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

@@ -0,0 +1,58 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+const ACTIONS = new Map([
+  ['add-funds', 'perps-balance-dropdown-add-funds'],
+  ['withdraw', 'perps-balance-dropdown-withdraw'],
+]);
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const balanceAction = String(input.node?.balance_action ?? '').trim().toLowerCase();
+  const actionTestId = ACTIONS.get(balanceAction);
+  if (!actionTestId) {
+    throw new Error(`metamask.perps.open_balance_action received unsupported balance_action ${JSON.stringify(balanceAction)}.`);
+  }
+  await page.click(dataTestId('perps-balance-dropdown-balance'));
+  const actionSelector = dataTestId(actionTestId);
+  const deadline = Date.now() + 10_000;
+  while (Date.now() <= deadline) {
+    const present = await page.evaluate(`(() => Boolean(document.querySelector(${JSON.stringify(actionSelector)})))()`);
+    if (present) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  await page.click(actionSelector);
+  const expected = balanceAction === 'withdraw'
+    ? ['perps-withdraw-page', 'perps-withdraw-container', 'perps-withdraw-view']
+    : ['confirm-page-container-content', 'confirm-page-container', 'transaction-confirmation'];
+  const resultDeadline = Date.now() + 15_000;
+  let observed;
+  while (Date.now() <= resultDeadline) {
+    observed = await page.evaluate(`(() => {
+      const expected = ${JSON.stringify(expected)};
+      const visibleTestIds = [...document.querySelectorAll('[data-testid]')]
+        .filter((element) => {
+          const style = getComputedStyle(element);
+          const rect = element.getBoundingClientRect();
+          return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+        })
+        .map((element) => element.getAttribute('data-testid'))
+        .filter(Boolean);
+      return {
+        route: String(location.hash),
+        matched: expected.filter((testId) => visibleTestIds.includes(testId)),
+        visibleTestIds: visibleTestIds.filter((testId) => /(?:perps|confirm|transaction|amount|token|network)/u.test(testId)).slice(0, 150),
+        text: String(document.body?.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 10_000),
+      };
+    })()`);
+    if (observed.matched.length > 0 || observed.route !== '#/perps-home') break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (!observed || (observed.matched.length === 0 && observed.route === '#/perps-home')) {
+    throw new Error(`Perps ${balanceAction} did not open: ${JSON.stringify(observed)}.`);
+  }
+  return {
+    action: input.action,
+    balanceAction,
+    ...observed,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));