@deeeed/metamask-harness 0.37.0 → 0.38.0

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

@@ -204,6 +204,51 @@ export async function closeOrders(input) {
   requireExplicitSelection(input);
   return withExtensionPage(input, async (page) => {
     const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+    const hasBackgroundRequest = await page.evaluate(
+      `typeof globalThis.stateHooks?.submitRequestToBackground === 'function'`,
+    );
+    if (!hasBackgroundRequest) {
+      if (input.node?.confirm_live !== true) {
+        throw new Error('metamask.perps.close_orders requires confirm_live=true for visible live cancellation.');
+      }
+      const selector = input.node?.selector && typeof input.node.selector === 'object' ? input.node.selector : {};
+      if (input.node?.side != null || selector.side != null) {
+        throw new Error('Visible Perps order cancellation cannot prove an order side. Next: select one market without side or use a runtime with background state hooks.');
+      }
+      const symbols = configuredSymbols(input, []);
+      if (symbols.length !== 1) {
+        throw new Error('Visible Perps order cancellation requires exactly one market.');
+      }
+      const symbol = symbols[0];
+      await page.navigateHash(`#/perps/market/${encodeURIComponent(symbol)}`);
+      const orderSelector = '[data-testid^="order-card-"]';
+      await page.waitForSelector(orderSelector, { timeoutMs });
+      let canceled = 0;
+      while (await page.evaluate(`Boolean(document.querySelector(${JSON.stringify(orderSelector)}))`)) {
+        const beforeCount = await page.evaluate(`document.querySelectorAll(${JSON.stringify(orderSelector)}).length`);
+        await page.click(orderSelector);
+        await page.waitForSelector(dataTestId('perps-cancel-order-modal'), { timeoutMs });
+        await page.click(dataTestId('perps-cancel-order-button'));
+        canceled += 1;
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+          const state = await page.evaluate(`({
+            modal: Boolean(document.querySelector(${JSON.stringify(dataTestId('perps-cancel-order-modal'))})),
+            orders: document.querySelectorAll(${JSON.stringify(orderSelector)}).length,
+          })`);
+          if (!state.modal && state.orders < beforeCount) break;
+          await sleep(250);
+        }
+        if (canceled >= 100) throw new Error('Visible Perps order cancellation exceeded 100 orders.');
+      }
+      return {
+        action: input.action,
+        canceled: canceled > 0,
+        matchingCount: canceled,
+        symbols: [symbol],
+        proofPath: 'visible-product-controls',
+      };
+    }
     const before = await readOpenOrders(page);
     const matching = selectedItems(input, before);
     const symbols = uniqueSymbols(matching.map(symbolForItem));
@@ -463,8 +508,17 @@ export async function placeOrder(input) {
   const leverage = Number(input.node?.leverage ?? 3);
   const isBuy = side !== 'short';
   const orderType = resolveOrderType(input);
+  const positionMode = String(input.node?.position_mode ?? 'new').toLowerCase();
+  const submitAttempts = Number(input.node?.submit_attempts ?? 1);
+  if (positionMode !== 'new' && positionMode !== 'modify') {
+    throw new Error(`${input.action} received unsupported position_mode: ${positionMode}.`);
+  }
+  if (!Number.isInteger(submitAttempts) || submitAttempts < 1 || submitAttempts > 2) {
+    throw new Error(`${input.action} submit_attempts must be 1 or 2.`);
+  }
   return withExtensionPage(input, async (page) => {
     await page.navigateHash(`#/perps/market/${encodeURIComponent(symbol)}`);
+    await page.waitForSelector(dataTestId('perps-market-detail-pair'), { timeoutMs: 20_000 });
     await page.evaluate(`(async () => {
       const request = globalThis.stateHooks?.submitRequestToBackground;
       if (typeof request !== 'function') return;
@@ -482,8 +536,146 @@ export async function placeOrder(input) {
     const limitPrice = orderType === 'limit'
       ? resolveLimitPrice(input, isBuy, resolvedPrice)
       : null;
-    await page.navigateHash(`#/perps/trade/${encodeURIComponent(symbol)}?direction=${encodeURIComponent(side)}&mode=new`);
+    const initialPositionSize = positionMode === 'modify'
+      ? await page.evaluate(`document.querySelector('[data-testid="perps-position-size-value"]')?.textContent?.trim() ?? null`)
+      : null;
+    const initialOpenOrderCount = orderType === 'limit'
+      ? await page.evaluate(`document.querySelectorAll('[data-testid^="order-card-"]').length`)
+      : null;
+    await page.navigateHash(`#/perps/trade/${encodeURIComponent(symbol)}?direction=${encodeURIComponent(side)}&mode=${positionMode}`);
     await page.waitForSelector(dataTestId('perps-order-entry-page'), { timeoutMs: 20000 });
+    const hasBackgroundRequest = await page.evaluate(
+      `typeof globalThis.stateHooks?.submitRequestToBackground === 'function'`,
+    );
+    if (!hasBackgroundRequest) {
+      if (input.node?.confirm_live !== true) {
+        throw new Error('metamask.perps.place_order requires confirm_live=true for visible live submission.');
+      }
+      await page.setInput(`${dataTestId('amount-input-field')} input`, amount);
+      await page.setInput(`${dataTestId('leverage-input')} input`, String(leverage));
+      if (orderType === 'limit') {
+        await page.click(dataTestId('order-type-limit'));
+        const limitInput = `${dataTestId('limit-price-input')} input`;
+        await page.waitForSelector(limitInput, { timeoutMs: 10000 });
+        await page.setInput(limitInput, String(limitPrice));
+      }
+      const configuredDeadline = Date.now() + 10_000;
+      let configured;
+      while (Date.now() < configuredDeadline) {
+        configured = await page.evaluate(`(() => {
+          const value = (testId) => document.querySelector('[data-testid="' + testId + '"] input')?.value ?? null;
+          const limit = document.querySelector('[data-testid="limit-price-input"] input')?.value ?? null;
+          const submit = document.querySelector('[data-testid="submit-order-button"]');
+          return {
+            amount: value('amount-input-field'),
+            leverage: value('leverage-input'),
+            limitPrice: limit,
+            limitSelected: document.querySelector('[data-testid="order-type-limit"]')?.getAttribute('aria-pressed') === 'true',
+            submitEnabled: Boolean(submit && !submit.disabled && submit.getAttribute('aria-disabled') !== 'true'),
+            validation: [...document.querySelectorAll('[role="alert"], [data-testid$="validation-error"], [data-testid$="warning"]')]
+              .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim())
+              .filter(Boolean)
+              .slice(0, 20),
+          };
+        })()`);
+        if (configured.submitEnabled) break;
+        await sleep(250);
+      }
+      if (Number(configured.amount) !== Number(amount) || Number(configured.leverage) !== leverage) {
+        throw new Error(`Visible Perps order inputs did not retain the requested values: ${JSON.stringify(configured)}.`);
+      }
+      if (orderType === 'limit' && (!configured.limitSelected || Number(configured.limitPrice) !== limitPrice)) {
+        throw new Error(`Visible Perps limit inputs did not retain the requested values: ${JSON.stringify(configured)}.`);
+      }
+      if (!configured.submitEnabled) {
+        throw new Error(`Visible Perps order is not submittable: ${JSON.stringify(configured)}.`);
+      }
+      const submitTarget = await page.evaluate(`(() => {
+        const element = document.querySelector('[data-testid="submit-order-button"]');
+        if (!element) throw new Error('Visible Perps submit control disappeared.');
+        element.scrollIntoView({ block: 'center', inline: 'center' });
+        const rect = element.getBoundingClientRect();
+        return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+      })()`);
+      for (let attempt = 0; attempt < submitAttempts; attempt += 1) {
+        await page.session.call('Input.dispatchMouseEvent', {
+          type: 'mousePressed',
+          x: submitTarget.x,
+          y: submitTarget.y,
+          button: 'left',
+          buttons: 1,
+          clickCount: 1,
+        });
+        await page.session.call('Input.dispatchMouseEvent', {
+          type: 'mouseReleased',
+          x: submitTarget.x,
+          y: submitTarget.y,
+          button: 'left',
+          buttons: 0,
+          clickCount: 1,
+        });
+      }
+      const resultSelector = orderType === 'limit'
+        ? '[data-testid^="order-card-"]'
+        : dataTestId('perps-position-size-value');
+      const resultDeadline = Date.now() + Number(input.node?.timeout_ms ?? 45000);
+      let outcome;
+      while (Date.now() < resultDeadline) {
+        outcome = await page.evaluate(`(() => ({
+          success: ${JSON.stringify(positionMode)} === 'modify'
+            ? String(location.hash).startsWith(${JSON.stringify(`#/perps/market/${symbol}`)}) &&
+              String(document.querySelector('[data-testid="perps-position-size-value"]')?.textContent || '').trim() !== ${JSON.stringify(initialPositionSize)}
+            : Boolean(document.querySelector(${JSON.stringify(resultSelector)})),
+          route: String(location.hash),
+          submit: (() => {
+            const element = document.querySelector('[data-testid="submit-order-button"]');
+            return element ? {
+              label: String(element.innerText || '').replace(/\\s+/gu, ' ').trim(),
+              enabled: !element.disabled && element.getAttribute('aria-disabled') !== 'true',
+            } : null;
+          })(),
+          errors: [...document.querySelectorAll('[data-testid="perps-order-submit-error"], [role="alert"]')]
+            .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim())
+            .filter(Boolean)
+            .slice(0, 20),
+        }))()`);
+        if (outcome.success) break;
+        if (outcome.errors.length > 0) {
+          throw new Error(`Visible Perps order submission failed: ${outcome.errors.join(' | ')}`);
+        }
+        await sleep(250);
+      }
+      if (!outcome?.success) {
+        throw new Error(`Visible Perps order submission did not produce ${resultSelector}; observed ${JSON.stringify(outcome)}.`);
+      }
+      let openOrderCount = null;
+      if (orderType === 'limit') {
+        await sleep(2_000);
+        await page.navigateHash(`#/perps/market/${encodeURIComponent(symbol)}`);
+        await page.waitForSelector(dataTestId('perps-market-detail-pair'), { timeoutMs: 20_000 });
+        openOrderCount = await page.evaluate(`document.querySelectorAll('[data-testid^="order-card-"]').length`);
+        if (openOrderCount !== initialOpenOrderCount + 1) {
+          throw new Error(`Perps limit submission created an unexpected open-order count: before=${initialOpenOrderCount}, after=${openOrderCount}.`);
+        }
+      }
+      return {
+        action: input.action,
+        market: symbol,
+        side,
+        orderType,
+        positionMode,
+        amount,
+        leverage,
+        limitPrice,
+        submitted: true,
+        submitAttempts,
+        initialOpenOrderCount,
+        openOrderCount,
+        configured,
+        outcome,
+        proofPath: 'visible-product-controls',
+      };
+    }
     let order;
     try {
       order = await page.evaluate(`(async () => {
@@ -532,7 +724,7 @@ export async function placeOrder(input) {
     } else {
       await waitForPositionPresent(page, symbol, Number(input.node?.timeout_ms ?? 30000));
     }
-    return { action: input.action, market: symbol, side, orderType, amount, leverage, limitPrice, submitted: true, order, proofPath: 'background-perpsPlaceOrder' };
+    return { action: input.action, market: symbol, side, orderType, positionMode, amount, leverage, limitPrice, submitted: true, order, proofPath: 'background-perpsPlaceOrder' };
   });
 }
 

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

@@ -1,7 +1,10 @@
 import { runAdapter } from '../platform/cdp.mjs';
-import { assertPositions, placeOrder } from './perps.mjs';
+import { assertOrders, assertPositions, placeOrder } from './perps.mjs';
 runAdapter(async (input) => {
   const order = await placeOrder(input);
-  const assertion = await assertPositions(input, true);
+  if (order.proofPath === 'visible-product-controls') return order;
+  const assertion = order.orderType === 'limit'
+    ? await assertOrders(input, true)
+    : await assertPositions(input, true);
   return { ...assertion, submitted: order.submitted === true, order };
 });

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

@@ -0,0 +1,34 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+runAdapter(async (input) => {
+  const endpoint = 'https://geolocation.api.cx.metamask.io/v2/geolocation';
+  const response = await fetch(endpoint, { signal: AbortSignal.timeout(Number(input.node?.timeout_ms ?? 15_000)) });
+  if (!response.ok) throw new Error(`MetaMask geolocation request failed with HTTP ${response.status}.`);
+  const geolocation = await response.json();
+  return withExtensionPage(input, async (page) => {
+    const product = await page.evaluate(`(async () => {
+      const hooks = globalThis.stateHooks || {};
+      const root = (await hooks.getCleanAppState?.()) || hooks.store?.getState?.() || {};
+      const metamask = root.metamask || root;
+      return {
+        isEligible: metamask.isEligible ?? null,
+        geoBlockModalVisible: Boolean(document.querySelector('[data-testid="perps-geo-block-modal"]')),
+        route: String(location.hash),
+      };
+    })()`, { awaitPromise: true });
+    if (typeof product.isEligible !== 'boolean') {
+      throw new Error('The release UI did not expose the current Perps eligibility state.');
+    }
+    return {
+      action: input.action,
+      endpoint,
+      geolocation: {
+        country: geolocation?.country ?? null,
+        region: geolocation?.region ?? null,
+        timezone: geolocation?.timezone ?? null,
+      },
+      product,
+      proofPath: 'release-state-plus-live-geolocation',
+    };
+  });
+});

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

@@ -0,0 +1,69 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const mode = String(input.node?.mode ?? '').trim().toLowerCase();
+  if (mode !== 'deposit' && mode !== 'withdraw') {
+    throw new Error('metamask.perps.read_funds_confirmation mode must be deposit or withdraw.');
+  }
+  const expectedTitle = mode === 'deposit' ? 'Deposit funds to Perps' : 'Withdraw';
+  const deadline = Date.now() + 30_000;
+  let observed;
+  while (Date.now() <= deadline) {
+    observed = await page.evaluate(`(() => {
+      const read = (testId) => String(document.querySelector('[data-testid="' + testId + '"]')?.innerText || '')
+        .replace(/\\s+/gu, ' ')
+        .trim()
+        .slice(0, 500);
+      const amount = document.querySelector('[data-testid="custom-amount-input"]');
+      const submit = document.querySelector('[data-testid="confirm-footer-button"]');
+      return {
+        route: String(location.hash),
+        title: String(document.body?.innerText || '').trim().split(/\\n+/u)[0] || '',
+        amount: amount && 'value' in amount ? String(amount.value) : null,
+        availableBalance: read('perps-withdraw-balance-value'),
+        transactionFee: read('transaction-fee-value'),
+        estimatedTime: read('bridge-time-value'),
+        receive: read('receive-value'),
+        payToken: String(document.body?.innerText || '').match(/Pay with\\s+([^\\n]+)/u)?.[1] || '',
+        submitLabel: String(submit?.innerText || '').trim(),
+        submitEnabled: Boolean(submit && !submit.disabled && submit.getAttribute('aria-disabled') !== 'true'),
+        layout: {
+          viewportWidth: innerWidth,
+          viewportHeight: innerHeight,
+          contentWidth: Math.max(document.documentElement?.scrollWidth || 0, document.body?.scrollWidth || 0),
+          horizontalOverflow: Math.max(document.documentElement?.scrollWidth || 0, document.body?.scrollWidth || 0) > innerWidth + 1,
+          clippedTestIds: [...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 &&
+                rect.bottom > 0 && rect.top < innerHeight && (rect.left < -1 || rect.right > innerWidth + 1);
+            })
+            .map((element) => element.getAttribute('data-testid'))
+            .filter(Boolean)
+            .slice(0, 100),
+        },
+      };
+    })()`);
+    if (observed.title === expectedTitle && observed.amount !== null) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (observed?.title !== expectedTitle || observed?.amount === null) {
+    throw new Error(`Perps ${mode} confirmation did not finish loading.`);
+  }
+  if (input.node?.require_no_horizontal_overflow === true && (
+    observed.layout.horizontalOverflow || observed.layout.clippedTestIds.length > 0
+  )) {
+    throw new Error(`Visible Perps funds layout overflows horizontally: ${JSON.stringify(observed.layout)}.`);
+  }
+  if (typeof input.node?.expected_submit_enabled === 'boolean'
+    && observed.submitEnabled !== input.node.expected_submit_enabled) {
+    throw new Error(`Perps ${mode} submit state mismatch: expected ${input.node.expected_submit_enabled}, observed ${observed.submitEnabled}.`);
+  }
+  return {
+    action: input.action,
+    mode,
+    ...observed,
+    proofPath: 'visible-dom-accessibility',
+  };
+}));

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

@@ -0,0 +1,98 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  normalizeVisiblePerpsState,
+  resolveVisibleStateOptions,
+} from '../../shared/perps/visible-state.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const options = resolveVisibleStateOptions(input.node);
+  const raw = await page.evaluate(`(() => {
+    const includeOffscreen = ${JSON.stringify(options.includeOffscreen)};
+    const maximum = ${JSON.stringify(options.maxItems)};
+    const relevant = /^(?:perps-|explore-markets-|market-list-view|market-row-|filter-select-button|sort-dropdown-button|search-input|position-card-|order-card-|transaction-card-|bottom-nav-perps|direction-|order-type-|amount-|balance-percent-|leverage-|auto-close|submit-order-button|limit-price-|tp-|sl-)/u;
+    const items = [];
+    const offscreenItems = [];
+    const clippedTestIds = [];
+    let matched = 0;
+    for (const element of document.querySelectorAll('[data-testid]')) {
+      const testId = element.getAttribute('data-testid');
+      if (!testId || !relevant.test(testId)) continue;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      const rendered = style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+      if (!rendered) continue;
+      matched += 1;
+      const visible = rect.bottom > 0 && rect.right > 0 && rect.top < innerHeight && rect.left < innerWidth;
+      if (rect.bottom > 0 && rect.top < innerHeight && (rect.left < -1 || rect.right > innerWidth + 1)) {
+        clippedTestIds.push(testId);
+      }
+      if (!visible && !includeOffscreen) continue;
+      if (items.length + offscreenItems.length >= maximum) break;
+      const label = String(element.getAttribute('aria-label') || element.innerText || element.getAttribute('value') || '')
+        .replace(/\\s+/gu, ' ')
+        .trim()
+        .slice(0, 500);
+      const item = {
+        testId,
+        label,
+        role: element.getAttribute('role') || element.tagName.toLowerCase(),
+        enabled: !element.disabled && element.getAttribute('aria-disabled') !== 'true',
+        visible,
+      };
+      (visible ? items : offscreenItems).push(item);
+    }
+    const field = (testId) => {
+      const element = document.querySelector('[data-testid="' + testId + '"]');
+      const input = element?.matches('input') ? element : element?.querySelector('input');
+      if (!element) return null;
+      return {
+        testId,
+        label: String(element.innerText || element.getAttribute('aria-label') || '').replace(/\\s+/gu, ' ').trim().slice(0, 500),
+        value: input && 'value' in input ? String(input.value) : null,
+        checked: input?.checked === true,
+        enabled: !element.disabled && element.getAttribute('aria-disabled') !== 'true',
+        pressed: element.getAttribute('aria-pressed'),
+      };
+    };
+    const submit = field('submit-order-button');
+    const direction = submit?.label.match(/\\b(long|short)\\b/iu)?.[1]?.toLowerCase() ||
+      String(location.hash).match(/[?&]direction=(long|short)(?:&|$)/u)?.[1] ||
+      null;
+    return {
+      route: location.hash,
+      title: document.title,
+      items,
+      offscreenItems,
+      truncated: matched > items.length + offscreenItems.length,
+      orderEntry: document.querySelector('[data-testid="perps-order-entry-page"]') ? {
+        symbol: field('perps-order-entry-asset-symbol')?.label || null,
+        direction,
+        orderType: field('order-type-limit')?.pressed === 'true' ? 'limit' : 'market',
+        amount: field('amount-input-field')?.value,
+        percent: field('balance-percent-input')?.value,
+        leverage: field('leverage-input')?.value,
+        autoClose: field('auto-close-toggle')?.checked === true,
+        takeProfitPrice: field('tp-price-input')?.value,
+        stopLossPrice: field('sl-price-input')?.value,
+        submit,
+        limitPrice: field('limit-price-input')?.value,
+        validation: [...document.querySelectorAll('[data-testid$="validation-error"], [role="alert"]')]
+          .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim())
+          .filter(Boolean)
+          .slice(0, 20),
+      } : null,
+      layout: {
+        viewportWidth: innerWidth,
+        viewportHeight: innerHeight,
+        contentWidth: Math.max(document.documentElement?.scrollWidth || 0, document.body?.scrollWidth || 0),
+        horizontalOverflow: Math.max(document.documentElement?.scrollWidth || 0, document.body?.scrollWidth || 0) > innerWidth + 1,
+        clippedTestIds: [...new Set(clippedTestIds)].slice(0, 100),
+      },
+    };
+  })()`);
+  return {
+    action: input.action,
+    ...normalizeVisiblePerpsState(raw, options, 'extension'),
+    proofPath: 'visible-dom-accessibility',
+  };
+}));

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

@@ -0,0 +1,44 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+const FILTERS = new Map([
+  ['trades', 'trade'],
+  ['orders', 'order'],
+  ['funding', 'funding'],
+  ['deposits', 'deposit'],
+]);
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const filter = String(input.node?.filter ?? '').trim().toLowerCase();
+  const option = FILTERS.get(filter);
+  if (!option) {
+    throw new Error(`metamask.perps.select_activity_filter received unsupported filter ${JSON.stringify(filter)}.`);
+  }
+  await page.click(dataTestId('perps-activity-filter-button'));
+  await page.click(dataTestId(`perps-activity-filter-option-${option}`));
+  await new Promise((resolve) => setTimeout(resolve, 300));
+  const observed = await page.evaluate(`(() => {
+    const button = document.querySelector('[data-testid="perps-activity-filter-button"]');
+    const entries = [...document.querySelectorAll('[data-testid^="transaction-card-"]')]
+      .slice(0, 200)
+      .map((element) => String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500));
+    return {
+      route: String(location.hash),
+      selected: String(button?.innerText || '').trim(),
+      entries,
+      empty: String(document.body?.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 2_000),
+    };
+  })()`);
+  if (observed.route !== '#/perps/activity') throw new Error('Perps activity filter left the activity route.');
+  if (observed.selected.toLowerCase() !== filter) {
+    throw new Error(`Expected Perps activity filter ${filter}, but observed ${observed.selected || 'none'}.`);
+  }
+  return {
+    action: input.action,
+    filter,
+    selected: observed.selected,
+    count: observed.entries.length,
+    entries: observed.entries,
+    empty: observed.entries.length === 0 ? observed.empty : undefined,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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

@@ -0,0 +1,71 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  normalizeVisiblePerpsState,
+  resolveVisibleStateOptions,
+} from '../../shared/perps/visible-state.mjs';
+
+const FILTERS = new Map([
+  ['all', 'all'],
+  ['crypto', 'crypto'],
+  ['stocks', 'stock'],
+  ['pre-ipo', 'pre-ipo'],
+  ['index', 'index'],
+  ['etf', 'etf'],
+  ['commodities', 'commodity'],
+  ['forex', 'forex'],
+  ['new', 'new'],
+]);
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const filter = String(input.node?.filter ?? '').trim().toLowerCase();
+  const option = FILTERS.get(filter);
+  if (!option) {
+    throw new Error(`metamask.perps.select_market_filter received unsupported filter ${JSON.stringify(filter)}.`);
+  }
+  const options = resolveVisibleStateOptions({
+    surface: 'market-list',
+    include_offscreen: true,
+    max_items: input.node?.max_items ?? 100,
+    minimum_market_count: input.node?.minimum_market_count ?? 1,
+    maximum_market_count: input.node?.maximum_market_count ?? 200,
+  });
+  await page.click(dataTestId('filter-select-button'));
+  const optionSelector = dataTestId(`filter-select-option-${option}`);
+  const found = await page.evaluate(`(() => Boolean(document.querySelector(${JSON.stringify(optionSelector)})))()`);
+  if (!found) {
+    throw new Error(`Perps market filter ${JSON.stringify(filter)} is not available in this release.`);
+  }
+  await page.click(optionSelector);
+  await new Promise((resolve) => setTimeout(resolve, 300));
+  const raw = await page.evaluate(`(() => {
+    const maximum = ${JSON.stringify(options.maxItems)};
+    const items = [];
+    let matched = 0;
+    for (const element of document.querySelectorAll('[data-testid]')) {
+      const testId = element.getAttribute('data-testid');
+      if (!testId || !/^(?:market-list-view|market-row-|perps-token-logo-|filter-select-button)/u.test(testId)) continue;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) continue;
+      matched += 1;
+      if (items.length >= maximum) break;
+      items.push({
+        testId,
+        label: String(element.getAttribute('aria-label') || element.innerText || element.getAttribute('value') || '')
+          .replace(/\\s+/gu, ' ')
+          .trim()
+          .slice(0, 500),
+        role: element.getAttribute('role') || element.tagName.toLowerCase(),
+        enabled: !element.disabled && element.getAttribute('aria-disabled') !== 'true',
+        visible: rect.bottom > 0 && rect.right > 0 && rect.top < innerHeight && rect.left < innerWidth,
+      });
+    }
+    return { route: location.hash, title: document.title, items, offscreenItems: [], truncated: matched > items.length };
+  })()`);
+  return {
+    action: input.action,
+    filter,
+    ...normalizeVisiblePerpsState(raw, options, 'extension'),
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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

@@ -0,0 +1,47 @@
+import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const market = String(input.node?.market ?? '').trim().toUpperCase();
+  if (!/^[A-Z0-9:_-]{2,20}$/u.test(market)) {
+    throw new Error('metamask.perps.set_market_favorite requires a valid market symbol.');
+  }
+  if (typeof input.node?.favorite !== 'boolean') {
+    throw new Error('metamask.perps.set_market_favorite requires favorite=true or false.');
+  }
+  const desired = input.node.favorite;
+  const selector = dataTestId('perps-market-detail-favorite-button');
+  const readState = () => page.evaluate(`(() => {
+    const market = ${JSON.stringify(market)};
+    const pair = String(document.querySelector('[data-testid="perps-market-detail-pair"]')?.innerText || '')
+      .trim()
+      .toUpperCase();
+    if (!pair.startsWith(market + '-')) throw new Error('Visible Perps market does not match the requested favorite market.');
+    const button = document.querySelector(${JSON.stringify(selector)});
+    if (!button) throw new Error('Perps favorite control is not visible.');
+    const label = String(button.getAttribute('aria-label') || button.innerText || '').trim();
+    return { label, favorite: /^remove from favorites$/iu.test(label) };
+  })()`);
+  const before = await readState();
+  if (before.favorite !== desired) {
+    await page.click(selector);
+  }
+  const deadline = Date.now() + 10_000;
+  let after = before;
+  while (Date.now() <= deadline) {
+    after = await readState();
+    if (after.favorite === desired) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (after.favorite !== desired) {
+    throw new Error(`Perps favorite state did not become ${desired}.`);
+  }
+  return {
+    action: input.action,
+    market,
+    requestedFavorite: desired,
+    changed: before.favorite !== after.favorite,
+    before,
+    after,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));