@deeeed/metamask-harness 0.36.0 → 0.38.0

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

@@ -0,0 +1,80 @@
+import { dataTestId, marketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+const ACTIONS = new Map([
+  ['add-exposure', {
+    first: 'perps-modify-cta-button',
+    second: 'perps-modify-menu-add-exposure',
+    expected: 'perps-order-entry-page',
+  }],
+  ['reduce-exposure', {
+    first: 'perps-modify-cta-button',
+    second: 'perps-modify-menu-reduce-exposure',
+    expected: 'perps-close-position-modal',
+  }],
+  ['reverse', {
+    first: 'perps-modify-cta-button',
+    second: 'perps-modify-menu-reverse-position',
+    expected: 'perps-reverse-position-modal',
+  }],
+  ['add-margin', {
+    first: 'perps-margin-card',
+    second: 'perps-margin-menu-add',
+    expected: 'perps-add-margin-modal',
+  }],
+  ['remove-margin', {
+    first: 'perps-margin-card',
+    second: 'perps-margin-menu-remove',
+    expected: 'perps-decrease-margin-modal',
+  }],
+  ['auto-close', {
+    first: 'perps-auto-close-row',
+    expected: 'perps-update-tpsl-modal',
+  }],
+]);
+
+runAdapter(async (input) => withExtensionPage(input, async (page) => {
+  const market = marketSymbol(input);
+  if (!market) throw new Error('metamask.perps.open_position_action requires market=<symbol>.');
+  const positionAction = String(input.node?.position_action ?? '').trim().toLowerCase();
+  const configuration = ACTIONS.get(positionAction);
+  if (!configuration) {
+    throw new Error(`metamask.perps.open_position_action received unsupported position_action ${JSON.stringify(positionAction)}.`);
+  }
+
+  await page.navigateHash(`#/perps/market/${encodeURIComponent(market)}`);
+  await page.waitForSelector(dataTestId('perps-position-size-value'), { timeoutMs: 20_000 });
+  await page.click(dataTestId(configuration.first));
+  if (configuration.second) {
+    await page.waitForSelector(dataTestId(configuration.second), { timeoutMs: 10_000 });
+    await page.click(dataTestId(configuration.second));
+  }
+  await page.waitForSelector(dataTestId(configuration.expected), { timeoutMs: 15_000 });
+
+  const observed = await page.evaluate(`(() => {
+    const controls = [...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) => ({
+        testId: element.getAttribute('data-testid'),
+        label: String(element.getAttribute('aria-label') || element.innerText || '')
+          .replace(/\\s+/gu, ' ')
+          .trim()
+          .slice(0, 500),
+        enabled: !element.disabled && element.getAttribute('aria-disabled') !== 'true',
+      }))
+      .filter((entry) => entry.testId && /perps/u.test(entry.testId))
+      .slice(0, 150);
+    return { route: String(location.hash), controls };
+  })()`);
+  return {
+    action: input.action,
+    market,
+    positionAction,
+    expectedTestId: configuration.expected,
+    ...observed,
+    proofPath: 'trusted-pointer-visible-ui',
+  };
+}));

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

@@ -1,5 +1,6 @@
 import { pathToFileURL } from 'node:url';
 import { dataTestId, marketSymbol, normalizeMarketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { readSnapshot } from './read_snapshot.mjs';
 import { readPerpsRuntimeStateExpression } from './state.mjs';
 
 function sleep(ms) {
@@ -203,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));
@@ -462,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;
@@ -481,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 () => {
@@ -531,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' };
   });
 }
 
@@ -832,6 +1025,7 @@ export async function teardownState(input) {
 }
 
 const DIRECT_ACTIONS = new Map([
+  ['metamask.perps.read_snapshot', readSnapshot],
   ['metamask.perps.read_positions', readPositions],
   ['metamask.perps.read_orders', readOrders],
   ['metamask.perps.close_positions', closePositions],

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