@deeeed/metamask-harness 0.36.0 → 0.38.0

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

@@ -0,0 +1,470 @@
+import { pathToFileURL } from 'node:url';
+
+import { normalizeMarketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+const ALL_SECTIONS = ['account', 'markets', 'positions', 'orders', 'history', 'watchlist'];
+const DEFAULT_HISTORY_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
+const MAX_HISTORY_WINDOW_MS = 365 * 24 * 60 * 60 * 1000;
+
+function boundedInteger(value, fallback, minimum, maximum, name) {
+  const resolved = value == null ? fallback : Number(value);
+  if (!Number.isInteger(resolved) || resolved < minimum || resolved > maximum) {
+    throw new Error(`metamask.perps.read_snapshot ${name} must be an integer from ${minimum} to ${maximum}.`);
+  }
+  return resolved;
+}
+
+function requestedMarkets(node) {
+  if (node.market != null && node.markets != null) {
+    throw new Error('metamask.perps.read_snapshot accepts market or markets, not both.');
+  }
+  const values = node.markets ?? (node.market == null ? [] : [node.market]);
+  if (!Array.isArray(values)) {
+    throw new Error('metamask.perps.read_snapshot markets must be an array of market symbols.');
+  }
+  const markets = Array.from(new Set(
+    values.map((value) => typeof value === 'string' ? normalizeMarketSymbol(value) : '').filter(Boolean),
+  ));
+  if (markets.length > 100) {
+    throw new Error('metamask.perps.read_snapshot accepts at most 100 market symbols.');
+  }
+  return markets;
+}
+
+export function resolveSnapshotOptions(input, now = Date.now()) {
+  const node = input.node ?? {};
+  const include = node.include ?? ALL_SECTIONS;
+  if (!Array.isArray(include) || include.length === 0) {
+    throw new Error('metamask.perps.read_snapshot include must be a non-empty array.');
+  }
+  const sections = Array.from(new Set(include.map((section) => String(section).toLowerCase())));
+  const unsupported = sections.filter((section) => !ALL_SECTIONS.includes(section));
+  if (unsupported.length > 0) {
+    throw new Error(`metamask.perps.read_snapshot received unsupported sections: ${unsupported.join(', ')}.`);
+  }
+
+  const history = node.history && typeof node.history === 'object' && !Array.isArray(node.history)
+    ? node.history
+    : {};
+  const endTime = boundedInteger(
+    history.end_time_ms,
+    now,
+    0,
+    Number.MAX_SAFE_INTEGER,
+    'history.end_time_ms',
+  );
+  const startTime = boundedInteger(
+    history.start_time_ms,
+    Math.max(0, endTime - DEFAULT_HISTORY_WINDOW_MS),
+    0,
+    Number.MAX_SAFE_INTEGER,
+    'history.start_time_ms',
+  );
+  if (startTime > endTime) {
+    throw new Error('metamask.perps.read_snapshot history.start_time_ms must not exceed history.end_time_ms.');
+  }
+  if (endTime - startTime > MAX_HISTORY_WINDOW_MS) {
+    throw new Error('metamask.perps.read_snapshot history range must not exceed 365 days.');
+  }
+
+  return {
+    include: sections,
+    markets: requestedMarkets(node),
+    timeoutMs: boundedInteger(node.timeout_ms, 20000, 1000, 60000, 'timeout_ms'),
+    maxItems: boundedInteger(node.max_items_per_section, 100, 1, 500, 'max_items_per_section'),
+    history: {
+      startTime,
+      endTime,
+      accountId: history.account_id == null || history.account_id === ''
+        ? undefined
+        : String(history.account_id),
+      limit: boundedInteger(history.limit, 100, 1, 500, 'history.limit'),
+    },
+  };
+}
+
+export function snapshotRequestExpression(options) {
+  const methods = {
+    account: ['perpsGetAccountState', []],
+    markets: ['perpsGetMarketDataWithPrices', []],
+    positions: ['perpsGetPositions', []],
+    orders: ['perpsGetOpenOrders', []],
+    history: ['perpsGetUserHistory', null],
+    watchlist: ['perpsGetWatchlistMarkets', []],
+  };
+  return `(async () => {
+    const request = globalThis.stateHooks?.submitRequestToBackground;
+    if (typeof request !== 'function') {
+      throw new Error('stateHooks.submitRequestToBackground is unavailable; cannot read live Perps snapshot.');
+    }
+    const timeoutMs = ${JSON.stringify(options.timeoutMs)};
+    const historyParams = {
+      startTime: ${JSON.stringify(options.history.startTime)},
+      endTime: ${JSON.stringify(options.history.endTime)},
+      accountId: ${options.history.accountId === undefined ? 'undefined' : JSON.stringify(options.history.accountId)},
+    };
+    const methods = ${JSON.stringify(methods)};
+    const markets = ${JSON.stringify(options.markets)};
+    const maxItems = ${JSON.stringify(options.maxItems)};
+    const historyLimit = ${JSON.stringify(Math.min(options.history.limit, options.maxItems))};
+    function field(record, names) {
+      for (const name of names) {
+        const value = record?.[name];
+        if (value === null || ['string', 'number', 'boolean'].includes(typeof value)) return value;
+      }
+      return null;
+    }
+    function marketFor(item) {
+      const value = field(item, ['symbol', 'coin', 'market', 'asset']);
+      return typeof value === 'string' ? value.replace(/-PERP$/iu, '').toUpperCase() : '';
+    }
+    function sideFor(item) {
+      const side = String(field(item, ['side', 'direction']) ?? '').toLowerCase();
+      if (['buy', 'b', 'long'].includes(side)) return 'long';
+      if (['sell', 'a', 's', 'short'].includes(side)) return 'short';
+      return side || null;
+    }
+    function leverageFor(item) {
+      const leverage = item?.leverage;
+      if (leverage === null || ['string', 'number'].includes(typeof leverage)) return leverage;
+      if (!leverage || typeof leverage !== 'object' || Array.isArray(leverage)) return null;
+      return { type: field(leverage, ['type']), value: field(leverage, ['value']) };
+    }
+    function normalize(section, item) {
+      if (section === 'markets') return {
+        market: marketFor(item) || null,
+        name: field(item, ['name']),
+        price: field(item, ['price', 'currentPrice']),
+        markPrice: field(item, ['markPrice', 'markPx']),
+        oraclePrice: field(item, ['oraclePrice', 'oraclePx']),
+        change24hPercent: field(item, ['change24hPercent', 'priceChange24h']),
+        volume24h: field(item, ['volume24h', 'dayNtlVlm']),
+        openInterest: field(item, ['openInterest']),
+        fundingRate: field(item, ['fundingRate', 'funding']),
+        maxLeverage: field(item, ['maxLeverage']),
+      };
+      if (section === 'positions') return {
+        market: marketFor(item) || null,
+        side: sideFor(item),
+        size: field(item, ['size', 'szi']),
+        entryPrice: field(item, ['entryPrice', 'entryPx']),
+        positionValue: field(item, ['positionValue']),
+        leverage: leverageFor(item),
+        liquidationPrice: field(item, ['liquidationPrice', 'liquidationPx']),
+        marginUsed: field(item, ['marginUsed']),
+        unrealizedPnl: field(item, ['unrealizedPnl']),
+        returnOnEquity: field(item, ['returnOnEquity']),
+        takeProfitPrice: field(item, ['takeProfitPrice']),
+        stopLossPrice: field(item, ['stopLossPrice']),
+      };
+      if (section === 'orders') return {
+        orderId: field(item, ['orderId', 'id', 'oid']),
+        market: marketFor(item) || null,
+        side: sideFor(item),
+        size: field(item, ['size', 'sz', 'szi']),
+        price: field(item, ['price', 'limitPx', 'px']),
+        type: field(item, ['orderType', 'type']),
+        status: field(item, ['status']),
+        timestamp: field(item, ['timestamp', 'time']),
+        reduceOnly: field(item, ['reduceOnly']),
+        isTrigger: field(item, ['isTrigger']),
+        triggerPrice: field(item, ['triggerPrice', 'triggerPx']),
+        triggerOrderType: field(item, ['triggerOrderType']),
+        takeProfitPrice: field(item, ['takeProfitPrice']),
+        stopLossPrice: field(item, ['stopLossPrice']),
+      };
+      return {
+        type: field(item, ['type', 'activityType']),
+        status: field(item, ['status']),
+        asset: field(item, ['asset', 'token', 'currency']),
+        market: marketFor(item) || null,
+        amount: field(item, ['amount', 'value']),
+        fee: field(item, ['fee']),
+        timestamp: field(item, ['timestamp', 'time']),
+        transactionHash: field(item, ['transactionHash', 'txHash', 'hash']),
+      };
+    }
+    function transport(section, value) {
+      if (section === 'account') {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) return { value };
+        const allowed = ${JSON.stringify([
+          'accountValue', 'totalBalance', 'balance', 'spendableBalance',
+          'withdrawableBalance', 'availableBalance', 'availableToTradeBalance',
+          'marginUsed', 'maintenanceMargin', 'unrealizedPnl', 'returnOnEquity',
+        ])};
+        return { value: Object.fromEntries(allowed.map((name) => [name, field(value, [name])]).filter(([, item]) => item !== null)) };
+      }
+      if (!Array.isArray(value)) return { value };
+      if (section === 'watchlist') {
+        const items = value.map((item) => typeof item === 'string' ? item : marketFor(item)).filter(Boolean);
+        const selected = markets.length === 0 ? items : items.filter((item) => markets.includes(String(item).replace(/-PERP$/iu, '').toUpperCase()));
+        const bounded = selected.slice(0, maxItems).map((item) => String(item).replace(/-PERP$/iu, '').toUpperCase());
+        return { value: bounded, totalCount: value.length, matchingCount: selected.length, truncated: bounded.length < selected.length, transportBound: true };
+      }
+      const selected = markets.length === 0 ? value : value.filter((item) => markets.includes(marketFor(item)));
+      const limit = section === 'history' ? historyLimit : maxItems;
+      const bounded = selected.slice(0, limit).map((item) => normalize(section, item));
+      return { value: bounded, totalCount: value.length, matchingCount: selected.length, truncated: bounded.length < selected.length, transportBound: true };
+    }
+    async function read(section) {
+      const [method, configuredArgs] = methods[section];
+      const args = section === 'history' ? [historyParams] : configuredArgs;
+      let timeoutId;
+      try {
+        const value = await Promise.race([
+          request(method, args),
+          new Promise((_, reject) => {
+            timeoutId = setTimeout(
+              () => reject(new Error(method + ' timed out after ' + timeoutMs + 'ms')),
+              timeoutMs,
+            );
+          }),
+        ]);
+        return [section, { ok: true, method, ...transport(section, value) }];
+      } catch (error) {
+        return [section, {
+          ok: false,
+          method,
+          error: error instanceof Error ? error.message : String(error),
+        }];
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    return Object.fromEntries(await Promise.all(${JSON.stringify(options.include)}.map(read)));
+  })()`;
+}
+
+function field(record, names) {
+  for (const name of names) {
+    const value = record?.[name];
+    if (value === null || ['string', 'number', 'boolean'].includes(typeof value)) return value;
+  }
+  return null;
+}
+
+function normalizedSide(item) {
+  const side = String(field(item, ['side', 'direction']) ?? '').toLowerCase();
+  if (side === 'buy' || side === 'b' || side === 'long') return 'long';
+  if (side === 'sell' || side === 'a' || side === 's' || side === 'short') return 'short';
+  return side || null;
+}
+
+function normalizedLeverage(item) {
+  const leverage = item?.leverage;
+  if (leverage === null || ['string', 'number'].includes(typeof leverage)) return leverage;
+  if (!leverage || typeof leverage !== 'object' || Array.isArray(leverage)) return null;
+  return {
+    type: field(leverage, ['type']),
+    value: field(leverage, ['value']),
+  };
+}
+
+function marketForItem(item) {
+  const value = field(item, ['symbol', 'coin', 'market', 'asset']);
+  return typeof value === 'string' && value.length > 0 ? normalizeMarketSymbol(value) : '';
+}
+
+function normalizeAccount(account) {
+  const allowed = [
+    'accountValue',
+    'totalBalance',
+    'balance',
+    'spendableBalance',
+    'withdrawableBalance',
+    'availableBalance',
+    'availableToTradeBalance',
+    'marginUsed',
+    'maintenanceMargin',
+    'unrealizedPnl',
+    'returnOnEquity',
+  ];
+  return Object.fromEntries(
+    allowed
+      .map((name) => [name, field(account, [name])])
+      .filter(([, value]) => value !== null),
+  );
+}
+
+function normalizeMarket(item) {
+  return {
+    market: marketForItem(item) || null,
+    name: field(item, ['name']),
+    price: field(item, ['price', 'currentPrice']),
+    markPrice: field(item, ['markPrice', 'markPx']),
+    oraclePrice: field(item, ['oraclePrice', 'oraclePx']),
+    change24hPercent: field(item, ['change24hPercent', 'priceChange24h']),
+    volume24h: field(item, ['volume24h', 'dayNtlVlm']),
+    openInterest: field(item, ['openInterest']),
+    fundingRate: field(item, ['fundingRate', 'funding']),
+    maxLeverage: field(item, ['maxLeverage']),
+  };
+}
+
+function normalizePosition(item) {
+  return {
+    market: marketForItem(item) || null,
+    side: normalizedSide(item),
+    size: field(item, ['size', 'szi']),
+    entryPrice: field(item, ['entryPrice', 'entryPx']),
+    positionValue: field(item, ['positionValue']),
+    leverage: normalizedLeverage(item),
+    liquidationPrice: field(item, ['liquidationPrice', 'liquidationPx']),
+    marginUsed: field(item, ['marginUsed']),
+    unrealizedPnl: field(item, ['unrealizedPnl']),
+    returnOnEquity: field(item, ['returnOnEquity']),
+    takeProfitPrice: field(item, ['takeProfitPrice']),
+    stopLossPrice: field(item, ['stopLossPrice']),
+  };
+}
+
+function normalizeOrder(item) {
+  return {
+    orderId: field(item, ['orderId', 'id', 'oid']),
+    market: marketForItem(item) || null,
+    side: normalizedSide(item),
+    size: field(item, ['size', 'sz', 'szi']),
+    price: field(item, ['price', 'limitPx', 'px']),
+    type: field(item, ['orderType', 'type']),
+    status: field(item, ['status']),
+    timestamp: field(item, ['timestamp', 'time']),
+    reduceOnly: field(item, ['reduceOnly']),
+    isTrigger: field(item, ['isTrigger']),
+    triggerPrice: field(item, ['triggerPrice', 'triggerPx']),
+    triggerOrderType: field(item, ['triggerOrderType']),
+    takeProfitPrice: field(item, ['takeProfitPrice']),
+    stopLossPrice: field(item, ['stopLossPrice']),
+  };
+}
+
+function normalizeHistoryItem(item) {
+  return {
+    type: field(item, ['type', 'activityType']),
+    status: field(item, ['status']),
+    asset: field(item, ['asset', 'token', 'currency']),
+    market: marketForItem(item) || null,
+    amount: field(item, ['amount', 'value']),
+    fee: field(item, ['fee']),
+    timestamp: field(item, ['timestamp', 'time']),
+    transactionHash: field(item, ['transactionHash', 'txHash', 'hash']),
+  };
+}
+
+function selectAndBound(items, options, normalize, limit = options.maxItems, result = {}) {
+  const selected = result.transportBound === true || options.markets.length === 0
+    ? items
+    : items.filter((item) => options.markets.includes(marketForItem(item)));
+  const bounded = selected.slice(0, Math.min(limit, options.maxItems));
+  return {
+    totalCount: result.transportBound === true ? result.totalCount : items.length,
+    matchingCount: result.transportBound === true ? result.matchingCount : selected.length,
+    returnedCount: bounded.length,
+    truncated: result.transportBound === true ? result.truncated === true : bounded.length < selected.length,
+    items: bounded.map(normalize),
+  };
+}
+
+function requireObjectSection(section, result) {
+  if (!result?.ok) {
+    throw new Error(`Requested Perps snapshot section ${section} is unavailable: ${result?.error ?? 'unknown error'}.`);
+  }
+  if (!result.value || typeof result.value !== 'object' || Array.isArray(result.value)) {
+    throw new Error(`Requested Perps snapshot section ${section} is unavailable: ${result.method} returned a non-object result.`);
+  }
+  return result.value;
+}
+
+function requireArraySection(section, result) {
+  if (!result?.ok) {
+    throw new Error(`Requested Perps snapshot section ${section} is unavailable: ${result?.error ?? 'unknown error'}.`);
+  }
+  if (!Array.isArray(result.value)) {
+    throw new Error(`Requested Perps snapshot section ${section} is unavailable: ${result.method} returned a non-array result.`);
+  }
+  return result.value;
+}
+
+export function normalizeSnapshotResult(raw, options) {
+  const sections = {};
+  for (const section of options.include) {
+    const result = raw?.[section];
+    if (section === 'account') {
+      sections.account = {
+        source: result?.method ?? 'perpsGetAccountState',
+        state: normalizeAccount(requireObjectSection(section, result)),
+      };
+      continue;
+    }
+    if (section === 'watchlist') {
+      const values = requireArraySection(section, result);
+      const items = values
+        .map((item) => typeof item === 'string' ? item : marketForItem(item))
+        .filter((item) => typeof item === 'string' && item.length > 0);
+      const selected = result.transportBound === true || options.markets.length === 0
+        ? items
+        : items.filter((item) => options.markets.includes(normalizeMarketSymbol(item)));
+      const bounded = selected
+        .slice(0, options.maxItems)
+        .map((item) => typeof item === 'string' && item.length > 0 ? normalizeMarketSymbol(item) : '')
+        .filter(Boolean);
+      sections.watchlist = {
+        source: result.method,
+        totalCount: result.transportBound === true ? result.totalCount : values.length,
+        matchingCount: result.transportBound === true ? result.matchingCount : selected.length,
+        returnedCount: bounded.length,
+        truncated: result.transportBound === true ? result.truncated === true : bounded.length < selected.length,
+        markets: bounded,
+      };
+      continue;
+    }
+    const values = requireArraySection(section, result);
+    const normalizer = {
+      markets: normalizeMarket,
+      positions: normalizePosition,
+      orders: normalizeOrder,
+      history: normalizeHistoryItem,
+    }[section];
+    sections[section] = {
+      source: result.method,
+      ...selectAndBound(
+        values,
+        options,
+        normalizer,
+        section === 'history' ? options.history.limit : options.maxItems,
+        result,
+      ),
+    };
+  }
+  return sections;
+}
+
+export async function readSnapshot(input) {
+  const options = resolveSnapshotOptions(input);
+  return withExtensionPage(input, async (page) => {
+    const raw = await page.evaluate(snapshotRequestExpression(options));
+    return {
+      action: input.action,
+      source: 'extension-stateHooks-background',
+      include: options.include,
+      markets: options.markets,
+      historyQuery: options.include.includes('history')
+        ? {
+            startTime: options.history.startTime,
+            endTime: options.history.endTime,
+            accountScoped: options.history.accountId !== undefined,
+          }
+        : null,
+      sections: normalizeSnapshotResult(raw, options),
+      redacted: true,
+      proofPath: 'background-perps-snapshot',
+    };
+  });
+}
+
+function isDirectRun() {
+  return process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+}
+
+if (isDirectRun()) {
+  runAdapter(readSnapshot);
+}

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