@deeeed/metamask-harness 0.23.1 → 0.25.0

package/library/actions/core/perps/update_position_tpsl.mjs

@@ -1,7 +1,9 @@
 import {
   configuredSymbols,
+  controllerRejection,
   getCoreControllerWithSigner,
   isDirectRun,
+  optionalParam,
   redactOrder,
   requireExplicitSelection,
   runAdapter,
@@ -22,11 +24,6 @@ import {
 // whole position. After submitting we re-read live open orders so the resulting
 // trigger orders — including their partial sizes — are visible as evidence.
 
-function optionalString(node, snake, camel) {
-  const value = node?.[snake] ?? node?.[camel];
-  return value === undefined || value === null ? undefined : String(value);
-}
-
 function numericValuesMatch(actual, expected) {
   const actualNumber = Number(actual);
   const expectedNumber = Number(expected);
@@ -94,12 +91,21 @@ export async function updatePositionTpsl(input) {
   const symbol = symbols[0];
 
   const node = input.node ?? {};
-  const takeProfitPrice = optionalString(node, 'take_profit_price', 'takeProfitPrice');
-  const stopLossPrice = optionalString(node, 'stop_loss_price', 'stopLossPrice');
-  const takeProfitSize = optionalString(node, 'take_profit_size', 'takeProfitSize');
-  const stopLossSize = optionalString(node, 'stop_loss_size', 'stopLossSize');
+  let takeProfitPrice = optionalParam(node, 'take_profit_price', 'takeProfitPrice');
+  let stopLossPrice = optionalParam(node, 'stop_loss_price', 'stopLossPrice');
+  let takeProfitSize = optionalParam(node, 'take_profit_size', 'takeProfitSize');
+  let stopLossSize = optionalParam(node, 'stop_loss_size', 'stopLossSize');
+  const takeProfitOffsetPct = optionalParam(node, 'take_profit_offset_pct', 'takeProfitOffsetPct');
+  const stopLossOffsetPct = optionalParam(node, 'stop_loss_offset_pct', 'stopLossOffsetPct');
+  const takeProfitFraction = optionalParam(node, 'take_profit_fraction', 'takeProfitFraction');
+  const stopLossFraction = optionalParam(node, 'stop_loss_fraction', 'stopLossFraction');
 
-  if (takeProfitPrice === undefined && stopLossPrice === undefined) {
+  if (
+    takeProfitPrice === undefined &&
+    stopLossPrice === undefined &&
+    takeProfitOffsetPct === undefined &&
+    stopLossOffsetPct === undefined
+  ) {
     throw new Error(
       'metamask.perps.update_position_tpsl requires take_profit_price and/or stop_loss_price (omit both only to clear, which is not supported here).',
     );
@@ -120,6 +126,93 @@ export async function updatePositionTpsl(input) {
     );
   }
 
+  // Prices and sizes are resolved from live mid and the actual position, so a
+  // recipe never has to name a number that only holds for one market at one
+  // moment. An absolute value still wins when the caller gives one.
+  // Both derivations below need the market, and each used to fetch it
+  // separately. getMarketDataWithPrices reads every market, so doing it twice in
+  // one adapter is what pushed this past the node timeout.
+  let market;
+  const readMarket = async () => {
+    if (market === undefined) {
+      const markets = await controller.getMarketDataWithPrices({
+        standalone: true,
+      });
+      market =
+        (Array.isArray(markets) ? markets : []).find(
+          (item) => (item?.symbol ?? '').toUpperCase() === symbol.toUpperCase(),
+        ) ?? null;
+    }
+    return market;
+  };
+
+  if (takeProfitOffsetPct !== undefined || stopLossOffsetPct !== undefined) {
+    // PerpsMarketData.price is a formatted string like '$103,245.00'.
+    const mid = Number(
+      String((await readMarket())?.price ?? '').replace(/[$,\s]/gu, ''),
+    );
+    if (!Number.isFinite(mid) || mid <= 0) {
+      throw new Error(
+        `metamask.perps.update_position_tpsl found no usable mid for ${symbol}.`,
+      );
+    }
+    const fromOffset = (raw, name) => {
+      const pct = Number(raw);
+      if (!Number.isFinite(pct)) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl received invalid ${name}: ${raw}.`,
+        );
+      }
+      const price = mid * (1 + pct / 100);
+      if (!Number.isFinite(price) || price <= 0) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl computed a non-positive price from ${name}=${raw}.`,
+        );
+      }
+      return String(price);
+    };
+    if (takeProfitPrice === undefined && takeProfitOffsetPct !== undefined) {
+      takeProfitPrice = fromOffset(takeProfitOffsetPct, 'take_profit_offset_pct');
+    }
+    if (stopLossPrice === undefined && stopLossOffsetPct !== undefined) {
+      stopLossPrice = fromOffset(stopLossOffsetPct, 'stop_loss_offset_pct');
+    }
+  }
+
+  if (takeProfitFraction !== undefined || stopLossFraction !== undefined) {
+    const absolutePositionSize = Math.abs(Number(position.size ?? position.szi ?? 0));
+    // Round to the market's own size precision before submitting. The venue
+    // rounds anyway, and the read-back below matches on size — so an unrounded
+    // fraction asks for a size that can never come back, and the poll spins
+    // until it times out.
+    const szDecimals = Number((await readMarket())?.szDecimals);
+    const fromFraction = (raw, name) => {
+      const fraction = Number(raw);
+      if (!Number.isFinite(fraction) || fraction <= 0 || fraction > 1) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl received invalid ${name}: ${raw} (expected a fraction in (0, 1]).`,
+        );
+      }
+      const exact = absolutePositionSize * fraction;
+      if (!Number.isFinite(szDecimals)) {
+        return String(exact);
+      }
+      const rounded = Number(exact.toFixed(szDecimals));
+      if (rounded <= 0) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl: ${name}=${raw} of a ${absolutePositionSize} position rounds to zero at ${szDecimals} size decimals; use a larger position or a larger fraction.`,
+        );
+      }
+      return String(rounded);
+    };
+    if (takeProfitSize === undefined && takeProfitFraction !== undefined) {
+      takeProfitSize = fromFraction(takeProfitFraction, 'take_profit_fraction');
+    }
+    if (stopLossSize === undefined && stopLossFraction !== undefined) {
+      stopLossSize = fromFraction(stopLossFraction, 'stop_loss_fraction');
+    }
+  }
+
   const params = {
     symbol,
     ...(takeProfitPrice === undefined ? {} : { takeProfitPrice }),
@@ -130,9 +223,11 @@ export async function updatePositionTpsl(input) {
 
   const result = await controller.updatePositionTPSL(params);
   if (!result || result.success !== true) {
-    throw new Error(
-      `core updatePositionTPSL failed for ${symbol}: ${result?.error ?? 'unknown error'}.`,
-    );
+    throw controllerRejection({
+      action: 'core updatePositionTPSL',
+      detail: symbol,
+      code: result?.error ?? 'unknown error',
+    });
   }
 
   const requests = [
@@ -156,12 +251,23 @@ export async function updatePositionTpsl(input) {
     accountAddress,
     input,
     requests,
-    Number(input.node?.timeout_ms ?? 30000),
+    // Poll for only part of the node's budget. Spending all of it means the
+    // runner kills this adapter before the mismatch below can be reported, so a
+    // read-back that never matches surfaces as an opaque timeout instead of
+    // saying which trigger order was missing.
+    Math.min(
+      Number(
+        optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000,
+      ) * 0.6,
+      60000,
+    ),
   );
 
   if (triggerOrders.length !== requests.length) {
     throw new Error(
-      `core updatePositionTPSL for ${symbol} reported success but only ${triggerOrders.length}/${requests.length} requested trigger orders are visible.`,
+      `core updatePositionTPSL for ${symbol} reported success but only ${triggerOrders.length}/${requests.length} requested trigger orders are visible. Requested: ${JSON.stringify(
+        requests,
+      )}.`,
     );
   }
 

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

@@ -0,0 +1,165 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { consentParams } from '../../shared/analytics/consent.mjs';
+
+runAdapter((input) => withExtensionPage(input, async (page) => {
+  const { participate, marketing, timeoutMs } = consentParams(input.node);
+  const bridgeSymbol = 'metamask-harness-consent-bridge';
+
+  async function readConsentState() {
+    return page.evaluate(`(async () => {
+      const getState = globalThis.stateHooks?.getCleanAppState;
+      if (typeof getState !== 'function') throw new Error('stateHooks.getCleanAppState is unavailable.');
+      const metamask = (await getState())?.metamask ?? {};
+      return {
+        optedIn: Boolean(metamask.optedIn),
+        dataCollectionForMarketing: Boolean(metamask.dataCollectionForMarketing),
+        analyticsId: metamask.analyticsId ? 'set' : null
+      };
+    })()`, { awaitPromise: true });
+  }
+
+  async function waitForConsentState(expected) {
+    const deadline = Date.now() + timeoutMs;
+    let state;
+    do {
+      state = await readConsentState();
+      if (Object.entries(expected).every(([key, value]) => state[key] === value)) {
+        return state;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } while (Date.now() < deadline);
+    throw new Error(`Consent state did not settle to ${JSON.stringify(expected)}; got ${JSON.stringify(state)}.`);
+  }
+
+  const hasDebugBridge = await page.evaluate(
+    `typeof globalThis.stateHooks?.submitRequestToBackground === 'function'`,
+  );
+  let preloadIdentifier;
+  if (!hasDebugBridge) {
+    const preload = await page.session.call('Page.addScriptToEvaluateOnNewDocument', {
+      source: `Object.defineProperty(
+        globalThis,
+        Symbol.for(${JSON.stringify(bridgeSymbol)}),
+        { value: globalThis.chrome, configurable: true }
+      );`,
+    });
+    preloadIdentifier = preload?.identifier;
+    try {
+      let notifyLoaded;
+      const loaded = new Promise((resolve) => {
+        notifyLoaded = resolve;
+      });
+      const unsubscribe = page.session.on('Page.loadEventFired', () => notifyLoaded?.());
+      let reloadTimeout;
+      try {
+        await page.session.call('Page.reload', { ignoreCache: false });
+        await Promise.race([
+          loaded,
+          new Promise((_, reject) => {
+            reloadTimeout = setTimeout(
+              () => reject(new Error(`Extension consent reload timed out after ${timeoutMs}ms.`)),
+              timeoutMs,
+            );
+          }),
+        ]);
+      } finally {
+        clearTimeout(reloadTimeout);
+        unsubscribe();
+      }
+      await page.waitForExpression(
+        `typeof globalThis[Symbol.for(${JSON.stringify(bridgeSymbol)})]?.runtime?.connect === 'function'`,
+        { timeoutMs },
+      );
+    } finally {
+      if (preloadIdentifier) {
+        await page.session.call('Page.removeScriptToEvaluateOnNewDocument', {
+          identifier: preloadIdentifier,
+        });
+      }
+    }
+  }
+
+  const controllerResult = await page.evaluate(`(async () => {
+    const submit = globalThis.stateHooks?.submitRequestToBackground;
+    const bridgeKey = Symbol.for(${JSON.stringify(bridgeSymbol)});
+    const capturedChrome = globalThis[bridgeKey];
+    let port;
+    let nextId = Date.now();
+
+    const rawSubmit = (method, params) => new Promise((resolve, reject) => {
+      if (!port) {
+        const connectionName = location.pathname.includes('sidepanel')
+          ? 'sidepanel'
+          : location.pathname.includes('popup')
+            ? 'popup'
+            : 'fullscreen';
+        port = capturedChrome.runtime.connect({ name: connectionName });
+      }
+      const id = nextId++;
+      const timer = setTimeout(
+        () => reject(new Error(method + ' timed out after ${timeoutMs}ms')),
+        ${timeoutMs},
+      );
+      const listener = (message) => {
+        const data = message?.name === 'controller' ? message.data : null;
+        if (data?.id !== id) return;
+        clearTimeout(timer);
+        port.onMessage.removeListener(listener);
+        if (data.error) reject(new Error(JSON.stringify(data.error)));
+        else resolve(data.result);
+      };
+      port.onMessage.addListener(listener);
+      port.postMessage({
+        name: 'controller',
+        data: { jsonrpc: '2.0', id, method, params }
+      });
+    });
+
+    const callController = typeof submit === 'function' ? submit : rawSubmit;
+    if (typeof callController !== 'function') {
+      throw new Error('Extension consent setup could not reach the background controller.');
+    }
+
+    const setMarketing = async (value) => {
+      await callController('setDataCollectionForMarketing', [value]);
+    };
+
+    try {
+      if (!${JSON.stringify(participate)}) await setMarketing(false);
+      const analyticsId = await callController(
+        'setParticipateInMetaMetrics',
+        [${JSON.stringify(participate)}],
+      );
+      if (${JSON.stringify(participate)}) {
+        await setMarketing(${JSON.stringify(marketing)});
+      }
+      return { analyticsId: analyticsId ? 'set' : null };
+    } finally {
+      port?.disconnect();
+      if (capturedChrome) delete globalThis[bridgeKey];
+    }
+  })()`, { awaitPromise: true });
+
+  const state = await waitForConsentState({
+    optedIn: participate,
+    dataCollectionForMarketing: marketing,
+  });
+
+  if (state.optedIn !== participate) {
+    throw new Error(`Expected optedIn=${participate}, got ${state.optedIn}.`);
+  }
+  if (state.dataCollectionForMarketing !== marketing) {
+    throw new Error(`Expected dataCollectionForMarketing=${marketing}, got ${state.dataCollectionForMarketing}.`);
+  }
+  if (participate && controllerResult.analyticsId !== 'set') {
+    throw new Error('MetaMetrics consent was enabled but the controller did not return an analyticsId.');
+  }
+  return {
+    action: input.action,
+    consent: {
+      ...state,
+      analyticsId: controllerResult.analyticsId,
+    },
+    proofPath: 'extension-background-controller',
+  };
+}));

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

@@ -1,4 +1,17 @@
-import { constants, access, cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import {
+  constants,
+  access,
+  chmod,
+  cp,
+  lstat,
+  mkdir,
+  mkdtemp,
+  open,
+  readFile,
+  rename,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
 import { closeSync, openSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
@@ -74,6 +87,75 @@ function resolveRelativeArtifactPath(artifactsDir, relPath) {
   return { relative: normalized, absolute };
 }
 
+async function preparePrivateArtifactStage(artifactsDir, relPath) {
+  const destination = resolveRelativeArtifactPath(artifactsDir, relPath);
+  const artifactsRoot = path.resolve(artifactsDir);
+  await mkdir(artifactsRoot, { recursive: true });
+  await ensureArtifactParent(artifactsRoot, path.dirname(destination.absolute));
+  await refuseUnsafeDestination(destination.absolute);
+  const stagingDir = await mkdtemp(path.join(artifactsRoot, '.extension-evidence-'));
+  await chmod(stagingDir, 0o700);
+  return {
+    ...destination,
+    stagingDir,
+    staged: path.join(stagingDir, 'artifact'),
+  };
+}
+
+async function ensureArtifactParent(artifactsRoot, parent) {
+  const relative = path.relative(artifactsRoot, parent);
+  let current = artifactsRoot;
+  for (const segment of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    try {
+      const info = await lstat(current);
+      if (info.isSymbolicLink() || !info.isDirectory()) {
+        throw new Error(`Refusing Extension evidence parent that is not a real directory: ${current}`);
+      }
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+      await mkdir(current, { mode: 0o700 });
+    }
+  }
+}
+
+async function refuseUnsafeDestination(destination) {
+  try {
+    const info = await lstat(destination);
+    if (info.isSymbolicLink()) {
+      throw new Error(`Refusing Extension evidence destination symlink: ${destination}`);
+    }
+    if (!info.isFile()) {
+      throw new Error(`Refusing Extension evidence destination that is not a regular file: ${destination}`);
+    }
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+}
+
+async function publishPrivateArtifact(stage) {
+  const handle = await open(
+    stage.staged,
+    constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0),
+  );
+  try {
+    const info = await handle.stat();
+    if (!info.isFile()) {
+      throw new Error(`Captured Extension evidence is not a safe regular file: ${stage.staged}`);
+    }
+    await handle.chmod(0o600);
+    await refuseUnsafeDestination(stage.absolute);
+    await rename(stage.staged, stage.absolute);
+  } finally {
+    await handle.close();
+  }
+  await rm(stage.stagingDir, { recursive: true, force: true });
+}
+
+async function cleanupPrivateArtifactStage(stage) {
+  await rm(stage.stagingDir, { recursive: true, force: true });
+}
+
 function captureHelperPath() {
   return process.env.CAPTURE_HELPER_PATH || 'capture-helper';
 }
@@ -121,8 +203,7 @@ async function captureHelperBrowserPid(context, port) {
 }
 
 async function captureCdpViewportSnapshot(page, context, relPath, metadata, captureHelperError = null) {
-  const { relative, absolute } = resolveRelativeArtifactPath(context.artifactsDir, relPath);
-  await mkdir(path.dirname(absolute), { recursive: true });
+  const stage = await preparePrivateArtifactStage(context.artifactsDir, relPath);
   try {
     const timeoutMs = Number(metadata?.cdpTimeoutMs ?? 5000);
     const result = await Promise.race([
@@ -136,9 +217,13 @@ async function captureCdpViewportSnapshot(page, context, relPath, metadata, capt
     if (typeof result?.data !== 'string' || result.data.length === 0) {
       throw new Error('Chrome Page.captureScreenshot returned no image data.');
     }
-    await writeFile(absolute, Buffer.from(result.data, 'base64'));
+    await writeFile(stage.staged, Buffer.from(result.data, 'base64'), {
+      flag: 'wx',
+      mode: 0o600,
+    });
+    await publishPrivateArtifact(stage);
     return {
-      path: relative,
+      path: stage.relative,
       type: 'screenshot',
       nodeId: context.nodeId,
       label: metadata?.label ?? `${context.nodeId} screenshot`,
@@ -151,13 +236,13 @@ async function captureCdpViewportSnapshot(page, context, relPath, metadata, capt
       },
     };
   } catch (error) {
+    await cleanupPrivateArtifactStage(stage);
     const cdpError = error instanceof Error ? error.message : String(error);
     return captureDomRasterSnapshot(page, context, relPath, metadata, captureHelperError, cdpError);
   }
 }
 
 async function captureDomRasterSnapshot(page, context, relPath, metadata, captureHelperError, cdpError) {
-  const { relative, absolute } = resolveRelativeArtifactPath(context.artifactsDir, relPath);
   const dataUrl = await page.evaluate(`(async () => {
     const width = Math.max(1, window.innerWidth);
     const height = Math.max(1, window.innerHeight);
@@ -200,9 +285,20 @@ async function captureDomRasterSnapshot(page, context, relPath, metadata, captur
   if (typeof dataUrl !== 'string' || !dataUrl.startsWith('data:image/png;base64,')) {
     throw new Error(`Extension screenshot fallbacks failed: capture-helper=${captureHelperError ?? 'not attempted'}; cdp=${cdpError}; DOM raster returned no PNG.`);
   }
-  await writeFile(absolute, Buffer.from(dataUrl.slice('data:image/png;base64,'.length), 'base64'));
+  const stage = await preparePrivateArtifactStage(context.artifactsDir, relPath);
+  try {
+    await writeFile(
+      stage.staged,
+      Buffer.from(dataUrl.slice('data:image/png;base64,'.length), 'base64'),
+      { flag: 'wx', mode: 0o600 },
+    );
+    await publishPrivateArtifact(stage);
+  } catch (error) {
+    await cleanupPrivateArtifactStage(stage);
+    throw error;
+  }
   return {
-    path: relative,
+    path: stage.relative,
     type: 'screenshot',
     nodeId: context.nodeId,
     label: metadata?.label ?? `${context.nodeId} screenshot`,
@@ -222,16 +318,16 @@ export async function captureHelperSnapshot(page, context, relPath, metadata) {
   if (process.platform !== 'darwin') {
     return captureCdpViewportSnapshot(page, context, relPath, metadata);
   }
-  const { relative, absolute } = resolveRelativeArtifactPath(context.artifactsDir, relPath);
-  await mkdir(path.dirname(absolute), { recursive: true });
+  const stage = await preparePrivateArtifactStage(context.artifactsDir, relPath);
 
   try {
     const pid = await captureHelperBrowserPid(context, page.port);
     const timeoutMs = Number(metadata?.timeoutMs ?? 30000);
-    const sessionSnapshot = await captureActiveRecipeRecordingSnapshot(pid, absolute, timeoutMs);
+    const sessionSnapshot = await captureActiveRecipeRecordingSnapshot(pid, stage.staged, timeoutMs);
     if (sessionSnapshot) {
+      await publishPrivateArtifact(stage);
       return {
-        path: relative,
+        path: stage.relative,
         type: 'screenshot',
         nodeId: context.nodeId,
         label: metadata?.label ?? `${context.nodeId} screenshot`,
@@ -246,7 +342,7 @@ export async function captureHelperSnapshot(page, context, relPath, metadata) {
       };
     }
 
-    const result = await runProcess(captureHelperPath(), ['snapshot', '--pid', String(pid), '--output', absolute], {
+    const result = await runProcess(captureHelperPath(), ['snapshot', '--pid', String(pid), '--output', stage.staged], {
       cwd: context.projectRoot,
       env: process.env,
       timeoutMs,
@@ -255,8 +351,9 @@ export async function captureHelperSnapshot(page, context, relPath, metadata) {
       throw new Error(`capture-helper snapshot failed for pid ${pid}: ${result.stderr || result.stdout}`);
     }
     const details = parseJsonObject(result.stdout);
+    await publishPrivateArtifact(stage);
     return {
-      path: relative,
+      path: stage.relative,
       type: 'screenshot',
       nodeId: context.nodeId,
       label: metadata?.label ?? `${context.nodeId} screenshot`,
@@ -270,6 +367,7 @@ export async function captureHelperSnapshot(page, context, relPath, metadata) {
       },
     };
   } catch (error) {
+    await cleanupPrivateArtifactStage(stage);
     const message = error instanceof Error ? error.message : String(error);
     return captureCdpViewportSnapshot(page, context, relPath, metadata, message);
   }

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

@@ -0,0 +1,90 @@
+import { evalAsync, navigate, 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, timeoutMs) {
+  return `(async () => {
+    const deadline = Date.now() + ${JSON.stringify(timeoutMs)};
+    let invoked = false;
+    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    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;
+    };
+    while (Date.now() < deadline) {
+      const target = find();
+      const props = target?.memoizedProps;
+      if (props && Boolean(props.value) === ${JSON.stringify(expected)}) {
+        return { ok: true, testId: ${JSON.stringify(testId)}, changed: invoked };
+      }
+      if (props && !invoked) {
+        if (typeof props.onValueChange !== 'function') {
+          throw new Error('Consent switch has no onValueChange handler: ${testId}');
+        }
+        invoked = true;
+        await props.onValueChange(${JSON.stringify(expected)});
+      }
+      await delay(100);
+    }
+    throw new Error('Timed out setting consent switch ${testId} to ${expected}.');
+  })()`;
+}
+
+function stateExpression(participate, marketing, timeoutMs) {
+  return `(async () => {
+    const deadline = Date.now() + ${JSON.stringify(timeoutMs)};
+    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    while (Date.now() < deadline) {
+      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
+      };
+      if (
+        consent.optedIn === ${JSON.stringify(participate)} &&
+        consent.dataCollectionForMarketing === ${JSON.stringify(marketing)} &&
+        (!${JSON.stringify(participate)} || consent.analyticsId === 'set')
+      ) return consent;
+      await delay(100);
+    }
+    throw new Error('Timed out reading back Mobile analytics consent.');
+  })()`;
+}
+
+runAdapter(async (input) => {
+  const { participate, marketing, timeoutMs } = consentParams(input.node);
+
+  const navigation = await navigate(input, 'SecuritySettings');
+  await evalAsync(input, toggleExpression(SWITCH_IDS.participate, participate, timeoutMs));
+  await evalAsync(input, toggleExpression(SWITCH_IDS.marketing, marketing, timeoutMs));
+  const consent = await evalAsync(
+    input,
+    stateExpression(participate, marketing, timeoutMs),
+  );
+
+  return {
+    action: input.action,
+    consent,
+    navigation,
+    proofPath: 'mobile-settings-consent',
+  };
+});

package/library/actions/shared/analytics/_adapter.mjs

@@ -0,0 +1,24 @@
+// Minimal adapter IO for the shared analytics actions.
+//
+// Mirrors the live-adapter contract in src/live-adapter-contract.ts. Neither
+// existing runAdapter fits: extension's lives under actions/extension/platform
+// and core's carries PerpsController teardown and expect_error handling. A
+// `shared/` action importing either would couple every platform to one of them,
+// so this is a deliberate 20-line duplicate of the contract itself.
+
+import { readFile, writeFile } from 'node:fs/promises';
+
+export async function runAdapter(callback) {
+  const inputPath = process.argv[2] || process.env.METAMASK_RECIPE_ADAPTER_INPUT;
+  if (!inputPath) throw new Error('Missing live adapter input path.');
+  const input = JSON.parse(await readFile(inputPath, 'utf8'));
+  try {
+    const output = await callback(input);
+    await writeFile(input.outputPath, `${JSON.stringify(output, null, 2)}\n`);
+  } catch (error) {
+    // No output file on failure — that is how the runner distinguishes a failed
+    // assertion from a passing one.
+    process.exitCode = 1;
+    process.stderr.write(`[shared/analytics] ${input.action} failed: ${error?.stack ?? error?.message ?? String(error)}\n`);
+  }
+}