@deeeed/metamask-harness 0.47.4 → 0.48.0

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

@@ -6,19 +6,30 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   if (!/^[A-Z0-9._-]{2,20}$/u.test(symbol)) {
     throw new Error('metamask.assets.open_details requires a valid token symbol.');
   }
-  const selector = await page.evaluate(`(() => {
+  const match = await page.evaluate(`(() => {
     const symbol = ${JSON.stringify(symbol)};
-    for (const [index, row] of [...document.querySelectorAll('[data-testid="multichain-token-list-button"]')].entries()) {
+    const selectors = [];
+    for (const row of document.querySelectorAll('[data-testid="multichain-token-list-button"]')) {
+      const style = getComputedStyle(row);
+      const rect = row.getBoundingClientRect();
+      if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0
+        || rect.bottom <= 0 || rect.right <= 0 || rect.top >= innerHeight || rect.left >= innerWidth) continue;
       const amount = String(row.querySelector('[data-testid="multichain-token-list-item-value"]')?.innerText || '').trim();
       const observed = amount.match(/\\b([A-Za-z][A-Za-z0-9._-]{1,19})$/u)?.[1]?.toUpperCase();
       if (observed !== symbol) continue;
-      row.setAttribute('data-mm-harness-asset-index', String(index));
-      return '[data-mm-harness-asset-index="' + index + '"]';
+      const parts = [];
+      for (let element = row; element; element = element.parentElement) {
+        const index = element.parentElement
+          ? [...element.parentElement.children].indexOf(element) + 1 : 1;
+        parts.unshift(element.localName + ':nth-child(' + index + ')');
+      }
+      selectors.push(parts.join(' > '));
     }
-    return null;
+    return { count: selectors.length, selector: selectors.length === 1 ? selectors[0] : null };
   })()`);
-  if (!selector) throw new Error(`Visible asset ${symbol} was not found.`);
-  await page.click(selector);
+  if (!match.count) throw new Error(`Visible asset ${symbol} was not found.`);
+  if (match.count !== 1) throw new Error(`Visible asset ${symbol} matches ${match.count} rows; selection is ambiguous.\nNext: use a uniquely visible token symbol or narrow the product network filter before retrying.`);
+  await page.click(match.selector);
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
     if (String(await page.evaluate('location.hash')).startsWith('#/asset/')) {

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

@@ -6,17 +6,29 @@ function clean(value) {
   return normalized ? normalized.slice(0, 500) : null;
 }
 
-runAdapter(async (input) => withExtensionPage(input, async (page) => {
-  const expectedSymbol = clean(input.node?.expected_symbol)?.toUpperCase() ?? null;
-  const requireChart = input.node?.require_chart === true;
-  const requireMarketCap = input.node?.require_market_cap === true;
-  const raw = await page.evaluate(`(() => {
+runAdapter(async (input) =>
+  withExtensionPage(input, async (page) => {
+    const expectedSymbol = clean(input.node?.expected_symbol)?.toUpperCase() ?? null;
+    const requireChart = input.node?.require_chart === true;
+    const requireMarketCap = input.node?.require_market_cap === true;
+    const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+    const deadline = Date.now() + timeoutMs;
+    let samples = 0;
+    while (true) {
+      const raw = await page.evaluate(`(() => {
     const text = (selector) => {
       const value = document.querySelector(selector)?.innerText;
       return typeof value === 'string' ? value.replace(/\\s+/gu, ' ').trim().slice(0, 500) : null;
     };
     const body = String(document.body?.innerText || '').replace(/\\s+/gu, ' ').trim();
     const name = text('[data-testid="asset-name"]');
+    const chart = document.querySelector('[data-testid="asset-price-chart"]');
+    const price = document.querySelector('[data-testid="asset-hovered-price"]');
+    const priceText = String(price?.innerText || '').trim();
+    const chartLabels = [...(chart?.querySelectorAll('p') || [])]
+      .filter(element => !element.closest('button, [role="button"]'))
+      .map(element => String(element.innerText || '').trim())
+      .filter(value => /[0-9]/u.test(value));
     return {
       route: String(location.hash),
       name,
@@ -25,33 +37,53 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
       marketCap: text('[data-testid="asset-market-cap"]'),
       chartRendered: Boolean(document.querySelector('[data-testid="asset-price-chart"] canvas')),
       chartEmpty: Boolean(document.querySelector('[data-testid="asset-chart-empty-state"]')),
+      chartHasPriceLabels: chartLabels.length >= 2,
+      priceSettled: Boolean(price && /[0-9]/u.test(priceText) && Number(getComputedStyle(price).opacity) === 1),
       malformed: /(?:\\bNaN\\b|\\bundefined\\b|\\bnull\\b)/u.test(body),
       hasActivity: /\\bYour activity\\b/u.test(body),
     };
   })()`);
+      samples += 1;
 
-  if (!raw.route.startsWith('#/asset/')) {
-    throw new Error(`Expected an asset details route, but observed ${raw.route || 'no route'}.`);
-  }
-  if (expectedSymbol && raw.symbol !== expectedSymbol) {
-    throw new Error(`Expected ${expectedSymbol} asset details, but observed ${raw.symbol || 'no symbol'}.`);
-  }
-  if (requireChart && (!raw.chartRendered || raw.chartEmpty)) {
-    throw new Error('Expected a rendered asset price chart without an empty state.');
-  }
-  if (requireMarketCap && !raw.marketCap) {
-    throw new Error('Expected a formatted asset market cap.');
-  }
-  if (raw.malformed) {
-    throw new Error('Asset details contain a malformed visible value.');
-  }
+      if (!raw.route.startsWith('#/asset/')) {
+        throw new Error(`Expected an asset details route, but observed ${raw.route || 'no route'}.`);
+      }
+      if (expectedSymbol && raw.symbol && raw.symbol !== expectedSymbol) {
+        throw new Error(
+          `Expected ${expectedSymbol} asset details, but observed ${raw.symbol || 'no symbol'}.`,
+        );
+      }
+      if (raw.malformed) {
+        throw new Error('Asset details contain a malformed visible value.');
+      }
 
-  return {
-    action: input.action,
-    source: 'visible-ui',
-    platform: 'extension',
-    surface: 'asset-details',
-    ...raw,
-    proofPath: 'visible-dom-accessibility',
-  };
-}));
+      const pending = [];
+      if (expectedSymbol && !raw.symbol) pending.push('asset symbol');
+      if (
+        requireChart &&
+        (!raw.chartRendered || raw.chartEmpty || !raw.chartHasPriceLabels || !raw.priceSettled)
+      )
+        pending.push('settled chart data and price');
+      if (requireMarketCap && !raw.marketCap) pending.push('formatted market cap');
+      if (pending.length) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+          throw new Error(
+            `Asset details did not show ${pending.join(', ')} within ${timeoutMs}ms. Last state: ${JSON.stringify(raw)}\nNext: inspect the asset page and captured failure; do not refresh to manufacture readiness.`,
+          );
+        await new Promise((resolve) => setTimeout(resolve, Math.min(100, remaining)));
+        continue;
+      }
+
+      return {
+        action: input.action,
+        source: 'visible-ui',
+        platform: 'extension',
+        surface: 'asset-details',
+        ...raw,
+        samples,
+        proofPath: 'visible-dom-accessibility',
+      };
+    }
+  }),
+);

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

