@deeeed/metamask-harness 0.38.1 → 0.40.0

package/library/actions/extension/assets/set_token_visibility.mjs

@@ -75,6 +75,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   }
   const requested = input.node.visible;
   const requireUnchanged = input.node?.require_unchanged === true;
+  const requireChange = input.node?.require_change === true;
   const timeoutMs = Number(input.node?.timeout_ms ?? 45_000);
 
   if (!(await visible(page, MANAGE))) await page.click(OPTIONS);
@@ -91,6 +92,9 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   if (requireUnchanged && before.enabled !== requested) {
     throw new Error(`${query} token visibility did not persist as ${requested ? 'enabled' : 'disabled'}.`);
   }
+  if (requireChange && before.enabled === requested) {
+    throw new Error(`${query} token visibility was already ${requested ? 'enabled' : 'disabled'}.`);
+  }
   if (before.enabled !== requested) {
     await page.click(dataTestId(before.testId));
   }
@@ -120,6 +124,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     query,
     requested,
     requireUnchanged,
+    requireChange,
     changed: before.enabled !== after.enabled,
     searchResult: after.label,
     toggleTestId: after.testId,

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

@@ -1,5 +1,6 @@
 import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
+  assertNetworkAdditionAllowed,
   findNetworkItem,
   openNetworkManager,
   selectHomeNetwork,
@@ -17,6 +18,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   const query = String(input.node?.query || network).trim();
   const chainId = Number(input.node?.chain_id);
   const symbol = String(input.node?.symbol || '').trim().toUpperCase();
