@deeeed/metamask-harness 0.34.1 → 0.34.2

package/library/actions/mobile/perps/perps.mjs

@@ -1,11 +1,92 @@
 import { pathToFileURL } from 'node:url';
-import { evalAsync, navigate, runAdapter } from '../platform/bridge.mjs';
+import {
+  bridgeCommand,
+  evalAsync,
+  navigate,
+  runAdapter,
+} from '../platform/bridge.mjs';
 import { ensureUnlocked } from '../wallet/ensure_unlocked.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+export async function measureHomepageVisible(input) {
+  const wallet = await ensureUnlocked({
+    ...input,
+    action: 'metamask.wallet.ensure_unlocked',
+  });
+  const timeoutMs = Math.max(1, Number(input.node?.timeout_ms ?? 30_000));
+  const targetTestId = input.node?.target_test_id;
+  const targetText = input.node?.target_text;
+  if (Number(Boolean(targetTestId)) + Number(Boolean(targetText)) !== 1) {
+    throw new Error(
+      'metamask.perps.measure_homepage_visible requires exactly one target_test_id or target_text.',
+    );
+  }
+
+  const options = {
+    animated: input.node?.animated === true,
+    fromTestId: input.node?.from_test_id ?? 'wallet-screen',
+    offset: Number(input.node?.offset ?? 600),
+    pollIntervalMs: Number(input.node?.poll_interval_ms ?? 100),
+    requireWalletReady: true,
+    timeoutMs,
+    scrollTestId: input.node?.scroll_test_id ?? 'wallet-screen',
+    ...(targetTestId ? { targetTestId } : { targetText }),
+    ...(input.node?.required_present_test_id
+      ? { requiredPresentTestId: input.node.required_present_test_id }
+      : {}),
+    ...(input.node?.visible_event_stage
+      ? { visibleEventStage: input.node.visible_event_stage }
+      : {}),
+    ...(input.node?.visible_event_grace_ms !== undefined
+      ? { visibleEventGraceMs: Number(input.node.visible_event_grace_ms) }
+      : {}),
+  };
+  const measurement = await bridgeCommand(
+    {
+      ...input,
+      node: {
+        ...input.node,
+        bridge_timeout_ms: timeoutMs + 15_000,
+        cdp_timeout_ms: timeoutMs + 15_000,
+      },
+    },
+    ['measure-scroll-transition', JSON.stringify(options)],
+  );
+  if (measurement?.ok !== true) {
+    throw new Error(
+      `metamask.perps.measure_homepage_visible failed: ${String(measurement?.error ?? 'unknown measurement error')}; measurement=${JSON.stringify(measurement)}.`,
+    );
+  }
+  return {
+    action: input.action,
+    wallet,
+    measurement,
+    proofPath: 'direct-cdp-wallet-ready-to-visible',
+  };
+}
+
+export async function retryPerpsClientRead(
+  read,
+  { timeoutMs = 20000, intervalMs = 500, sleep: wait = sleep } = {},
+) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      return await read();
+    } catch (error) {
+      if (!/CLIENT_NOT_INITIALIZED/u.test(String(error?.message ?? error))) {
+        throw error;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) throw error;
+      await wait(Math.min(intervalMs, remainingMs));
+    }
+  }
+}
+
 function marketSymbol(input) {
   return normalizeMarketSymbol(input.node?.market ?? input.node?.symbol ?? 'BTC');
 }
@@ -104,54 +185,155 @@ function uniqueSymbols(symbols) {
 }
 
 async function readPositions(input) {
-  const positions = await evalAsync(
-    input,
-    `(function(){
-      var controller = Engine && Engine.context && Engine.context.PerpsController;
-      if (!controller || typeof controller.getPositions !== 'function') {
-        throw new Error('Engine.context.PerpsController.getPositions is unavailable; cannot assert live Perps positions.');
+  return retryPerpsClientRead(
+    async () => {
+      const positions = await evalAsync(
+        input,
+        `(function(){
+          var controller = Engine && Engine.context && Engine.context.PerpsController;
+          if (!controller || typeof controller.getPositions !== 'function') {
+            throw new Error('Engine.context.PerpsController.getPositions is unavailable; cannot assert live Perps positions.');
+          }
+          return controller.getPositions().then(function(r){
+            if (!Array.isArray(r)) throw new Error('PerpsController.getPositions returned a non-array result.');
+            return JSON.stringify(r);
+          });
+        })()`,
+      );
+      if (!Array.isArray(positions)) {
+        throw new Error(
+          'PerpsController.getPositions returned a non-array result.',
+        );
       }
-      return controller.getPositions().then(function(r){
-        if (!Array.isArray(r)) throw new Error('PerpsController.getPositions returned a non-array result.');
-        return JSON.stringify(r);
-      });
-    })()`,
+      return positions;
+    },
   );