@@ -12,7 +12,8 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
       .filter((element) => {
         const style = getComputedStyle(element);
         const rect = element.getBoundingClientRect();
-        return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0;
+        return style.display !== 'none' && style.visibility !== 'hidden' && rect.width > 0 && rect.height > 0
+          && rect.bottom > 0 && rect.right > 0 && rect.top < innerHeight && rect.left < innerWidth;
       })
       .slice(0, maximum)
       .map((element) => {
@@ -38,6 +39,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     return {
       route: location.hash,
       title: document.title,
+      lowValueExpanded: document.querySelector('[data-testid="low-value-assets-toggle"]')?.getAttribute('aria-expanded') ?? null,
       items: rows,
       truncated: document.querySelectorAll('[data-testid="multichain-token-list-button"]').length > rows.length,
     };
@@ -45,6 +47,7 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   return {
     action: input.action,
     ...normalizeVisibleAssetsState(raw, options, 'extension'),
+    lowValueExpanded: raw.lowValueExpanded,
     proofPath: 'visible-dom-accessibility',
   };
 }));

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

@@ -11,16 +11,23 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   await openHome(page, timeoutMs);
   const filter = dataTestId('sort-by-networks');
   const all = dataTestId('home-network-filter-all-default');
+  const deadline = Date.now() + timeoutMs;
+  const remaining = () => Math.max(1, deadline - Date.now());
+  const readLabel = () => page.evaluate(`String(document.querySelector(${JSON.stringify(filter)})?.innerText || '')`);
+  const alreadySelected = /All (?:default )?networks/iu.test(await readLabel());
+  if (await visible(page, all)) {
+    await page.waitFor({ selector: all, expected: 'visible', timeoutMs: remaining() });
+    await page.click(all);
+  } else if (!alreadySelected) {
+    await waitFor(page, () => visible(page, filter), 'Network filter did not become visible.', remaining());
+    await page.click(filter);
+    await page.waitFor({ selector: all, expected: 'visible', timeoutMs: remaining() });
+    await page.click(all);
+  }
   const selected = await waitFor(page, async () => {
-    const label = await page.evaluate(`String(document.querySelector(${JSON.stringify(filter)})?.innerText || '')`);
-    if (/All (?:default )?networks/iu.test(label)) return label;
-    if (await visible(page, all)) {
-      await page.click(all);
-    } else if (await visible(page, filter)) {
-      await page.click(filter);
-    }
-    return null;
-  }, 'All networks did not become selected.', timeoutMs);
+    const label = await readLabel();
+    return /All (?:default )?networks/iu.test(label) && !(await visible(page, all)) ? label : null;
+  }, 'All networks did not become selected with its menu closed.', remaining());
   return {
     action: input.action,
     scope,

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

@@ -1,8 +1,9 @@
 import { dataTestId, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { verifyHomeIdentity } from './home-token-identity.mjs';
 
 const OPTIONS = dataTestId('asset-list-control-bar-action-button');
 const MANAGE = dataTestId('manageTokens__button');
-const PAGE = dataTestId('token-management-page');
+const PAGE = `${dataTestId('parent-selector-token-management-page')}, ${dataTestId('token-management-page')}`;
 const SEARCH = dataTestId('token-management-search-input');
 const BACK = dataTestId('token-management-header-back-button');
 const LOW_VALUE = dataTestId('low-value-assets-toggle');
@@ -27,12 +28,15 @@ async function waitFor(page, predicate, message, timeoutMs) {
   throw new Error(message);
 }
 
-async function matchingToggle(page, query) {
+async function matchingToggle(page, query, assetId) {
   return page.evaluate(`(() => {
     const query = ${JSON.stringify(query.toLowerCase())};
+    const assetId = ${JSON.stringify(assetId)};
     const candidates = [...document.querySelectorAll('[data-testid^="token-management-cell-search-"][data-testid$="-toggle-control"]')];
+    const matches = [];
     for (const element of candidates) {
       const testId = element.getAttribute('data-testid');
+      if (assetId && testId !== 'token-management-cell-search-' + assetId + '-toggle-control') continue;
       const row = document.querySelector('[data-testid="' + testId.slice(0, -'-toggle-control'.length) + '"]');
       const label = String(row?.innerText || element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500);
       const words = label.toLowerCase().split(/[^a-z0-9]+/u).filter(Boolean);
@@ -40,28 +44,48 @@ async function matchingToggle(page, query) {
       const style = getComputedStyle(element);
       const rect = element.getBoundingClientRect();
       if (style.display === 'none' || style.visibility === 'hidden' || rect.width <= 0 || rect.height <= 0) continue;
-      return {
+      matches.push({
         testId,
         label,
         enabled: Boolean(element.querySelector('.toggle-button--on')),
-      };
+        busy: element.getAttribute('aria-busy') === 'true',
+      });
     }
-    return null;
+    if (matches.length > 1) throw new Error('Token management matched ' + matches.length + ' rows; query is ambiguous.\\nNext: mm-harness actions --action metamask.assets.set_token_visibility --json');
+    return matches[0] || null;
   })()`);
 }
 
-async function homeToken(page, query) {
+async function homeToken(page, query, verifyIdentity = false) {
   return page.evaluate(`(() => {
     const query = ${JSON.stringify(query.toLowerCase())};
+    const verifyIdentity = ${JSON.stringify(verifyIdentity)};
+    const matches = [];
     for (const row of document.querySelectorAll('[data-testid="multichain-token-list-button"]')) {
       const name = String(row.querySelector('[data-testid="multichain-token-list-item-token-name"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
       const amount = String(row.querySelector('[data-testid="multichain-token-list-item-value"]')?.innerText || '').replace(/\\s+/gu, ' ').trim();
       const symbol = amount.match(/\\b([A-Za-z][A-Za-z0-9]{1,11})$/u)?.[1] || '';
       if (symbol.toLowerCase() === query || name.toLowerCase().includes(query)) {
-        return { name, symbol: symbol.toUpperCase(), amount };
+        const rect = row.getBoundingClientRect();
+        const style = getComputedStyle(row);
+        if (rect.width <= 0 || rect.height <= 0 || style.display === 'none' || style.visibility === 'hidden') continue;
+        matches.push({ row, name, symbol: symbol.toUpperCase(), amount });
       }
     }
-    return null;
+    if (verifyIdentity && matches.length > 1) throw new Error('Home token query is ambiguous; cannot verify asset identity.');
+    const match = matches[0];
+    if (!match) return null;
+    const { row, ...token } = match;
+    if (verifyIdentity) {
+      row.scrollIntoView({ block: 'center', inline: 'nearest' });
+      const rect = row.getBoundingClientRect();
+      const x = rect.left + rect.width / 2;
+      const y = rect.top + rect.height / 2;
+      const hit = document.elementFromPoint(x, y);
+      if (!hit || !row.contains(hit)) return null;
+      token.point = { x, y };
+    }
+    return token;
   })()`);
 }
 
@@ -77,6 +101,31 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   const requireUnchanged = input.node?.require_unchanged === true;
   const requireChange = input.node?.require_change === true;
   const timeoutMs = Number(input.node?.timeout_ms ?? 45_000);
+  const assetId = String(input.node?.asset_id ?? '').trim().toLowerCase();
+  if (assetId && !/^eip155:[1-9][0-9]{0,19}\/erc20:0x[0-9a-f]{40}$/u.test(assetId)) {
+    throw new Error('asset_id requires an ERC-20 CAIP asset ID.\nNext: mm-harness actions --action metamask.assets.set_token_visibility --json');
+  }
+  if (assetId && !requested && (!requireChange || requireUnchanged)) {
+    throw new Error('Exact token hiding requires require_change=true and require_unchanged=false.\nNext: mm-harness actions --action metamask.assets.set_token_visibility --json');
+  }
+
+  let identity;
+  if (assetId && !requested) {
+    if (await visible(page, LOW_VALUE)) {
+      const expanded = await page.evaluate(`document.querySelector(${JSON.stringify(LOW_VALUE)})?.getAttribute('aria-expanded') === 'true'`);
+      if (!expanded) await page.click(LOW_VALUE);
+    }
+    const token = await waitFor(
+      page,
+      () => homeToken(page, query, true),
+      `${query} must be visible on Home before its exact identity can be hidden.`,
+      timeoutMs,
+    );
+    identity = {
+      ...await verifyHomeIdentity(page, token, assetId, timeoutMs),
+      verifiedAt: 'before-hide',
+    };
+  }
 
   if (!(await visible(page, MANAGE))) await page.click(OPTIONS);
   await waitFor(page, () => visible(page, MANAGE), 'Manage tokens did not become visible.', timeoutMs);
@@ -85,8 +134,11 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   await page.setInput(SEARCH, query);
   const before = await waitFor(
     page,
-    () => matchingToggle(page, query),
-    `Token management returned no visible result for ${query}.`,
+    async () => {
+      const state = await matchingToggle(page, query, assetId);
+      return state && !state.busy ? state : null;
+    },
+    `Token management returned no settled visible result for ${query}.`,
     timeoutMs,
   );
   if (requireUnchanged && before.enabled !== requested) {
@@ -101,8 +153,8 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   const after = await waitFor(
     page,
     async () => {
-      const state = await matchingToggle(page, query);
-      return state?.enabled === requested ? state : null;
+      const state = await matchingToggle(page, query, assetId);
+      return state && !state.busy && state.enabled === requested ? state : null;
     },
     `${query} token visibility did not become ${requested ? 'enabled' : 'disabled'}.`,
     timeoutMs,
@@ -110,14 +162,26 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
   await page.click(BACK);
   await waitFor(page, () => visible(page, OPTIONS), 'Token list did not reopen.', timeoutMs);
 
-  if (requested && (await visible(page, LOW_VALUE))) {
+  if ((requested || assetId) && (await visible(page, LOW_VALUE))) {
     const expanded = await page.evaluate(`document.querySelector(${JSON.stringify(LOW_VALUE)})?.getAttribute('aria-expanded') === 'true'`);
     if (!expanded) await page.click(LOW_VALUE);
   }
-  const token = requested
-    ? await waitFor(page, () => homeToken(page, query), `${query} did not appear in the token list.`, timeoutMs)
-    : await homeToken(page, query);
-  if (!requested && token) throw new Error(`${query} remained visible after disabling it.`);
+  let token = null;
+  if (requested) {
+    token = await waitFor(page, () => homeToken(page, query, Boolean(assetId)), `${query} did not appear in the token list.`, timeoutMs);
+    if (assetId) identity = await verifyHomeIdentity(page, token, assetId, timeoutMs);
+  } else if (assetId) {
+    await waitFor(
+      page,
+      async () => !(await homeToken(page, query)),
+      `${query} remained visible after disabling it.`,
+      timeoutMs,
+    );
+    identity.homeAbsent = true;
+  } else {
+    token = await homeToken(page, query);
+    if (token) throw new Error(`${query} remained visible after disabling it.`);
+  }
 
   return {
     action: input.action,
@@ -126,8 +190,11 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     requireUnchanged,
     requireChange,
     changed: before.enabled !== after.enabled,
+    beforeEnabled: before.enabled,
+    afterEnabled: after.enabled,
     searchResult: after.label,
     toggleTestId: after.testId,
+    ...(identity ? { identity } : {}),
     token,
     proofPath: 'trusted-pointer-visible-ui',
   };

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

@@ -45,9 +45,9 @@ function assertDeclining(rows) {
   }
 }
 
-async function choose(page, selector) {
+async function openMenu(page) {
   const isVisible = async () => page.evaluate(`(() => {
-    const element = document.querySelector(${JSON.stringify(selector)});
+    const element = document.querySelector(${JSON.stringify(ALPHABETICAL)});
     if (!element) return false;
     const style = getComputedStyle(element);
     const rect = element.getBoundingClientRect();
@@ -57,24 +57,71 @@ async function choose(page, selector) {
   const deadline = Date.now() + 5_000;
   while (!(await isVisible())) {
     if (Date.now() >= deadline) throw new Error('Asset sort menu did not become visible.');
-    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 100))');
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+}
+
+async function selectedSort(page) {
+  await openMenu(page);
+  const selected = await page.evaluate(`(() => ${JSON.stringify([ALPHABETICAL, DECLINING])}
+    .filter(selector => document.querySelector(selector)?.classList.contains('selectable-list-item--selected')))()`);
+  if (selected.length !== 1) throw new Error('Asset sort preference is unavailable or ambiguous; no sort will be changed.');
+  return selected[0];
+}
+
+async function choose(page, selector) {
+  const current = await selectedSort(page);
+  await page.click(current === selector ? TOGGLE : selector);
+  await page.waitForExpression(`(() => {
+    const element = document.querySelector(${JSON.stringify(ALPHABETICAL)});
+    if (!element) return true;
+    const rect = element.getBoundingClientRect();
+    const style = getComputedStyle(element);
+    return rect.width === 0 || rect.height === 0 || style.display === 'none' || style.visibility === 'hidden';
+  })()`, { timeoutMs: 5000 });
+}
+
+async function waitForRows(page, assertion) {
+  const deadline = Date.now() + 5000;
+  while (true) {
+    const rows = await readRows(page);
+    try {
+      assertion(rows);
+      return rows;
+    } catch (error) {
+      if (Date.now() >= deadline) throw error;
+    }
+    await new Promise(resolve => setTimeout(resolve, 100));
   }
-  await page.click(selector);
-  await page.evaluate('new Promise((resolve) => setTimeout(resolve, 500))');
 }
 
 runAdapter(async (input) => withExtensionPage(input, async (page) => {
-  if (!String(await page.evaluate('location.hash')).startsWith('#/')) {
+  if (!['#/', '#', ''].includes(String(await page.evaluate('location.hash')))) {
     throw new Error('metamask.assets.verify_sorting requires the wallet home token list.');
   }
 
-  await choose(page, ALPHABETICAL);
-  const alphabetical = await readRows(page);
-  assertAlphabetical(alphabetical);
-
-  await choose(page, DECLINING);
-  const declining = await readRows(page);
-  assertDeclining(declining);
+  const initialSort = await selectedSort(page);
+  let alphabetical;
+  let declining;
+  let proofError;
+  try {
+    await choose(page, ALPHABETICAL);
+    alphabetical = await waitForRows(page, assertAlphabetical);
+    await choose(page, DECLINING);
+    declining = await waitForRows(page, assertDeclining);
+  } catch (error) {
+    proofError = error;
+  }
+  try {
+    await choose(page, initialSort);
+    await openMenu(page);
+    await page.waitForExpression(`document.querySelector(${JSON.stringify(initialSort)})?.classList.contains('selectable-list-item--selected') === true`, { timeoutMs: 5000 });
+    await page.click(TOGGLE);
+  } catch (restoreError) {
+    if (proofError) throw new AggregateError([proofError, restoreError], 'Asset sorting proof and preference restoration both failed.');
+    throw restoreError;
+  }
+  if (proofError) throw proofError;
 
   return {
     action: input.action,
@@ -83,7 +130,8 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     surface: 'token-list',
     alphabetical: alphabetical.map((row) => row.name),
     decliningFiat: declining.map((row) => row.fiat),
-    restoredSort: 'declining-balance',
+    initialSort: initialSort === ALPHABETICAL ? 'alphabetical' : 'declining-balance',
+    restoredSort: initialSort === ALPHABETICAL ? 'alphabetical' : 'declining-balance',
     proofPath: 'trusted-pointer-visible-ui',
   };
 }));

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

@@ -37,17 +37,19 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     await page.setInput(dataTestId('network-form-chain-id'), chainId);
     await page.setInput(dataTestId('network-form-ticker-input'), symbol);
 
-    await page.evaluate('new Promise((resolve) => setTimeout(resolve, 1000))');
-    let addRpc;
-    for (let attempt = 0; attempt < 3 && !addRpc; attempt += 1) {
-      await page.click(dataTestId('test-add-rpc-drop-down'));
-      await page.evaluate('new Promise((resolve) => setTimeout(resolve, 250))');
-      addRpc = await semanticButtonOrNull(page, 'Add RPC URL');
-    }
-    if (!addRpc) throw new Error('Visible button "Add RPC URL" was not found after opening the RPC menu.');
+    await page.click(dataTestId('test-add-rpc-drop-down'));
+    const addRpc = await waitFor(
+      page,
+      () => semanticButtonOrNull(page, 'Add RPC URL'),
+      'Add RPC URL did not become visible after opening the menu.',
+      timeoutMs,
+    );
+    await page.waitFor({ selector: addRpc, expected: 'visible', timeoutMs });
     await page.click(addRpc);
     await page.setInput(dataTestId('rpc-url-input-test'), rpcUrl);
-    await page.click(dataTestId('page-container-footer-next'));
+    const rpcSubmit = `${dataTestId('page-container-footer-next')}:not(:disabled):not([aria-disabled="true"])`;
+    await page.waitFor({ selector: rpcSubmit, expected: 'visible', timeoutMs });
+    await page.click(rpcSubmit);
     await waitFor(
       page,
       () => page.evaluate(`!document.querySelector(${JSON.stringify(dataTestId('rpc-url-input-test'))})`),
@@ -56,14 +58,14 @@ runAdapter(async (input) => withExtensionPage(input, async (page) => {
     );
 
     if (explorerUrl) {
-      await page.evaluate('new Promise((resolve) => setTimeout(resolve, 1000))');
-      let addExplorer;
-      for (let attempt = 0; attempt < 3 && !addExplorer; attempt += 1) {
-        await page.click(dataTestId('test-explorer-drop-down'));
-        await page.evaluate('new Promise((resolve) => setTimeout(resolve, 250))');
-        addExplorer = await semanticButtonOrNull(page, 'Add a block explorer URL');
-      }
-      if (!addExplorer) throw new Error('Visible button "Add a block explorer URL" was not found after opening the explorer menu.');
+      await page.click(dataTestId('test-explorer-drop-down'));
+      const addExplorer = await waitFor(
+        page,
+        () => semanticButtonOrNull(page, 'Add a block explorer URL'),
+        'Add a block explorer URL did not become visible after opening the menu.',
+        timeoutMs,
+      );
+      await page.waitFor({ selector: addExplorer, expected: 'visible', timeoutMs });
       await page.click(addExplorer);
       await page.setInput(dataTestId('explorer-url-input'), explorerUrl);
       await page.click(await semanticButton(page, 'Add URL'));

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

@@ -90,7 +90,7 @@ export async function openNetworkManager(page, timeoutMs) {
   const networks = dataTestId('global-menu-networks');
   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.waitFor({ selector: networks, expected: 'visible', timeoutMs: Math.max(1, deadline - Date.now()) });
   await page.click(networks);
   await waitFor(
     page,
@@ -115,7 +115,9 @@ export async function findNetworkItem(page, network, chainId) {
       const label = String(element.innerText || '').replace(/\\s+/gu, ' ').trim().slice(0, 500);
       const nameMatches = [...element.querySelectorAll('[data-testid]')]
         .some((child) => String(child.getAttribute('data-testid') || '').toLowerCase() === network);
-      if (chainIds.has(suffix) && nameMatches) return { testId, label, suffix };
+      if (!chainIds.has(suffix)) continue;
+      if (!nameMatches) throw new Error('Chain ' + ${JSON.stringify(chainId)} + ' is already configured under a different name.\\nNext: mm-harness call ui.locators --adapter extension --json');
+      return { testId, label, suffix };
     }
     return null;
   })()`);
@@ -128,6 +130,7 @@ export function assertNetworkAdditionAllowed(item, requireAbsent, network, chain
 }
 
 export async function selectHomeNetwork(page, network, chainId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
   const sort = dataTestId('sort-by-networks');
   const chainHex = `0x${chainId.toString(16)}`;
   const choices = [
@@ -135,13 +138,15 @@ export async function selectHomeNetwork(page, network, chainId, timeoutMs) {
     dataTestId(`home-network-filter-custom-${chainHex}`),
     dataTestId(`home-network-filter-additional-${chainHex}`),
   ];
-  await page.click(sort);
+  if (!(await visible(page, dataTestId('home-network-filter-all-default')))) await page.click(sort);
   const choice = await waitFor(page, async () => {
     for (const candidate of choices) {
       if (await visible(page, candidate)) return candidate;
     }
     return null;
   }, `${network} did not appear in the home network filter.`, timeoutMs);
+  await page.scroll({ selector: choice, intoView: true });
+  await page.waitFor({ selector: choice, expected: 'visible', timeoutMs: Math.max(1, deadline - Date.now()) });
   await page.click(choice);
   await waitFor(page, async () => {
     const label = await page.evaluate(`String(document.querySelector(${JSON.stringify(sort)})?.innerText || '')`);

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

@@ -40,6 +40,7 @@ async function capture(page, maximum) {
 runAdapter(async (input) => withExtensionPage(input, async (page) => {
   const options = resolveVisibleNetworkOptions(input.node);
   const before = await capture(page, options.assets.maxItems);
+  normalizeVisibleNetworkState(before, before, options, 'extension');
   if (options.settleMs > 0) await sleep(options.settleMs);
   const after = options.settleMs > 0 ? await capture(page, options.assets.maxItems) : before;
   return {