+  const requireAbsent = input.node?.require_absent === true;
   const timeoutMs = Number(input.node?.timeout_ms ?? 60_000);
   if (!network || !query || !Number.isInteger(chainId) || chainId <= 0 || !symbol) {
     throw new Error('metamask.networks.add_chainlist requires network, query, positive chain_id, and symbol.');
@@ -25,6 +27,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   const chainlistOpen = await page.evaluate(`Boolean(document.querySelector(${JSON.stringify(CHAINLIST_SEARCH)}))`);
   if (!chainlistOpen) await openNetworkManager(page, timeoutMs);
   let item = chainlistOpen ? null : await findNetworkItem(page, network, chainId);
+  assertNetworkAdditionAllowed(item, requireAbsent, network, chainId);
   let added = false;
   if (!item) {
     if (!chainlistOpen) {
@@ -87,6 +90,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     chainId,
     symbol,
     query,
+    requireAbsent,
     added,
     item,
     proofPath: 'trusted-pointer-chainlist-ui',

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

@@ -1,5 +1,6 @@
 import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
+  assertNetworkAdditionAllowed,
   findNetworkItem,
   openNetworkManager,
   selectHomeNetwork,
@@ -14,6 +15,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   const chainId = Number(input.node?.chain_id);
   const symbol = String(input.node?.symbol || '').trim();
   const explorerUrl = String(input.node?.explorer_url || '').trim();
+  const requireAbsent = input.node?.require_absent === true;
   const timeoutMs = Number(input.node?.timeout_ms ?? 60_000);
   if (!network || !/^https?:\/\//u.test(rpcUrl) || !Number.isInteger(chainId) || chainId <= 0 || !symbol) {
     throw new Error('metamask.networks.add_custom requires network, rpc_url, positive chain_id, and symbol.');
@@ -21,6 +23,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
 
   await openNetworkManager(page, timeoutMs);
   let item = await findNetworkItem(page, network, chainId);
+  assertNetworkAdditionAllowed(item, requireAbsent, network, chainId);
   let added = false;
   if (!item) {
     await page.click(dataTestId('networks-page-add-custom-network-button'));
@@ -116,6 +119,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     symbol,
     rpcUrl,
     explorerUrl: explorerUrl || null,
+    requireAbsent,
     added,
     item,
     proofPath: 'trusted-pointer-visible-ui',

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

@@ -10,6 +10,46 @@ async function visible(page, selector) {
   })()`);
 }
 
+export async function clickUncovered(page, selector, deadline) {
+  let point;
+  while (!point && Date.now() < deadline) {
+    point = await page.evaluate(`(() => {
+      const element = document.querySelector(${JSON.stringify(selector)});
+      if (!element) return null;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) return null;
+      const offsets = [[0.25, 0.25], [0.25, 0.5], [0.25, 0.75], [0.5, 0.75], [0.75, 0.75]];
+      for (const [xOffset, yOffset] of offsets) {
+        const x = rect.left + (rect.width * xOffset);
+        const y = rect.top + (rect.height * yOffset);
+        const hit = document.elementFromPoint(x, y);
+        if (hit === element || element.contains(hit)) return { x, y };
+      }
+      return null;
+    })()`);
+    if (!point) await page.evaluate('new Promise((resolve) => setTimeout(resolve, 100))');
+  }
+  if (!point) throw new Error(`Network manager control has no uncovered pointer target: ${selector}`);
+  await page.session.call('Input.dispatchMouseEvent', { type: 'mouseMoved', x: point.x, y: point.y });
+  await page.session.call('Input.dispatchMouseEvent', {
+    type: 'mousePressed',
+    x: point.x,
+    y: point.y,
+    button: 'left',
+    buttons: 1,
+    clickCount: 1,
+  });
+  await page.session.call('Input.dispatchMouseEvent', {
+    type: 'mouseReleased',
+    x: point.x,
+    y: point.y,
+    button: 'left',
+    buttons: 0,
+    clickCount: 1,
+  });
+}
+
 export async function waitFor(page, predicate, message, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -48,7 +88,8 @@ export async function semanticButton(page, label) {
 export async function openNetworkManager(page, timeoutMs) {
   const menu = dataTestId('account-options-menu-button');
   const networks = dataTestId('global-menu-networks');
-  await page.click(menu);
+  const deadline = Date.now() + timeoutMs;
+  await clickUncovered(page, menu, deadline);
   await waitFor(page, () => visible(page, networks), 'Networks did not become visible in the account menu.', timeoutMs);
   await page.click(networks);
   await waitFor(
@@ -80,6 +121,12 @@ export async function findNetworkItem(page, network, chainId) {
   })()`);
 }
 
+export function assertNetworkAdditionAllowed(item, requireAbsent, network, chainId) {
+  if (requireAbsent && item) {
+    throw new Error(`${network} (${chainId}) is already configured; refusing to reuse it because cleanup must not remove pre-existing state.`);
+  }
+}
+
 export async function selectHomeNetwork(page, network, chainId, timeoutMs) {
   const sort = dataTestId('sort-by-networks');
   const chainHex = `0x${chainId.toString(16)}`;

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

@@ -0,0 +1,366 @@
+import { pathToFileURL } from 'node:url';
+
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import {
+  openPerpsActivity,
+  openPerpsHome,
+  openPerpsMarketList,
+} from '../ui/navigate.mjs';
+import { selectActivityFilter } from './select_activity_filter.mjs';
+
+const ACTIVITY_FILTERS = ['trades', 'orders', 'funding', 'deposits'];
+const PRICE_SURFACES = new Set(['home', 'market-list', 'market-details', 'order-entry']);
+
+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.assert_visible_consistency ${name} must be an integer from ${minimum} to ${maximum}.`);
+  }
+  return resolved;
+}
+
+export function resolveVisibleConsistencyOptions(input) {
+  const node = input.node ?? {};
+  const mode = String(node.mode ?? '').trim().toLowerCase();
+  if (mode !== 'market-stream' && mode !== 'watchlist-stream' && mode !== 'activity-containment' && mode !== 'price-stream') {
+    throw new Error(`metamask.perps.assert_visible_consistency received unsupported mode ${JSON.stringify(mode)}.`);
+  }
+  const surface = node.surface == null ? undefined : String(node.surface).trim().toLowerCase();
+  if (mode === 'price-stream' && !PRICE_SURFACES.has(surface)) {
+    throw new Error('metamask.perps.assert_visible_consistency price-stream requires a supported surface.');
+  }
+  const market = node.market == null ? undefined : String(node.market).trim().toUpperCase();
+  if (mode === 'price-stream' && (surface === 'home' || surface === 'market-list') && !market) {
+    throw new Error(`metamask.perps.assert_visible_consistency price-stream surface ${surface} requires market.`);
+  }
+  const requireUniqueIds = node.require_unique_ids === true;
+  if (mode === 'price-stream' && requireUniqueIds) {
+    throw new Error('metamask.perps.assert_visible_consistency require_unique_ids is unavailable for price-stream.');
+  }
+  return {
+    mode,
+    surface,
+    market,
+    sampleCount: boundedInteger(node.sample_count, 3, 2, 10, 'sample_count'),
+    sampleIntervalMs: boundedInteger(node.sample_interval_ms, 1_000, 100, 30_000, 'sample_interval_ms'),
+    minimumChangedCount: boundedInteger(node.minimum_changed_count, 1, 0, 200, 'minimum_changed_count'),
+    minimumRecentActivityCount: boundedInteger(
+      node.minimum_recent_activity_count,
+      1,
+      0,
+      50,
+      'minimum_recent_activity_count',
+    ),
+    timeoutMs: boundedInteger(node.timeout_ms, 30_000, 1_000, 120_000, 'timeout_ms'),
+    maxItems: boundedInteger(node.max_items, 100, 1, 200, 'max_items'),
+    requireUniqueIds,
+  };
+}
+
+function assertUniqueIds(entries, boundary) {
+  const ids = entries.map((entry) => typeof entry === 'string' ? entry : entry.testId);
+  const duplicates = [...new Set(ids.filter((id, index) => id && ids.indexOf(id) !== index))];
+  if (duplicates.length > 0) {
+    throw new Error(`Visible Perps ${boundary} contains duplicate identities: ${duplicates.join(', ')}.`);
+  }
+}
+
+async function visiblePrice(page, surface, market) {
+  const rowTestId = surface === 'home'
+    ? `perps-watchlist-${market}`
+    : surface === 'market-list'
+      ? `market-row-${market?.replace(':', '-')}`
+      : undefined;
+  const rootTestId = surface === 'market-details'
+    ? 'perps-market-detail-page'
+    : surface === 'order-entry'
+      ? 'perps-order-entry-page'
+      : rowTestId;
+  const priceTestId = surface === 'market-details'
+    ? 'perps-market-detail-price'
+    : surface === 'order-entry'
+      ? 'perps-order-entry-price'
+      : undefined;
+  return page.evaluate(`(() => {
+    const visible = (element) => {
+      if (!element) return false;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+    };
+    const root = document.querySelector('[data-testid=${JSON.stringify(rootTestId)}]');
+    const price = ${priceTestId
+    ? `document.querySelector('[data-testid=${JSON.stringify(priceTestId)}]')`
+    : 'root?.lastElementChild?.firstElementChild'};
+    const value = String(price?.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 100);
+    const numeric = Number(value.replace(/[^0-9.-]/gu, ''));
+    return {
+      rootVisible: visible(root),
+      priceVisible: visible(price),
+      value,
+      positive: Number.isFinite(numeric) && numeric > 0,
+    };
+  })()`);
+}
+
+async function marketRows(page, maxItems) {
+  return page.evaluate(`[
+    ...document.querySelectorAll('[data-testid^="market-row-"]')
+  ].filter((element) => {
+    const testId = element.getAttribute('data-testid') || '';
+    if (testId.startsWith('market-row-ticker-') || /-(?:token-logo|asset-label)$/u.test(testId)) return false;
+    const style = getComputedStyle(element);
+    const rect = element.getBoundingClientRect();
+    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+  }).slice(0, ${JSON.stringify(maxItems)}).map((element) => ({
+    testId: String(element.getAttribute('data-testid') || '').slice(0, 500),
+    label: String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500),
+  }))`);
+}
+
+async function watchlistRows(page, maxItems) {
+  return page.evaluate(`[
+    ...document.querySelectorAll('[data-testid^="perps-watchlist-"]')
+  ].filter((element) => {
+    const style = getComputedStyle(element);
+    const rect = element.getBoundingClientRect();
+    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+  }).slice(0, ${JSON.stringify(maxItems)}).map((element) => ({
+    testId: String(element.getAttribute('data-testid') || '').slice(0, 500),
+    label: String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500),
+  }))`);
+}
+
+function changedRows(first, last) {
+  const initial = new Map(first.map((entry) => [entry.testId, entry.label]));
+  return last
+    .filter((entry) => initial.has(entry.testId) && initial.get(entry.testId) !== entry.label)
+    .map((entry) => entry.testId);
+}
+
+async function activityIds(page, maxItems) {
+  const selector = '[data-testid^="transaction-card-"]';
+  return page.evaluate(`[
+    ...document.querySelectorAll(${JSON.stringify(selector)})
+  ].filter((element) => {
+    const style = getComputedStyle(element);
+    const rect = element.getBoundingClientRect();
+    return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+  }).slice(0, ${JSON.stringify(maxItems)}).map((element) => String(element.getAttribute('data-testid') || ''))`);
+}
+
+async function recentActivityState(page, maxItems) {
+  return page.evaluate(`(() => {
+    const visible = (element) => {
+      if (!element) return false;
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+    };
+    return {
+      ids: [...document.querySelectorAll('[data-testid^="transaction-card-"]')]
+        .filter(visible)
+        .slice(0, ${JSON.stringify(maxItems)})
+        .map((element) => String(element.getAttribute('data-testid') || '')),
+      emptyVisible: visible(document.querySelector('[data-testid="perps-recent-activity-empty"]')),
+    };
+  })()`);
+}
+
+async function pollLoaded(read, accept, timeoutMs, pause, failure) {
+  const deadline = Date.now() + timeoutMs;
+  let observed;
+  while (true) {
+    observed = await read();
+    if (accept(observed)) return observed;
+    if (Date.now() >= deadline) throw new Error(failure(observed));
+    await pause();
+  }
+}
+
+async function filteredActivityIds(page, options, selectFilter) {
+  const ids = new Set();
+  const counts = {};
+  for (const filter of ACTIVITY_FILTERS) {
+    await selectFilter(page, filter, options.timeoutMs);
+    const filteredIds = await activityIds(page, options.maxItems);
+    if (options.requireUniqueIds) assertUniqueIds(filteredIds, `${filter} activity`);
+    counts[filter] = filteredIds.length;
+    for (const testId of filteredIds) ids.add(testId);
+  }
+  return { ids: [...ids], counts };
+}
+
+async function pollContained(page, recentIds, options, pause, selectFilter) {
+  const deadline = Date.now() + options.timeoutMs;
+  let observed = { ids: [], counts: {} };
+  while (true) {
+    observed = await filteredActivityIds(page, options, selectFilter);
+    if (recentIds.every((testId) => observed.ids.includes(testId))) return observed;
+    if (Date.now() >= deadline) {
+      throw new Error(`Recent Perps activity is not contained across all activity filters: ${JSON.stringify({ recentIds, ...observed })}.`);
+    }
+    await pause(options.sampleIntervalMs);
+  }
+}
+
+export async function assertVisibleConsistency(page, input, testOptions = {}) {
+  const options = resolveVisibleConsistencyOptions(input);
+  const pause = testOptions.pause ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  if (options.mode === 'price-stream') {
+    const first = await pollLoaded(
+      () => visiblePrice(page, options.surface, options.market),
+      (sample) => sample.rootVisible && sample.priceVisible && sample.positive,
+      options.timeoutMs,
+      () => pause(options.sampleIntervalMs),
+      () => `Visible Perps ${options.surface} price did not finish loading before sampling.`,
+    );
+    const samples = [first];
+    for (let index = 1; index < options.sampleCount; index += 1) {
+      await pause(options.sampleIntervalMs);
+      samples.push(await visiblePrice(page, options.surface, options.market));
+    }
+    if (samples.some((sample) => !sample.rootVisible || !sample.priceVisible || !sample.positive)) {
+      throw new Error(`Visible Perps ${options.surface} price became unavailable while sampling.`);
+    }
+    const changedCount = samples.slice(1)
+      .filter((sample, index) => sample.value !== samples[index].value)
+      .length;
+    if (changedCount < options.minimumChangedCount) {
+      throw new Error(`Expected at least ${options.minimumChangedCount} changing visible Perps ${options.surface} price samples, but observed ${changedCount}.`);
+    }
+    return {
+      action: input.action,
+      mode: options.mode,
+      surface: options.surface,
+      market: options.market ?? null,
+      sampleCount: samples.length,
+      changedCount,
+      samples: samples.map((sample) => sample.value),
+      proofPath: 'visible-dom-accessibility',
+    };
+  }
+  if (options.mode === 'market-stream') {
+    const openMarketList = testOptions.openMarketList ?? openPerpsMarketList;
+    await openMarketList(page, options.timeoutMs);
+    const first = await pollLoaded(
+      () => marketRows(page, options.maxItems),
+      (rows) => rows.length > 0,
+      options.timeoutMs,
+      () => pause(options.sampleIntervalMs),
+      () => 'Visible Perps market rows did not finish loading before sampling.',
+    );
+    const samples = [first];
+    for (let index = 1; index < options.sampleCount; index += 1) {
+      await pause(options.sampleIntervalMs);
+      samples.push(await marketRows(page, options.maxItems));
+    }
+    if (options.requireUniqueIds) {
+      samples.forEach((sample, index) => assertUniqueIds(sample, `market sample ${index + 1}`));
+    }
+    const changed = changedRows(samples[0], samples.at(-1));
+    if (changed.length < options.minimumChangedCount) {
+      throw new Error(`Expected at least ${options.minimumChangedCount} changing visible Perps market rows, but observed ${changed.length}.`);
+    }
+    return {
+      action: input.action,
+      mode: options.mode,
+      sampleCount: samples.length,
+      firstCount: samples[0].length,
+      finalCount: samples.at(-1).length,
+      changedCount: changed.length,
+      changedTestIds: changed,
+      uniqueIdsVerified: options.requireUniqueIds,
+      proofPath: 'visible-dom-accessibility',
+    };
+  }
+
+  if (options.mode === 'watchlist-stream') {
+    const openHome = testOptions.openHome ?? openPerpsHome;
+    await openHome(page, options.timeoutMs);
+    const first = await pollLoaded(
+      () => watchlistRows(page, options.maxItems),
+      (rows) => rows.length > 0,
+      options.timeoutMs,
+      () => pause(options.sampleIntervalMs),
+      () => 'Visible Perps watchlist did not finish loading before sampling.',
+    );
+    const samples = [first];
+    for (let index = 1; index < options.sampleCount; index += 1) {
+      await pause(options.sampleIntervalMs);
+      samples.push(await watchlistRows(page, options.maxItems));
+    }
+    if (options.requireUniqueIds) {
+      samples.forEach((sample, index) => assertUniqueIds(sample, `watchlist sample ${index + 1}`));
+    }
+    const changed = changedRows(samples[0], samples.at(-1));
+    if (changed.length < options.minimumChangedCount) {
+      throw new Error(`Expected at least ${options.minimumChangedCount} changing visible Perps watchlist rows, but observed ${changed.length}.`);
+    }
+    const selectedTestId = changed[0];
+    const selectedMarket = selectedTestId.slice('perps-watchlist-'.length).toUpperCase();
+    const visibleSymbol = selectedMarket.replace(/^XYZ:/u, '');
+    await page.click(`[data-testid=${JSON.stringify(selectedTestId)}]`);
+    await pollLoaded(
+      () => page.evaluate(`(() => {
+        const pair = String(document.querySelector('[data-testid="perps-market-detail-pair"]')?.innerText || '')
+          .trim()
+          .toUpperCase();
+        return { pair, route: String(location.hash || '') };
+      })()`),
+      (state) => state.pair.startsWith(`${visibleSymbol}-`) && /\/perps\/market\//u.test(state.route),
+      options.timeoutMs,
+      () => pause(100),
+      () => `Visible Perps watchlist row ${selectedTestId} did not open its matching details.`,
+    );
+    return {
+      action: input.action,
+      mode: options.mode,
+      sampleCount: samples.length,
+      firstCount: samples[0].length,
+      finalCount: samples.at(-1).length,
+      changedCount: changed.length,
+      changedTestIds: changed,
+      selectedMarket,
+      selectedTestId,
+      matchingDetailsVisible: true,
+      uniqueIdsVerified: options.requireUniqueIds,
+      proofPath: 'visible-dom-accessibility',
+    };
+  }
+
+  const openHome = testOptions.openHome ?? openPerpsHome;
+  const openActivity = testOptions.openActivity ?? openPerpsActivity;
+  const selectFilter = testOptions.selectActivityFilter ?? ((currentPage, filter, timeoutMs) => selectActivityFilter(
+    currentPage,
+    { action: 'metamask.perps.select_activity_filter', node: { filter } },
+    { timeoutMs },
+  ));
+  await openHome(page, options.timeoutMs);
+  const recent = await pollLoaded(
+    () => recentActivityState(page, options.maxItems),
+    (state) => state.ids.length >= options.minimumRecentActivityCount &&
+      (state.ids.length > 0 || state.emptyVisible),
+    options.timeoutMs,
+    () => pause(options.sampleIntervalMs),
+    (state) => `Expected loaded recent Perps activity with at least ${options.minimumRecentActivityCount} visible cards, but observed ${state.ids.length}.`,
+  );
+  const recentIds = recent.ids;
+  if (options.requireUniqueIds) assertUniqueIds(recentIds, 'recent activity');
+  await openActivity(page, options.timeoutMs);
+  const full = await pollContained(page, recentIds, options, pause, selectFilter);
+  return {
+    action: input.action,
+    mode: options.mode,
+    recentCount: recentIds.length,
+    fullCount: full.ids.length,
+    filterCounts: full.counts,
+    containedTestIds: recentIds,
+    uniqueIdsVerified: options.requireUniqueIds,
+    proofPath: 'visible-dom-accessibility',
+  };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runAdapter((input) => withExtensionPage(input, (page) => assertVisibleConsistency(page, input)));
+}