-  if (!Array.isArray(positions)) throw new Error('PerpsController.getPositions returned a non-array result.');
-  return positions;
 }
 
 async function readOpenOrders(input) {
-  const orders = await evalAsync(
-    input,
-    `(function(){
-      var controller = Engine && Engine.context && Engine.context.PerpsController;
-      if (!controller || typeof controller.getOpenOrders !== 'function') {
-        throw new Error('Engine.context.PerpsController.getOpenOrders is unavailable; cannot assert live Perps orders.');
+  return retryPerpsClientRead(
+    async () => {
+      const orders = await evalAsync(
+        input,
+        `(function(){
+          var controller = Engine && Engine.context && Engine.context.PerpsController;
+          if (!controller || typeof controller.getOpenOrders !== 'function') {
+            throw new Error('Engine.context.PerpsController.getOpenOrders is unavailable; cannot assert live Perps orders.');
+          }
+          return controller.getOpenOrders().then(function(r){
+            if (!Array.isArray(r)) throw new Error('PerpsController.getOpenOrders returned a non-array result.');
+            return JSON.stringify(r);
+          });
+        })()`,
+      );
+      if (!Array.isArray(orders)) {
+        throw new Error(
+          'PerpsController.getOpenOrders returned a non-array result.',
+        );
       }
-      return controller.getOpenOrders().then(function(r){
-        if (!Array.isArray(r)) throw new Error('PerpsController.getOpenOrders returned a non-array result.');
-        return JSON.stringify(r);
-      });
-    })()`,
+      return orders;
+    },
   );
-  if (!Array.isArray(orders)) throw new Error('PerpsController.getOpenOrders returned a non-array result.');
-  return orders;
 }
 
