@deeeed/metamask-harness 0.34.4 → 0.36.0

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

@@ -0,0 +1,234 @@
+import { resolveWalletImportCredentials, validateWalletImportOptions, walletImportMethod } from '../../shared/wallet/import-source.mjs';
+import { runAdapter, withExtensionPage } from '../platform/cdp.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 setSecretInput(page, selector, value) {
+  await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) throw new Error('Wallet import secret input was not found.');
+    element.focus();
+    if (typeof element.select === 'function') element.select();
+  })()`);
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace' });
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace' });
+  await page.session.call('Input.insertText', { text: value });
+  const matches = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return false;
+    element.dispatchEvent(new Event('change', { bubbles: true }));
+    return element.value === ${JSON.stringify(value)};
+  })()`);
+  if (!matches) throw new Error('Wallet import secret input did not retain the supplied value.');
+}
+
+async function pasteSecretInput(page, selector, value) {
+  const pasted = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return false;
+    const clipboardData = new DataTransfer();
+    clipboardData.setData('text', ${JSON.stringify(value)});
+    element.focus();
+    element.dispatchEvent(new ClipboardEvent('paste', {
+      bubbles: true,
+      cancelable: true,
+      clipboardData,
+    }));
+    return true;
+  })()`);
+  if (!pasted) throw new Error('Wallet import Secret Recovery Phrase input was not found.');
+}
+
+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.');
+  }
+  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 pasteSecretInput(page, SELECTORS.srp, credentials.mnemonic);
+  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',
+  };
+}));

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

@@ -0,0 +1,98 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { readWalletStateExpression } from './state.mjs';
+
+const SELECTORS = {
+  accountMenu: '[data-testid="account-options-menu-button"]',
+  lock: '[data-testid="global-menu-lock"]',
+  forgotPassword: '[data-testid="unlock-forgot-password-button"]',
+  resetChoice: '[data-testid="reset-password-modal-button-link"]',
+  confirmReset: '[data-testid="reset-password-modal-button"]',
+};
+
+async function hasSelector(page, selector) {
+  return page.evaluate(`Boolean(document.querySelector(${JSON.stringify(selector)}))`).catch(() => 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 reset timed out waiting for ${selector}.`);
+}
+
+async function clickWhenReady(page, selector, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() <= deadline) {
+    if (await hasSelector(page, selector)) {
+      try {
+        await page.click(selector);
+        return;
+      } catch (error) {
+        const message = String(error?.message ?? error);
+        if (!message.includes('Target is obscured') && !message.includes('Target is not visible')) {
+          throw error;
+        }
+        lastError = error;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw lastError ?? new Error(`Wallet reset timed out waiting for ${selector}.`);
+}
+
+async function readState(page) {
+  return page.evaluate(readWalletStateExpression(), { awaitPromise: true });
+}
+
+function isFreshWallet(state) {
+  return !state.completedOnboarding &&
+    String(state.href ?? '').includes('/onboarding') &&
+    !state.selectedAccount;
+}
+
+async function waitForFreshWallet(page, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let observed;
+  while (Date.now() <= deadline) {
+    observed = await readState(page);
+    if (isFreshWallet(observed)) return observed;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error('Extension wallet reset did not clear onboarding and the selected account.');
+}
+
+runAdapter((input) => withExtensionPage(input, async (page) => {
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+  const before = await readState(page);
+  if (isFreshWallet(before)) {
+    return {
+      action: input.action,
+      alreadyFresh: true,
+      completedOnboarding: false,
+      redacted: true,
+      proofPath: 'extension-visible-wallet-reset',
+    };
+  }
+
+  if (!before.passwordInput) {
+    await page.navigateHash('#/');
+    await waitForSelector(page, SELECTORS.accountMenu, timeoutMs);
+    await clickWhenReady(page, SELECTORS.accountMenu, timeoutMs);
+    await clickWhenReady(page, SELECTORS.lock, timeoutMs);
+    await waitForSelector(page, SELECTORS.forgotPassword, timeoutMs);
+  }
+  await clickWhenReady(page, SELECTORS.forgotPassword, timeoutMs);
+  await clickWhenReady(page, SELECTORS.resetChoice, timeoutMs);
+  await clickWhenReady(page, SELECTORS.confirmReset, timeoutMs);
+  const after = await waitForFreshWallet(page, timeoutMs);
+  return {
+    action: input.action,
+    alreadyFresh: false,
+    completedOnboarding: after.completedOnboarding,
+    redacted: true,
+    proofPath: 'extension-visible-wallet-reset',
+  };
+}));

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

@@ -38,6 +38,7 @@ export function readWalletStateExpression() {
         type: selected.type || null,
       } : null,
       completedOnboarding: Boolean(metamask.completedOnboarding),
+      metametricsOptedIn: typeof metamask.optedIn === 'boolean' ? metamask.optedIn : null,
       selectedNetworkClientId: metamask.selectedNetworkClientId || null,
     };
   })()`;

package/library/actions/mobile/analytics/consent-settings.mjs

@@ -0,0 +1,112 @@
+import { evalAsync, navigate } from '../platform/bridge.mjs';
+
+const SWITCH_IDS = {
+  participate: 'metametrics-switch',
+  marketing: 'data-collection-switch',
+};
+
+function toggleExpression(testId, expected, invoke) {
+  return `(() => {
+    const find = () => {
+      const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      const rootsFor = hook?.getFiberRoots;
+      if (!hook?.renderers || typeof rootsFor !== 'function') return null;
+      const walk = (fiber) => {
+        if (!fiber) return null;
+        if (fiber.memoizedProps?.testID === ${JSON.stringify(testId)}) return fiber;
+        return walk(fiber.child) || walk(fiber.sibling);
+      };
+      for (const [id] of hook.renderers) {
+        for (const root of rootsFor(id) ?? []) {
+          const match = walk(root.current);
+          if (match) return match;
+        }
+      }
+      return null;
+    };
+    const target = find();
+    const props = target?.memoizedProps;
+    if (!props) return { matched: false, found: false, invoked: false };
+    if (Boolean(props.value) === ${JSON.stringify(expected)}) {
+      return { matched: true, found: true, invoked: false };
+    }
+    if (!${JSON.stringify(invoke)}) {
+      return { matched: false, found: true, invoked: false };
+    }
+    if (typeof props.onValueChange !== 'function') {
+      throw new Error('Consent switch has no onValueChange handler: ${testId}');
+    }
+    return Promise.resolve(
+      props.onValueChange(${JSON.stringify(expected)})
+    ).then(() => ({
+      matched: false,
+      found: true,
+      invoked: true
+    }));
+  })()`;
+}
+
+function stateExpression(participate, marketing) {
+  return `(() => {
+    const state = globalThis.store?.getState?.();
+    const analytics = state?.engine?.backgroundState?.AnalyticsController ?? {};
+    const consent = {
+      optedIn: Boolean(analytics.optedIn),
+      dataCollectionForMarketing: Boolean(state?.security?.dataCollectionForMarketing),
+      analyticsId: analytics.analyticsId ? 'set' : null
+    };
+    return {
+      ready:
+        consent.optedIn === ${JSON.stringify(participate)} &&
+        consent.dataCollectionForMarketing === ${JSON.stringify(marketing)} &&
+        (!${JSON.stringify(participate)} || consent.analyticsId === 'set'),
+      consent
+    };
+  })()`;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function setSwitch(input, testId, expected, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let invoked = false;
+  while (Date.now() < deadline) {
+    const result = await evalAsync(
+      input,
+      toggleExpression(testId, expected, !invoked),
+    );
+    invoked ||= Boolean(result?.invoked);
+    if (result?.matched) {
+      return { ...result, changed: invoked };
+    }
+    await delay(100);
+  }
+  throw new Error(`Timed out setting consent switch ${testId} to ${expected}.`);
+}
+
+async function readConsent(input, participate, marketing, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await evalAsync(
+      input,
+      stateExpression(participate, marketing),
+    );
+    if (result?.ready) {
+      return result.consent;
+    }
+    await delay(100);
+  }
+  throw new Error('Timed out reading back Mobile analytics consent.');
+}
+
+export async function setMobileConsent(input, participate, marketing, timeoutMs) {
+  const navigation = await navigate(input, 'SettingsView', {
+    screen: 'SecuritySettings',
+  }, 'SecuritySettings');
+  await setSwitch(input, SWITCH_IDS.participate, participate, timeoutMs);
+  await setSwitch(input, SWITCH_IDS.marketing, marketing, timeoutMs);
+  const consent = await readConsent(input, participate, marketing, timeoutMs);
+  return { consent, navigation };
+}

package/library/actions/mobile/analytics/set_consent.mjs

@@ -1,120 +1,12 @@
-import { evalAsync, navigate, runAdapter } from '../platform/bridge.mjs';
+import { runAdapter } from '../platform/bridge.mjs';
 import { consentParams } from '../../shared/analytics/consent.mjs';
-
-const SWITCH_IDS = {
-  participate: 'metametrics-switch',
-  marketing: 'data-collection-switch',
-};
-
-function toggleExpression(testId, expected, invoke) {
-  return `(() => {
-    const find = () => {
-      const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-      const rootsFor = hook?.getFiberRoots;
-      if (!hook?.renderers || typeof rootsFor !== 'function') return null;
-      const walk = (fiber) => {
-        if (!fiber) return null;
-        if (fiber.memoizedProps?.testID === ${JSON.stringify(testId)}) return fiber;
-        return walk(fiber.child) || walk(fiber.sibling);
-      };
-      for (const [id] of hook.renderers) {
-        for (const root of rootsFor(id) ?? []) {
-          const match = walk(root.current);
-          if (match) return match;
-        }
-      }
-      return null;
-    };
-    const target = find();
-    const props = target?.memoizedProps;
-    if (!props) return { matched: false, found: false, invoked: false };
-    if (Boolean(props.value) === ${JSON.stringify(expected)}) {
-      return { matched: true, found: true, invoked: false };
-    }
-    if (!${JSON.stringify(invoke)}) {
-      return { matched: false, found: true, invoked: false };
-    }
-    if (typeof props.onValueChange !== 'function') {
-      throw new Error('Consent switch has no onValueChange handler: ${testId}');
-    }
-    return Promise.resolve(
-      props.onValueChange(${JSON.stringify(expected)})
-    ).then(() => ({
-      matched: false,
-      found: true,
-      invoked: true
-    }));
-  })()`;
-}
-
-function stateExpression(participate, marketing) {
-  return `(() => {
-    const state = globalThis.store?.getState?.();
-    const analytics = state?.engine?.backgroundState?.AnalyticsController ?? {};
-    const consent = {
-      optedIn: Boolean(analytics.optedIn),
-      dataCollectionForMarketing: Boolean(state?.security?.dataCollectionForMarketing),
-      analyticsId: analytics.analyticsId ? 'set' : null
-    };
-    return {
-      ready:
-        consent.optedIn === ${JSON.stringify(participate)} &&
-        consent.dataCollectionForMarketing === ${JSON.stringify(marketing)} &&
-        (!${JSON.stringify(participate)} || consent.analyticsId === 'set'),
-      consent
-    };
-  })()`;
-}
-
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function setSwitch(input, testId, expected, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  let invoked = false;
-  while (Date.now() < deadline) {
-    const result = await evalAsync(
-      input,
-      toggleExpression(testId, expected, !invoked),
-    );
-    invoked ||= Boolean(result?.invoked);
-    if (result?.matched) {
-      return { ...result, changed: invoked };
-    }
-    await delay(100);
-  }
-  throw new Error(`Timed out setting consent switch ${testId} to ${expected}.`);
-}
-
-async function readConsent(input, participate, marketing, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const result = await evalAsync(
-      input,
-      stateExpression(participate, marketing),
-    );
-    if (result?.ready) {
-      return result.consent;
-    }
-    await delay(100);
-  }
-  throw new Error('Timed out reading back Mobile analytics consent.');
-}
+import { setMobileConsent } from './consent-settings.mjs';
 
 runAdapter(async (input) => {
   const { participate, marketing, timeoutMs } = consentParams(input.node);
 
-  const navigation = await navigate(input, 'SettingsView', {
-    screen: 'SecuritySettings',
-  }, 'SecuritySettings');
-  await setSwitch(input, SWITCH_IDS.participate, participate, timeoutMs);
-  await setSwitch(input, SWITCH_IDS.marketing, marketing, timeoutMs);
-  const consent = await readConsent(
-    input,
-    participate,
-    marketing,
-    timeoutMs,
+  const { consent, navigation } = await setMobileConsent(
+    input, participate, marketing, timeoutMs,
   );
 
   return {

package/library/actions/mobile/platform/bridge.mjs

@@ -454,6 +454,9 @@ export async function bridgeCommand(input, args) {
 function redactBridgeArgs(args) {
   const command = String(args[0] ?? '');
   if (command === 'unlock' && args.length > 1) return [command, '<redacted-password>', ...args.slice(2)];
+  if (command === 'set-input' && isSensitiveInputId(args[1])) {
+    return [command, String(args[1]), '<redacted>'];
+  }
   return args.map((arg) => String(arg));
 }
 
@@ -470,9 +473,14 @@ function redactBridgeOutput(output, args) {
 function sensitiveBridgeArgs(args) {
   const command = String(args[0] ?? '');
   if (command === 'unlock' && args.length > 1) return [args[1]];
+  if (command === 'set-input' && isSensitiveInputId(args[1])) return args.slice(2);
   return [];
 }
 
+function isSensitiveInputId(value) {
+  return /(?:confirm-password|password|phrase|seed|srp)/iu.test(String(value ?? ''));
+}
+
 function parseMaybeJson(value) {
   if (typeof value !== 'string') return value;
   try {