@deeeed/metamask-harness 0.35.0 → 0.37.0

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

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

package/library/actions/extension/platform/cdp.mjs

@@ -67,9 +67,12 @@ export function extensionTarget(targets, extensionId = null) {
     if (extensionId && extensionIdFromTarget(target) !== extensionId) return false;
     return Boolean(target.webSocketDebuggerUrl);
   });
-  return candidates.find((target) => String(target.url).includes('/home.html')) ??
-    candidates.find((target) => String(target.url).includes('/sidepanel.html')) ??
-    null;
+  const home = candidates.find((target) => String(target.url).includes('/home.html'));
+  const sidepanel = candidates.find((target) => String(target.url).includes('/sidepanel.html'));
+  if (home && String(home.url).includes('/onboarding/completion') && sidepanel) {
+    return sidepanel;
+  }
+  return home ?? sidepanel ?? null;
 }
 
 

package/library/actions/extension/wallet/import.mjs

@@ -0,0 +1,201 @@
+import { resolveWalletImportCredentials, validateWalletImportOptions, walletImportMethod } from '../../shared/wallet/import-source.mjs';
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { pasteSecretRecoveryPhrase, setSecretInput } from './secret-input.mjs';
+import { readWalletStateExpression } from './state.mjs';
+
+const SELECTORS = {
+  importWallet: '[data-testid="onboarding-import-wallet"]',
+  importWithSrp: '[data-testid="onboarding-import-with-srp-button"]',
+  srp: '[data-testid="srp-input-import__srp-note"]',
+  confirmSrp: '[data-testid="import-srp-confirm"]',
+  password: '[data-testid="create-password-new-input"]',
+  confirmPassword: '[data-testid="create-password-confirm-input"]',
+  passwordTerms: '[data-testid="create-password-terms"]',
+  createPassword: '[data-testid="create-password-submit"]',
+  skipPasskey: '[data-testid="passkey-maybe-later-button"]',
+  metricsCheckbox: '[data-testid="metametrics-checkbox"]',
+  metricsContinue: '[data-testid="metametrics-i-agree"]',
+  complete: '[data-testid="onboarding-complete-done"]',
+};
+
+async function hasSelector(page, selector) {
+  try {
+    return await page.evaluate(`Boolean(document.querySelector(${JSON.stringify(selector)}))`);
+  } catch {
+    return false;
+  }
+}
+
+async function waitForSelector(page, selector, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    if (await hasSelector(page, selector)) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Wallet import timed out waiting for ${selector}.`);
+}
+
+async function waitForSelectorToDisappear(page, selector, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    if (!(await hasSelector(page, selector))) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Wallet import timed out waiting for ${selector} to disappear.`);
+}
+
+async function waitForFirstSelector(page, selectors, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    for (const selector of selectors) {
+      if (await hasSelector(page, selector)) return selector;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error('Wallet import timed out waiting for the next onboarding screen.');
+}
+
+async function waitForEnabled(page, selector, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const enabled = await page.evaluate(`(() => {
+      const element = document.querySelector(${JSON.stringify(selector)});
+      return Boolean(element && !element.disabled && element.getAttribute('aria-disabled') !== 'true');
+    })()`).catch(() => false);
+    if (enabled) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Wallet import timed out waiting for ${selector} to become enabled.`);
+}
+
+async function readState(page) {
+  return page.evaluate(readWalletStateExpression(), { awaitPromise: true });
+}
+
+async function unlockProfile(page, credentials, timeoutMs) {
+  await setSecretInput(page, 'input[type="password"]', credentials.password);
+  await page.click('button[type="submit"]');
+  await waitForSelectorToDisappear(page, 'input[type="password"]', timeoutMs);
+}
+
+async function importThroughUi(page, input, timeoutMs) {
+  const credentials = await resolveWalletImportCredentials(input);
+  const metametricsEnabled = input.node?.metametrics === true || input.node?.metametrics === 'true';
+  const interests = Array.isArray(input.node?.interests) ? input.node.interests : [];
+  if (interests.length > 0) {
+    throw new Error('metamask.wallet.import interests are supported only on Mobile.');
+  }
+  if (!(await hasSelector(page, SELECTORS.srp))) {
+    await page.click(SELECTORS.importWallet);
+    const importChoice = await waitForFirstSelector(
+      page,
+      [SELECTORS.importWithSrp, SELECTORS.srp],
+      timeoutMs,
+    );
+    if (importChoice === SELECTORS.importWithSrp) {
+      await page.click(SELECTORS.importWithSrp);
+    }
+    await waitForSelector(page, SELECTORS.srp, timeoutMs);
+  }
+  await pasteSecretRecoveryPhrase(page, SELECTORS.srp, credentials.mnemonic, timeoutMs);
+  await waitForEnabled(page, SELECTORS.confirmSrp, timeoutMs);
+  await page.click(SELECTORS.confirmSrp);
+  await waitForSelector(page, SELECTORS.password, timeoutMs);
+  await setSecretInput(page, SELECTORS.password, credentials.password);
+  await setSecretInput(page, SELECTORS.confirmPassword, credentials.password);
+  await page.click(SELECTORS.passwordTerms);
+  await waitForEnabled(page, SELECTORS.createPassword, timeoutMs);
+  await page.click(SELECTORS.createPassword);
+
+  await waitForFirstSelector(
+    page,
+    [SELECTORS.skipPasskey, SELECTORS.metricsContinue],
+    timeoutMs,
+  );
+  if (await hasSelector(page, SELECTORS.skipPasskey)) {
+    await page.click(SELECTORS.skipPasskey);
+    await waitForSelector(page, SELECTORS.metricsContinue, timeoutMs);
+  }
+  const metricsChecked = await page.evaluate(`(() => {
+    const checkbox = document.querySelector(${JSON.stringify(SELECTORS.metricsCheckbox)});
+    return checkbox?.checked === true ||
+      checkbox?.getAttribute('data-checked') === 'true' ||
+      checkbox?.getAttribute('aria-checked') === 'true';
+  })()`);
+  if (metricsChecked !== metametricsEnabled) await page.click(SELECTORS.metricsCheckbox);
+  await page.click(SELECTORS.metricsContinue);
+  await waitForSelector(page, SELECTORS.complete, timeoutMs);
+  await page.click(SELECTORS.complete);
+
+  const deadline = Date.now() + timeoutMs;
+  let state = await readState(page);
+  while (
+    Date.now() <= deadline &&
+    (!state.completedOnboarding || !state.selectedAccount?.address)
+  ) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    state = await readState(page);
+  }
+  if (!state.completedOnboarding || !state.selectedAccount?.address) {
+    throw new Error('Extension wallet import did not complete onboarding with a selected account.');
+  }
+  if (state.metametricsOptedIn !== metametricsEnabled) {
+    throw new Error(`Extension MetaMetrics preference was ${String(state.metametricsOptedIn)}, expected ${String(metametricsEnabled)}.`);
+  }
+  const actualAddress = String(state.selectedAccount?.address ?? '').toLowerCase();
+  if (actualAddress !== credentials.expectedAddress) {
+    throw new Error(`Wallet import selected ${actualAddress || 'no address'}, expected ${credentials.expectedAddress}.`);
+  }
+  return { credentials, state, metametricsEnabled };
+}
+
+runAdapter((input) => withExtensionPage(input, async (page) => {
+  validateWalletImportOptions('extension', input.node);
+  const method = walletImportMethod(input);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+  const before = await readState(page);
+  const onboarding = String(before.href ?? '').includes('onboarding');
+
+  if (method === 'ui' && !onboarding) {
+    throw new Error('metamask.wallet.import method=ui requires a fresh Extension onboarding profile.');
+  }
+  if (onboarding) {
+    if (method === 'profile') {
+      throw new Error('metamask.wallet.import method=profile found a fresh Extension onboarding profile.');
+    }
+    const imported = await importThroughUi(page, input, timeoutMs);
+    return {
+      action: input.action,
+      method: 'ui-import',
+      credentialSource: imported.credentials.source,
+      credentialSourceName: imported.credentials.sourceName,
+      selectedAddress: imported.state.selectedAccount.address,
+      completedOnboarding: imported.state.completedOnboarding,
+      metametricsEnabled: imported.metametricsEnabled,
+      interests: [],
+      redacted: true,
+      proofPath: 'extension-visible-onboarding-import',
+    };
+  }
+
+  const credentials = await resolveWalletImportCredentials(input);
+  if (before.passwordInput) await unlockProfile(page, credentials, timeoutMs);
+  const after = await readState(page);
+  if (!after.completedOnboarding || !after.selectedAccount?.address || after.passwordInput) {
+    throw new Error('Extension fixture-backed wallet is not ready after profile verification.');
+  }
+  const actualAddress = String(after.selectedAccount.address).toLowerCase();
+  if (actualAddress !== credentials.expectedAddress) {
+    throw new Error(`Wallet profile selected ${actualAddress}, expected ${credentials.expectedAddress}.`);
+  }
+  return {
+    action: input.action,
+    method: 'profile',
+    credentialSource: credentials.source,
+    credentialSourceName: credentials.sourceName,
+    selectedAddress: after.selectedAccount.address,
+    completedOnboarding: after.completedOnboarding,
+    redacted: true,
+    proofPath: 'extension-fixture-profile',
+  };
+}));