-async function clearPerformanceCaches(input) {
-  return evalAsync(
-    input,
-    `(function(){
-      var bridge = globalThis.__AGENTIC__;
-      if (!bridge || typeof bridge.clearPerpsPerformanceCaches !== 'function') {
-        throw new Error('__AGENTIC__.clearPerpsPerformanceCaches is unavailable; reload the current Mobile development source.');
+export function clearPerformanceCachesExpression() {
+  return `(function(){
+      var metroRequire = globalThis.__r;
+      if (typeof metroRequire !== 'function' || typeof metroRequire.getModules !== 'function') {
+        throw new Error('Metro module registry is unavailable; cannot clear Perps performance caches through CDP.');
       }
-      return Promise.resolve(bridge.clearPerpsPerformanceCaches()).then(function(result){
-        return JSON.stringify(result);
+      var storageModuleId = null;
+      var perpsConfigModuleId = null;
+      var streamManagerModuleId = null;
+      metroRequire.getModules().forEach(function(module, moduleId){
+        var name = String(module && module.verboseName || '');
+        if (name === 'app/store/storage-wrapper.ts' || name.endsWith('/app/store/storage-wrapper.ts')) {
+          storageModuleId = moduleId;
+        }
+        if (name.includes('@metamask/perps-controller') && name.includes('/constants/perpsConfig.')) {
+          perpsConfigModuleId = moduleId;
+        }
+        if (name === 'app/components/UI/Perps/providers/PerpsStreamManager.tsx' || name.endsWith('/app/components/UI/Perps/providers/PerpsStreamManager.tsx')) {
+          streamManagerModuleId = moduleId;
+        }
       });
-    })()`,
-  );
+      if (storageModuleId === null || perpsConfigModuleId === null || streamManagerModuleId === null) {
+        throw new Error('Required Mobile storage, Perps constants, or stream manager module is unavailable in Metro.');
+      }
+      var storageExports = metroRequire(storageModuleId);
+      var storage = storageExports && (storageExports.default || storageExports);
+      var perpsConfig = metroRequire(perpsConfigModuleId);
+      var streamManagerExports = metroRequire(streamManagerModuleId);
+      var getStreamManager = streamManagerExports && streamManagerExports.getStreamManagerInstance;
+      var streamManager = typeof getStreamManager === 'function' ? getStreamManager() : null;
+      var keys = [
+        perpsConfig.PERPS_DISK_CACHE_MARKETS,
+        perpsConfig.PERPS_DISK_CACHE_USER_DATA,
+      ];
+      if (!storage || typeof storage.removeItem !== 'function' || typeof storage.getItem !== 'function' || keys.some(function(key){ return typeof key !== 'string' || key.length === 0; })) {
+        throw new Error('Resolved Mobile storage or Perps cache constants are invalid.');
+      }
+      if (!streamManager) {
+        throw new Error('Resolved Mobile Perps stream manager is invalid.');
+      }
+      var engine = globalThis.Engine;
+      var controller = engine && engine.context && engine.context.PerpsController;
+      if (!controller || typeof controller.update !== 'function' || !controller.state) {
+        throw new Error('Engine.context.PerpsController cache state is unavailable.');
+      }
+      var marketEntries = Object.keys(controller.state.cachedMarketDataByProvider || {}).length;
+      var userEntries = Object.keys(controller.state.cachedUserDataByProvider || {}).length;
+      var channelNames = ['marketData', 'positions', 'orders', 'account'];
+      var quiesceChannels = function(){
+        channelNames.forEach(function(name){
+          var channel = streamManager[name];
+          if (!channel || typeof channel.disconnect !== 'function' || typeof channel.clearCache !== 'function') {
+            throw new Error('Perps stream channel ' + name + ' cannot be quiesced.');
+          }
+          channel.disconnect();
+        });
+      };
+      quiesceChannels();
+      if (typeof controller.stopMarketDataPreload === 'function') {
+        controller.stopMarketDataPreload();
+      }
+      var pendingOperations = [
+        streamManager.marketData && streamManager.marketData.fetchPromise,
+        streamManager.userDataSnapshotPromise,
+      ].filter(function(value){ return value && typeof value.then === 'function'; });
+      return Promise.allSettled(pendingOperations).then(function(){
+        quiesceChannels();
+        channelNames.forEach(function(name){ streamManager[name].clearCache(); });
+        controller.update(function(state){
+          state.cachedMarketDataByProvider = {};
+          state.cachedUserDataByProvider = {};
+        });
+        return Promise.all(keys.map(function(key){ return storage.removeItem(key); }));
+      }).then(function(){
+        return new Promise(function(resolve){ setTimeout(resolve, 250); });
+      }).then(function(){
+        return Promise.all(keys.map(function(key){ return storage.getItem(key); }));
+      }).then(function(values){
+        var remainingKeys = keys.filter(function(_key, index){ return values[index] !== null && values[index] !== undefined; });
+        if (remainingKeys.length > 0) {
+          throw new Error('Perps performance cache repopulated after clear: ' + remainingKeys.join(', '));
+        }
+        return JSON.stringify({
+          ok: true,
+          method: 'metro-cdp',
+          clearedStorageKeys: keys,
+          clearedControllerMarketEntries: marketEntries,
+          clearedControllerUserEntries: userEntries,
+          quiescedChannels: channelNames,
+          awaitedPendingOperations: pendingOperations.length,
+          storageVerifiedAbsent: true,
+        });
+      });
+    })()`;
+}
+
+async function clearPerformanceCaches(input) {
+  return evalAsync(input, clearPerformanceCachesExpression());
 }
 
 async function waitForPositionsAbsent(input, symbols, timeoutMs = 30000) {
@@ -846,6 +1028,7 @@ const DIRECT_ACTIONS = new Map([
   ['metamask.perps.ensure_positions', ensurePositions],
   ['metamask.perps.ensure_orders', ensureOrders],
   ['metamask.perps.clear_performance_caches', clearPerformanceCaches],
+  ['metamask.perps.measure_homepage_visible', measureHomepageVisible],
   ['metamask.perps.start_state', startState],
   ['metamask.perps.teardown_state', teardownState],
 ]);

package/library/actions/mobile/perps/prepare_local_snapshot_endpoint.mjs

@@ -0,0 +1,58 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import { runAdapter } from '../platform/bridge.mjs';
+import { resolveMobileToolPath } from '../platform/tool-paths.mjs';
+
+const execFileAsync = promisify(execFile);
+
+async function prepareLocalSnapshotEndpoint(input) {
+  const port = Number(input.node?.port);
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    throw new Error(
+      'metamask.perps.prepare_local_snapshot_endpoint requires an integer port between 1 and 65535.',
+    );
+  }
+
+  const serial = process.env.ADB_SERIAL || process.env.ANDROID_SERIAL;
+  if (!serial) {
+    return {
+      action: input.action,
+      applied: false,
+      reason: 'not-required-for-ios-simulator',
+      port,
+      proofPath: 'local-snapshot-endpoint-platform-check',
+    };
+  }
+
+  const adb = resolveMobileToolPath('adb');
+  if (!adb) {
+    throw new Error(
+      'metamask.perps.prepare_local_snapshot_endpoint could not resolve adb.',
+    );
+  }
+  const mapping = `tcp:${port}`;
+  await execFileAsync(adb, ['-s', serial, 'reverse', mapping, mapping], {
+    timeout: 10_000,
+  });
+  const { stdout } = await execFileAsync(adb, ['-s', serial, 'reverse', '--list'], {
+    timeout: 10_000,
+  });
+  const applied = stdout
+    .split(/\r?\n/u)
+    .some((line) => line.includes(`${mapping} ${mapping}`));
+  if (!applied) {
+    throw new Error(
+      `metamask.perps.prepare_local_snapshot_endpoint did not observe ${mapping} after applying it to ${serial}.`,
+    );
+  }
+  return {
+    action: input.action,
+    applied: true,
+    port,
+    redacted: true,
+    proofPath: 'adb-reverse-local-snapshot-endpoint',
+  };
+}
+
+runAdapter(prepareLocalSnapshotEndpoint);

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

@@ -526,14 +526,21 @@ function valueContains(actual, expected) {
   return Object.is(actual, expected);
 }
 
-function routeMatches(route, expectedRoute, expectedParams) {
+export function routeSatisfiesNavigationTarget(
+  route,
+  expectedRoute,
+  expectedParams,
+) {
   return routeName(route) === expectedRoute &&
     (expectedParams === undefined || valueContains(route?.params ?? {}, expectedParams));
 }
 
 function routeTransitionProven(previousRoute, currentRoute, expectedRoute, expectedParams) {
-  if (!previousRoute || !routeMatches(currentRoute, expectedRoute, expectedParams)) return false;
-  if (!routeMatches(previousRoute, expectedRoute, expectedParams)) return true;
+  if (
+    !previousRoute ||
+    !routeSatisfiesNavigationTarget(currentRoute, expectedRoute, expectedParams)
+  ) return false;
+  if (!routeSatisfiesNavigationTarget(previousRoute, expectedRoute, expectedParams)) return true;
   return Boolean(
     previousRoute.key &&
       currentRoute?.key &&
@@ -563,6 +570,23 @@ export async function navigate(input, route, params = {}, expectedRoute) {
     if (!isTargetTransition(error)) throw error;
   }
 
+  if (
+    routeSatisfiesNavigationTarget(
+      previousRoute,
+      requestedRoute,
+      requestedParams,
+    )
+  ) {
+    return {
+      navigated: route,
+      params,
+      previousRoute,
+      currentRoute: previousRoute,
+      verifiedRoute: requestedRoute,
+      alreadyAtRoute: true,
+    };
+  }
+
   while (navigateAttempts < 2 || recoveryPending) {
     if (recoveryPending) {
       const deadline = recoveryDeadline ?? Date.now() + timeoutMs;
@@ -598,7 +622,14 @@ export async function navigate(input, route, params = {}, expectedRoute) {
           },
         };
       }
-      if (!previousRoute && routeMatches(currentRoute, requestedRoute, requestedParams)) {
+      if (
+        !previousRoute &&
+        routeSatisfiesNavigationTarget(
+          currentRoute,
+          requestedRoute,
+          requestedParams,
+        )
+      ) {
         break;
       }
       recoveryPending = false;
@@ -682,7 +713,9 @@ export async function waitForRoute(
       await waitForNextRouteProbe(deadline);
       continue;
     }
-    if (routeMatches(lastRoute, expected, expectedParams)) return lastRoute;
+    if (
+      routeSatisfiesNavigationTarget(lastRoute, expected, expectedParams)
+    ) return lastRoute;
     pollCount += 1;
     await waitForNextRouteProbe(deadline);
   }

package/library/actions/mobile/wallet/ensure_unlocked.mjs

@@ -1,6 +1,10 @@
 import { readFile } from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
-import { bridgeCommand, runAdapter, selectBridgeStatusEntry } from '../platform/bridge.mjs';
+import {
+  bridgeCommand,
+  runAdapter,
+  selectBridgeStatusEntry,
+} from '../platform/bridge.mjs';
 import { walletFixturePath } from '../../harness-exports.mjs';
 
 async function fixturePassword(projectRoot) {