@deeeed/metamask-harness 0.86.1 → 0.87.0

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

@@ -22,6 +22,8 @@ import path from 'node:path';
 
 import { captureActiveRecipeRecordingSnapshot, recipeHarnessPath } from '@farmslot/recipe-cli/harness';
 import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, extensionIdPath, walletFixturePath } from '../../harness-exports.mjs';
+import { liveAdapterDeadline } from '../../shared/app/live-adapter-deadline.mjs';
+import { withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
 
 // Resolve the Farmslot harness through normal package dependencies by default.
 // Local Farmslot source is only a dev override handled by the harness paths module.
@@ -843,6 +845,8 @@ export async function withExtensionPage(input, callback) {
     const origin = `chrome-extension://${extensionId}`;
     const runtimeIdentity = extensionRuntimeIdentity({ port, target, browserVersion });
     const page = new ExtensionPage(session, origin, target, port, runtimeIdentity);
+    // Rate-limit retries on this page's reads stop before the runner's process limit.
+    page.actionDeadline = liveAdapterDeadline(input.node);
     const recoverVisibleWallet = input.action === 'metamask.wallet.import' && input.node?.method === 'ui';
     if (recoverVisibleWallet) {
       try {
@@ -1030,7 +1034,7 @@ export class ExtensionPage extends CdpWebPage {
   }
 
   async readPositions() {
-    return this.evaluate(`(async () => {
+    return withRateLimitRetry('perpsGetPositions', () => this.evaluate(`(async () => {
       const request = globalThis.stateHooks?.submitRequestToBackground;
       const manager = globalThis.stateHooks?.getPerpsStreamManager?.();
       const cached = manager?.positions?.cache;
@@ -1050,7 +1054,7 @@ export class ExtensionPage extends CdpWebPage {
         connected: Boolean(manager?.positions?.isConnected),
         positions: Array.isArray(cached) ? cached : [],
       };
-    })()`);
+    })()`), { deadline: this.actionDeadline });
   }
 
   async screenshot(contextOrInput, relPath, metadata = {}) {

package/library/actions/extension/ui/navigate.mjs

@@ -280,6 +280,8 @@ export async function openPerpsHome(page, timeoutMs) {
     await pauseForUi(page);
   }
 
+  // The sample is capped at 30 and the header and tabs come first in the DOM, so loading
+  // markers are listed first; otherwise a Perps view still loading reads as a wrong route.
   const state = await page.evaluate(`({
     href: location.href,
     title: document.title,
@@ -291,8 +293,14 @@ export async function openPerpsHome(page, timeoutMs) {
       })
       .map((element) => element.getAttribute('data-testid'))
       .filter(Boolean)
+      .sort((a, b) => Number(b.endsWith('-loading')) - Number(a.endsWith('-loading')))
       .slice(0, 30),
   })`);
+  if (await hasVisibleSelector(page, perpsLoading)) {
+    throw new Error(
+      `extension ui.navigate page=perps: Perps home stayed on its loading view (perps-view-loading visible) within the ${timeoutMs}ms budget; observed ${JSON.stringify(state)}.\nNext: check the Perps stream/provider, or raise timeout_ms; a raw hash route does not wait for Perps readiness.`,
+    );
+  }
   throw new Error(
     `extension ui.navigate page=perps could not resolve the Perps home through visible UI; observed ${JSON.stringify(state)}. Capture the current UI with mm-harness call ui.screenshot, then use a verified visible control or raw hash/path.`,
   );

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

@@ -4,8 +4,13 @@ import { pathToFileURL } from 'node:url';
 import {
   MOBILE_BRIDGE_RESULT_ERROR_CODES,
   bridgeCommand,
+  createSetupBudget,
+  deadlineFromTimeout,
+  earliestDeadline,
   evalAsync,
-  isTargetTransition,
+  inheritedDeadline,
+  isUnansweredRead,
+  mobileNavigationTimeoutMs,
   navigate,
   routeSatisfiesNavigationTarget,
   runAdapter,
@@ -22,6 +27,7 @@ import {
   requireHouseNotional,
   requirePerpsOrderAllowed,
 } from '../../shared/perps/order-policy.mjs';
+import { isRateLimited, rateLimitedError, withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -94,23 +100,6 @@ const MODE_ROOT_TEST_IDS = {
 };
 const READ_ATTEMPT_TIMEOUT_MS = 10_000;
 
-function inheritedDeadline(input) {
-  const deadline = Number(input.node?._action_deadline_epoch_ms);
-  return Number.isFinite(deadline) ? deadline : null;
-}
-
-function earliestDeadline(input, deadline) {
-  const inherited = inheritedDeadline(input);
-  return inherited === null ? deadline : Math.min(deadline, inherited);
-}
-
-function deadlineFromTimeout(input, timeoutMs) {
-  return earliestDeadline(
-    input,
-    Date.now() + Math.max(0, Number(timeoutMs)),
-  );
-}
-
 async function sleepBeforeDeadline(deadline, maximumMs, wait = sleep) {
   const remainingMs = deadline - Date.now();
   if (remainingMs <= 0) return;
@@ -183,7 +172,7 @@ async function readModeState(input, mode, deadline) {
   try {
     return await queryModeState(input, mode, deadline);
   } catch (error) {
-    if (!isTargetTransition(error)) throw error;
+    if (!isUnansweredRead(error)) throw error;
     return null;
   }
 }
@@ -251,6 +240,8 @@ export async function ensureMode(input) {
   throw new Error(`Perps did not reach ${requestedMode} mode before timeout.`);
 }
 
+// Retries the client-not-initialized race until the deadline, and a 429 with
+// the shared rate-limit backoff.
 export async function retryPerpsClientRead(
   read,
   {
@@ -258,6 +249,8 @@ export async function retryPerpsClientRead(
     intervalMs = 500,
     sleep: wait = sleep,
     deadlineEpochMs,
+    call = 'PerpsController read',
+    random,
   } = {},
 ) {
   const localDeadline = Date.now() + Math.max(0, timeoutMs);
@@ -268,7 +261,7 @@ export async function retryPerpsClientRead(
       : Math.min(localDeadline, configuredDeadline);
   while (true) {
     try {
-      return await read();
+      return await withRateLimitRetry(call, read, { deadline, sleep: wait, random });
     } catch (error) {
       if (!/CLIENT_NOT_INITIALIZED/u.test(String(error?.message ?? error))) {
         throw error;
@@ -400,7 +393,7 @@ async function readPositions(input) {
       }
       return positions;
     },
-    { deadlineEpochMs: inheritedDeadline(input) },
+    { deadlineEpochMs: inheritedDeadline(input), call: 'PerpsController.getPositions' },
   );
 }
 
@@ -427,7 +420,7 @@ async function readOpenOrders(input) {
       }
       return orders;
     },
-    { deadlineEpochMs: inheritedDeadline(input) },
+    { deadlineEpochMs: inheritedDeadline(input), call: 'PerpsController.getOpenOrders' },
   );
 }
 
@@ -459,7 +452,7 @@ async function readStrategyOrders(input) {
       }
       return orders;
     },
-    { deadlineEpochMs: inheritedDeadline(input) },
+    { deadlineEpochMs: inheritedDeadline(input), call: 'PerpsController.getTwapOrders/getChaseOrders' },
   );
 }
 
@@ -917,7 +910,7 @@ async function readCurrentRoute(input) {
   try {
     return await bridgeCommand(input, ['get-route']);
   } catch (error) {
-    if (!isTargetTransition(error)) throw error;
+    if (!isUnansweredRead(error)) throw error;
     return null;
   }
 }
@@ -975,8 +968,7 @@ async function waitForPerpsUiTarget(input, testId, deadline) {
 }
 
 async function selectPerpsMarketFromHome(input, symbol, previousRoute) {
-  const timeoutMs = Number(input.node?.navigation_timeout_ms ?? 15_000);
-  const deadline = deadlineFromTimeout(input, timeoutMs);
+  const deadline = deadlineFromTimeout(input, mobileNavigationTimeoutMs(input));
   const params = { market: { symbol } };
   const rowTestId = `perps-market-row-item-${symbol}`;
   const recentlyViewedTestId = `perps-recently-viewed-tile-${symbol}`;
@@ -1059,8 +1051,7 @@ async function waitForRouteChange(input, previousRoute, deadline) {
 }
 
 async function navigateFromMarketDetailsToHome(input, previousRoute) {
-  const timeoutMs = Number(input.node?.navigation_timeout_ms ?? 15_000);
-  const deadline = deadlineFromTimeout(input, timeoutMs);
+  const deadline = deadlineFromTimeout(input, mobileNavigationTimeoutMs(input));
   let visibleTestIds = await readVisiblePerpsTestIds(input, deadline);
   let backTestId = PERPS_MARKET_DETAILS_BACK_TEST_IDS.find((testId) =>
     visibleTestIds.has(testId),
@@ -1482,6 +1473,16 @@ export async function placeOrder(input) {
       );
     }
     if (result?.success === false || result == null) {
+      // Mobile keeps no placement receipt, so a 429 is never retried: nothing proves the venue saw no order.
+      if (isRateLimited(result?.error)) {
+        throw rateLimitedError({
+          call: 'PerpsController.placeOrder',
+          attempts: 1,
+          waitedMs: 0,
+          reason: `no retry, since nothing proves the ${symbol} order was not placed`,
+          next: `read the ${symbol} positions and orders, then wait a minute and rerun only if nothing was placed`,
+        });
+      }
       throw new Error(`Failed to place ${symbol} ${side}: ${result?.error || JSON.stringify(result)}`);
     }
     if (orderType === 'limit') {
@@ -1746,9 +1747,20 @@ function mergeStateConfig(defaults, params) {
   };
 }
 
-export function applyTradingStatePolicy(config) {
+// The policy owns positions, orders and strategies. An explicit request for one
+// of them would be dropped, so it fails before any phase runs.
+export function applyTradingStatePolicy(config, requested) {
   const policy = config.trading_state;
   if (policy === undefined) return config;
+  const dropped = ['positions', 'orders', 'strategies'].filter(
+    (key) => requested[key] !== undefined && requested[key] !== false,
+  );
+  if (dropped.length > 0) {
+    throw new Error(
+      `metamask.perps.start_state trading_state=${String(policy)} sets positions, orders and strategies itself, so the requested ${dropped.join(', ')} would be ignored. ` +
+        `Omit trading_state to apply ${dropped.join(', ')}, or request ${dropped.join(', ')} in a separate metamask.perps.start_state node.`,
+    );
+  }
   if (policy === 'preserve') {
     return { ...config, positions: false, orders: false, strategies: false };
   }
@@ -1983,16 +1995,15 @@ export async function startState(input) {
   const params = paramsForState(input);
   const config = applyTradingStatePolicy(
     mergeStateConfig(profileDefaults(params.profile), params),
+    params,
   );
-  const timeoutMs = Math.max(1, Number(input.node?.timeout_ms ?? 30_000));
-  const deadline = deadlineFromTimeout(input, timeoutMs);
-  const stateInput = () => {
-    const remainingMs = deadline - Date.now();
-    if (remainingMs <= 0) {
-      throw new Error(
-        'metamask.perps.start_state timed out before completing all phases.',
-      );
-    }
+  const budget = createSetupBudget(input, 'metamask.perps.start_state');
+  const navigationSlice = { sliceMs: budget.navigationMs };
+  // Product edits require an app restart before proof. Mobile relocks on restart,
+  // so a deterministic Perps start state must restore the fixture-backed wallet
+  // prerequisite before it navigates or converges controller state.
+  const wallet = await budget.phase('unlock', (phaseInput) => {
+    const remainingMs = phaseInput.node.timeout_ms;
     const configuredTargetMs = Number(input.node?.target_timeout_ms);
     const targetTimeoutMs = Math.min(
       remainingMs,
@@ -2007,75 +2018,78 @@ export async function startState(input) {
         ? configuredUnlockMs
         : remainingMs,
     );
-    return {
-      ...input,
+    return ensureUnlocked({
+      ...phaseInput,
+      action: 'metamask.wallet.ensure_unlocked',
       node: {
-        ...input.node,
-        _action_deadline_epoch_ms: deadline,
-        timeout_ms: remainingMs,
-        bridge_timeout_ms: remainingMs,
-        cdp_timeout_ms: remainingMs,
-        controller_ready_timeout_ms: remainingMs,
+        ...phaseInput.node,
+        action: 'metamask.wallet.ensure_unlocked',
         target_timeout_ms: targetTimeoutMs,
         unlock_timeout_ms: unlockTimeoutMs,
       },
-    };
-  };
-  // Product edits require an app restart before proof. Mobile relocks on restart,
-  // so a deterministic Perps start state must restore the fixture-backed wallet
-  // prerequisite before it navigates or converges controller state.
-  const walletInput = stateInput();
-  const wallet = await ensureUnlocked({
-    ...walletInput,
-    action: 'metamask.wallet.ensure_unlocked',
-    node: { ...walletInput.node, action: 'metamask.wallet.ensure_unlocked' },
+    });
   });
-  const accountInput = stateInput();
   const account = typeof config.account === 'string' && config.account.trim()
-    ? await selectAccount({
-      ...accountInput,
+    ? await budget.phase('account', (phaseInput) => selectAccount({
+      ...phaseInput,
       action: 'metamask.wallet.select_account',
       node: {
-        ...accountInput.node,
+        ...phaseInput.node,
         action: 'metamask.wallet.select_account',
         ...(/^0x[0-9a-f]{40}$/iu.test(config.account.trim())
           ? { address: config.account.trim() }
           : { name: config.account.trim() }),
       },
-    })
+    }))
     : { skipped: true };
   // Entering Perps initializes the provider client on a freshly launched app.
   // State reads before this navigation fail with CLIENT_NOT_INITIALIZED.
-  const navigation = await applyStateNavigation(stateInput(), config);
-  const provider = await ensureProvider(stateInput(), config);
-  const network = await ensureNetwork(stateInput(), config);
+  const navigation = await budget.phase(
+    'navigation',
+    (phaseInput) => applyStateNavigation(phaseInput, config),
+    navigationSlice,
+  );
+  const provider = await budget.phase('provider', (phaseInput) =>
+    ensureProvider(phaseInput, config));
+  const network = await budget.phase('network', (phaseInput) =>
+    ensureNetwork(phaseInput, config));
   let resolvedNavigation = provider.changed || network.changed
-    ? await applyStateNavigation(stateInput(), config)
+    ? await budget.phase(
+      'navigation after provider or network change',
+      (phaseInput) => applyStateNavigation(phaseInput, config),
+      navigationSlice,
+    )
     : navigation;
-  const modeInput = stateInput();
   const marketMode = config.market_mode
-    ? await ensureMode({
-        ...modeInput,
+    ? await budget.phase('market mode', (phaseInput) => ensureMode({
+        ...phaseInput,
         action: 'metamask.perps.ensure_mode',
         node: {
-          ...modeInput.node,
+          ...phaseInput.node,
           action: 'metamask.perps.ensure_mode',
           mode: config.market_mode,
         },
-      })
+      }))
     : { skipped: true };
   if (marketMode.alreadySelected === false) {
-    resolvedNavigation = await applyStateNavigation(stateInput(), config);
-  }
-  const tutorial = await applyTutorialState(stateInput(), config);
-  const readyToTrade = await assertReadyToTrade(stateInput(), config);
-  const balance = await assertBalance(stateInput(), config);
-  const strategies = await applyStrategiesState(
-    stateInput(),
-    config.strategies,
-  );
-  const orders = await applyOrdersState(stateInput(), config.orders);
-  const positions = await applyPositionsState(stateInput(), config.positions);
+    resolvedNavigation = await budget.phase(
+      'navigation after mode change',
+      (phaseInput) => applyStateNavigation(phaseInput, config),
+      navigationSlice,
+    );
+  }
+  const tutorial = await budget.phase('tutorial', (phaseInput) =>
+    applyTutorialState(phaseInput, config));
+  const readyToTrade = await budget.phase('ready to trade', (phaseInput) =>
+    assertReadyToTrade(phaseInput, config));
+  const balance = await budget.phase('balance', (phaseInput) =>
+    assertBalance(phaseInput, config));
+  const strategies = await budget.phase('strategies', (phaseInput) =>
+    applyStrategiesState(phaseInput, config.strategies));
+  const orders = await budget.phase('orders', (phaseInput) =>
+    applyOrdersState(phaseInput, config.orders));
+  const positions = await budget.phase('positions', (phaseInput) =>
+    applyPositionsState(phaseInput, config.positions));
   return {
     action: input.action,
     profile: config.profile ?? params.profile ?? null,
@@ -2104,16 +2118,7 @@ export async function startState(input) {
 }
 
 export async function teardownState(input) {
-  const timeoutMs = Math.max(1, Number(input.node?.timeout_ms ?? 30_000));
-  const deadline = deadlineFromTimeout(input, timeoutMs);
-  const stateInput = (phase) => {
-    if (Date.now() >= deadline) {
-      throw new Error(
-        `metamask.perps.teardown_state timed out before ${phase}.`,
-      );
-    }
-    return withRemainingDeadline(input, deadline);
-  };
+  const budget = createSetupBudget(input, 'metamask.perps.teardown_state');
   const params = paramsForState(input);
   const defaults = {
     provider: 'hyperliquid',
@@ -2124,28 +2129,23 @@ export async function teardownState(input) {
     strategies: params.market || params.symbol || params.markets || params.symbols ? { state: 'none', mode: 'matching' } : false,
   };
   const config = mergeStateConfig(defaults, params);
-  const environment = await assertRequestedRuntimeState(
-    stateInput('checking the requested environment'),
-    config,
-  );
-  const strategies = await applyStrategiesState(
-    stateInput('cleaning strategies'),
-    config.strategies,
-  );
-  const orders = await applyOrdersState(
-    stateInput('cleaning orders'),
-    config.orders,
-  );
-  const positions = await applyPositionsState(
-    stateInput('closing positions'),
-    config.positions,
+  const environment = await budget.phase(
+    'checking the requested environment',
+    (phaseInput) => assertRequestedRuntimeState(phaseInput, config),
   );
+  const strategies = await budget.phase('cleaning strategies', (phaseInput) =>
+    applyStrategiesState(phaseInput, config.strategies));
+  const orders = await budget.phase('cleaning orders', (phaseInput) =>
+    applyOrdersState(phaseInput, config.orders));
+  const positions = await budget.phase('closing positions', (phaseInput) =>
+    applyPositionsState(phaseInput, config.positions));
   const navigation =
     config.page === false
       ? { skipped: true }
-      : await applyStateNavigation(
-          stateInput('restoring the requested page'),
-          config,
+      : await budget.phase(
+          'restoring the requested page',
+          (phaseInput) => applyStateNavigation(phaseInput, config),
+          { sliceMs: budget.navigationMs },
         );
   return {
     action: input.action,