@deeeed/metamask-harness 0.37.0 → 0.38.0

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

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