@deeeed/metamask-harness 0.45.1 → 0.46.0

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

@@ -4,10 +4,13 @@ import {
   evalAsync,
   isTargetTransition,
   navigate,
+  routeSatisfiesNavigationTarget,
   runAdapter,
+  waitForRoute,
 } from '../platform/bridge.mjs';
 import { ensureUnlocked } from '../wallet/ensure_unlocked.mjs';
 import { selectAccount } from '../wallet/select_account.mjs';
+import { observeNativeUi } from '../platform/observe-ui.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -80,7 +83,31 @@ const MODE_ROOT_TEST_IDS = {
 };
 const READ_ATTEMPT_TIMEOUT_MS = 10_000;
 
-function withRemainingDeadline(input, deadline, attemptTimeoutMs) {
+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;
+  await wait(Math.min(maximumMs, remainingMs));
+}
+
+function withRemainingDeadline(input, requestedDeadline, attemptTimeoutMs) {
+  const deadline = earliestDeadline(input, requestedDeadline);
   const remainingMs = Math.max(1, deadline - Date.now());
   const boundedTimeout = (configured) =>
     Math.min(
@@ -93,6 +120,7 @@ function withRemainingDeadline(input, deadline, attemptTimeoutMs) {
     node: {
       ...input.node,
       _action_deadline_epoch_ms: deadline,
+      timeout_ms: boundedTimeout(input.node?.timeout_ms),
       bridge_timeout_ms: boundedTimeout(input.node?.bridge_timeout_ms),
       cdp_timeout_ms: boundedTimeout(input.node?.cdp_timeout_ms),
       controller_ready_timeout_ms: boundedTimeout(
@@ -147,7 +175,10 @@ export async function ensureMode(input) {
     throw new Error('metamask.perps.ensure_mode requires mode=lite|pro.');
   }
   const otherMode = requestedMode === 'lite' ? 'pro' : 'lite';
-  const deadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
+  const deadline = deadlineFromTimeout(
+    input,
+    Number(input.node?.timeout_ms ?? 30_000),
+  );
   let switched = false;
 
   while (Date.now() < deadline) {
@@ -184,7 +215,7 @@ export async function ensureMode(input) {
         switched = true;
       }
     }
-    await sleep(Math.min(250, Math.max(0, deadline - Date.now())));
+    await sleepBeforeDeadline(deadline, 250);
   }
 
   throw new Error(`Perps did not reach ${requestedMode} mode before timeout.`);
@@ -192,9 +223,19 @@ export async function ensureMode(input) {
 
 export async function retryPerpsClientRead(
   read,
-  { timeoutMs = 20000, intervalMs = 500, sleep: wait = sleep } = {},
+  {
+    timeoutMs = 20000,
+    intervalMs = 500,
+    sleep: wait = sleep,
+    deadlineEpochMs,
+  } = {},
 ) {
-  const deadline = Date.now() + timeoutMs;
+  const localDeadline = Date.now() + Math.max(0, timeoutMs);
+  const configuredDeadline = Number(deadlineEpochMs);
+  const deadline =
+    deadlineEpochMs == null || !Number.isFinite(configuredDeadline)
+      ? localDeadline
+      : Math.min(localDeadline, configuredDeadline);
   while (true) {
     try {
       return await read();
@@ -204,7 +245,7 @@ export async function retryPerpsClientRead(
       }
       const remainingMs = deadline - Date.now();
       if (remainingMs <= 0) throw error;
-      await wait(Math.min(intervalMs, remainingMs));
+      await sleepBeforeDeadline(deadline, intervalMs, wait);
     }
   }
 }
@@ -329,6 +370,7 @@ async function readPositions(input) {
       }
       return positions;
     },
+    { deadlineEpochMs: inheritedDeadline(input) },
   );
 }
 
@@ -355,9 +397,227 @@ async function readOpenOrders(input) {
       }
       return orders;
     },
+    { deadlineEpochMs: inheritedDeadline(input) },
+  );
+}
+
+async function readStrategyOrders(input) {
+  return retryPerpsClientRead(
+    async () => {
+      const orders = await evalAsync(
+        input,
+        `(function(){
+        var controller = Engine && Engine.context && Engine.context.PerpsController;
+        if (!controller || typeof controller.getTwapOrders !== 'function' || typeof controller.getChaseOrders !== 'function') {
+          throw new Error('PerpsController strategy readers are unavailable; cannot clean live TWAP and Chase orders.');
+        }
+        return Promise.all([
+          controller.getTwapOrders(),
+          controller.getChaseOrders()
+        ]).then(function(values){
+          if (!Array.isArray(values[0]) || !Array.isArray(values[1])) {
+            throw new Error('PerpsController strategy readers returned a non-array result.');
+          }
+          return JSON.stringify({ twap: values[0], chase: values[1] });
+        });
+        })()`,
+      );
+      if (!Array.isArray(orders?.twap) || !Array.isArray(orders?.chase)) {
+        throw new Error(
+          'PerpsController strategy readers returned an invalid result.',
+        );
+      }
+      return orders;
+    },
+    { deadlineEpochMs: inheritedDeadline(input) },
+  );
+}
+
+function selectedActiveTwapOrders(input, orders) {
+  return selectedItems(input, orders).filter(
+    (order) => String(order?.status ?? '').toLowerCase() === 'active',
+  );
+}
+
+const ACTIVE_CHASE_STATUSES = new Set([
+  'active',
+  'backgrounded',
+  'termination_pending',
+]);
+
+function selectedActiveChaseOrders(input, orders) {
+  return selectedItems(input, orders).filter((order) =>
+    ACTIVE_CHASE_STATUSES.has(String(order?.status ?? '').toLowerCase()),
+  );
+}
+
+async function waitForStrategyOrdersAbsent(
+  input,
+  targetKeys,
+  timeoutMs = 30000,
+) {
+  const deadline = deadlineFromTimeout(input, timeoutMs);
+  let activeTwapOrders = [];
+  let activeChaseOrders = [];
+  while (true) {
+    const orders = await readStrategyOrders(input);
+    activeTwapOrders = selectedActiveTwapOrders(
+      input,
+      orders.twap,
+    ).filter((order) =>
+      targetKeys.has(
+        strategyTargetKey({
+          orderId: order.orderId,
+          orderType: 'twap',
+          providerId: order.providerId,
+        }),
+      ),
+    );
+    activeChaseOrders = selectedActiveChaseOrders(
+      input,
+      orders.chase,
+    ).filter((order) =>
+      targetKeys.has(
+        strategyTargetKey({
+          orderId: order.handle,
+          orderType: 'chase',
+          providerId: order.providerId,
+        }),
+      ),
+    );
+    if (activeTwapOrders.length === 0 && activeChaseOrders.length === 0) {
+      return { activeTwapOrders, activeChaseOrders };
+    }
+    if (Date.now() >= deadline) {
+      return { activeTwapOrders, activeChaseOrders };
+    }
+    await sleepBeforeDeadline(deadline, 500);
+  }
+}
+
+function strategyTargetKey(target) {
+  return [
+    target.orderType,
+    target.providerId ?? '',
+    String(target.orderId),
+  ].join(':');
+}
+
+function isAlreadyAbsentStrategyResult(entry) {
+  return (
+    entry.success !== true &&
+    /never placed, already canceled, or filled/iu.test(
+      String(entry.result?.error ?? entry.error ?? ''),
+    )
   );
 }
 
+async function closeStrategyOrders(input) {
+  requireExplicitSelection(input);
+  const orders = await readStrategyOrders(input);
+  const twapOrders = selectedActiveTwapOrders(input, orders.twap);
+  const chaseOrders = selectedActiveChaseOrders(input, orders.chase);
+  const targets = [
+    ...twapOrders.map((order) => ({
+      orderId: String(order.orderId ?? ''),
+      symbol: symbolForItem(order),
+      orderType: 'twap',
+      providerId: order.providerId,
+    })),
+    ...chaseOrders.map((order) => ({
+      orderId: String(order.handle ?? ''),
+      symbol: symbolForItem(order),
+      orderType: 'chase',
+      providerId: order.providerId,
+    })),
+  ];
+  const invalid = targets.find((target) => !target.orderId || !target.symbol);
+  if (invalid) {
+    throw new Error(
+      `Cannot cancel selected Perps strategy without an order ID and symbol: ${JSON.stringify(invalid)}`,
+    );
+  }
+  if (targets.length === 0) {
+    return {
+      action: input.action,
+      changed: false,
+      canceled: false,
+      matchingCount: 0,
+      twapCount: 0,
+      chaseCount: 0,
+      acceptedCount: 0,
+      alreadyAbsentCount: 0,
+      proofPath: 'mobile-perps-controller-cancel-strategies',
+    };
+  }
+
+  const result = await evalAsync(
+    input,
+    `(function(){
+      var controller = Engine && Engine.context && Engine.context.PerpsController;
+      var targets = ${JSON.stringify(targets)};
+      if (!controller || typeof controller.cancelOrder !== 'function') {
+        throw new Error('Engine.context.PerpsController.cancelOrder is unavailable; cannot cancel live Perps strategies.');
+      }
+      return targets.reduce(function(chain, target){
+        return chain.then(function(results){
+          return controller.cancelOrder(target).then(function(value){
+            results.push({ target: target, success: !value || value.success !== false, result: value });
+            return results;
+          }, function(error){
+            results.push({ target: target, success: false, error: String(error && error.message || error) });
+            return results;
+          });
+        });
+      }, Promise.resolve([])).then(function(results){
+        return JSON.stringify(results);
+      });
+    })()`,
+  );
+  const failed = result.filter(
+    (entry) =>
+      entry.success !== true && !isAlreadyAbsentStrategyResult(entry),
+  );
+  if (failed.length > 0) {
+    throw new Error(
+      `Failed to cancel ${failed.length} selected Perps strategies: ${JSON.stringify(failed)}`,
+    );
+  }
+
+  const confirmedTargetKeys = new Set(
+    result
+      .filter((entry) => entry.success === true)
+      .map((entry) => strategyTargetKey(entry.target)),
+  );
+  const remaining =
+    confirmedTargetKeys.size === 0
+      ? { activeTwapOrders: [], activeChaseOrders: [] }
+      : await waitForStrategyOrdersAbsent(
+          input,
+          confirmedTargetKeys,
+          Number(input.node?.timeout_ms ?? 30000),
+        );
+  if (
+    remaining.activeTwapOrders.length > 0 ||
+    remaining.activeChaseOrders.length > 0
+  ) {
+    throw new Error(
+      `Expected selected Perps strategies to cancel, but ${remaining.activeTwapOrders.length} TWAP and ${remaining.activeChaseOrders.length} Chase orders remain active.`,
+    );
+  }
+  return {
+    action: input.action,
+    changed: result.some((entry) => entry.success === true),
+    canceled: result.some((entry) => entry.success === true),
+    matchingCount: targets.length,
+    twapCount: twapOrders.length,
+    chaseCount: chaseOrders.length,
+    acceptedCount: result.filter((entry) => entry.success === true).length,
+    alreadyAbsentCount: result.filter(isAlreadyAbsentStrategyResult).length,
+    proofPath: 'mobile-perps-controller-cancel-strategies',
+  };
+}
+
 export function clearPerformanceCachesExpression() {
   return `(function(){
       var metroRequire = globalThis.__r;
@@ -459,43 +719,43 @@ async function clearPerformanceCaches(input) {
 }
 
 async function waitForPositionsAbsent(input, symbols, timeoutMs = 30000) {
-  const deadline = Date.now() + timeoutMs;
+  const deadline = deadlineFromTimeout(input, timeoutMs);
   let last = [];
   while (Date.now() < deadline) {
     last = await readPositions(input);
     const remaining = last.filter((position) => symbols.includes(symbolForItem(position)));
     if (remaining.length === 0) return last;
-    await sleep(500);
+    await sleepBeforeDeadline(deadline, 500);
   }
   return last;
 }
 
 async function waitForOrdersAbsent(input, symbols, timeoutMs = 30000) {
-  const deadline = Date.now() + timeoutMs;
+  const deadline = deadlineFromTimeout(input, timeoutMs);
   let last = [];
   while (Date.now() < deadline) {
     last = await readOpenOrders(input);
     const remaining = last.filter((order) => symbols.includes(symbolForItem(order)));
     if (remaining.length === 0) return last;
-    await sleep(500);
+    await sleepBeforeDeadline(deadline, 500);
   }
   return last;
 }
 
 async function waitForPositionPresent(input, symbol, timeoutMs = 30000) {
-  const deadline = Date.now() + timeoutMs;
+  const deadline = deadlineFromTimeout(input, timeoutMs);
   let last = [];
   while (Date.now() < deadline) {
     last = await readPositions(input);
     const matching = last.filter((position) => symbolForItem(position) === symbol);
     if (matching.length > 0) return last;
-    await sleep(500);
+    await sleepBeforeDeadline(deadline, 500);
   }
   return last;
 }
 
 async function waitForSelectedState(input, readItems, expectedOpen, timeoutMs) {
-  const deadline = Date.now() + Math.max(0, timeoutMs);
+  const deadline = deadlineFromTimeout(input, timeoutMs);
   let items;
   while (true) {
     items = await readItems(input);
@@ -504,7 +764,7 @@ async function waitForSelectedState(input, readItems, expectedOpen, timeoutMs) {
       return matching;
     }
     if (Date.now() >= deadline) return matching;
-    await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
+    await sleepBeforeDeadline(deadline, 500);
   }
 }
 
@@ -605,18 +865,311 @@ function isTransientClosePriceError(result) {
   return /IOC_CANCEL|Slippage/i.test(message);
 }
 
+function isPerpsMarketSelectorRoute(route) {
+  return ['PerpsMarketListView', 'PerpsTrendingView'].includes(route?.name);
+}
+
+function marketSymbolFromRoute(route) {
+  const symbol = route?.params?.market?.symbol ?? route?.params?.symbol;
+  return String(symbol ?? '').trim() ? normalizeMarketSymbol(symbol) : null;
+}
+
+const PERPS_MARKET_DETAILS_BACK_TEST_IDS = [
+  'perps-pro-market-header-back-button',
+  'perps-market-header-back-button',
+];
+const PERPS_MARKET_DETAILS_SCROLL_TEST_IDS = [
+  'perps-pro-market-scroll-view',
+  'perps-market-details-view',
+];
+
+async function readCurrentRoute(input) {
+  try {
+    return await bridgeCommand(input, ['get-route']);
+  } catch (error) {
+    if (!isTargetTransition(error)) throw error;
+    return null;
+  }
+}
+
+async function readVisiblePerpsTestIds(input, deadline) {
+  const boundedInput = withRemainingDeadline(
+    input,
+    deadline,
+    READ_ATTEMPT_TIMEOUT_MS,
+  );
+  const observed = await observeNativeUi(
+    { refs: ['ui.visible'], node: boundedInput.node },
+    input.context,
+  );
+  const visible = observed.observations?.['ui.visible'];
+  if (!visible) {
+    const detail = observed.warnings
+      ?.map((warning) => warning.message)
+      .filter(Boolean)
+      .join('; ');
+    throw new Error(
+      `Visible Perps market navigation could not read native accessibility${detail ? `: ${detail}` : '.'}`,
+    );
+  }
+  return new Set(visible.items.map((item) => String(item.test_id ?? '')));
+}
+
+async function waitForPerpsUiTarget(input, testId, deadline) {
+  let lastTestIds = [];
+  while (Date.now() < deadline) {
+    const testIds = await readVisiblePerpsTestIds(input, deadline);
+    if (testIds.has(testId)) return testIds;
+    lastTestIds = [...testIds].filter(Boolean).slice(0, 20);
+    await sleepBeforeDeadline(deadline, 250);
+  }
+  throw new Error(
+    `Perps control ${testId} did not become visible before timeout. Observed: ${lastTestIds.join(', ') || 'none'}.`,
+  );
+}
+
+async function selectPerpsMarketFromHome(input, symbol, previousRoute) {
+  const timeoutMs = Number(input.node?.navigation_timeout_ms ?? 15_000);
+  const deadline = deadlineFromTimeout(input, timeoutMs);
+  const params = { market: { symbol } };
+  const rowTestId = `perps-market-row-item-${symbol}`;
+  const searchTestId = 'perps-market-list-search-bar';
+  let visibleTestIds = await readVisiblePerpsTestIds(input, deadline);
+  let usedSearch = false;
+
+  if (!visibleTestIds.has(rowTestId)) {
+    if (!visibleTestIds.has(searchTestId)) {
+      if (!visibleTestIds.has('perps-home-search-toggle')) {
+        throw new Error(
+          'Perps Home has no visible market row, search field, or search control.',
+        );
+      }
+      await bridgeCommand(withRemainingDeadline(input, deadline), [
+        'press-test-id',
+        'perps-home-search-toggle',
+      ]);
+      visibleTestIds = await waitForPerpsUiTarget(
+        input,
+        searchTestId,
+        deadline,
+      );
+    }
+    await bridgeCommand(withRemainingDeadline(input, deadline), [
+      'set-input',
+      searchTestId,
+      symbol,
+    ]);
+    visibleTestIds = await waitForPerpsUiTarget(
+      input,
+      rowTestId,
+      deadline,
+    );
+    usedSearch = true;
+  }
+
+  await bridgeCommand(withRemainingDeadline(input, deadline), [
+    'press-test-id',
+    rowTestId,
+  ]);
+  const currentRoute = await waitForRoute(
+    withRemainingDeadline(input, deadline),
+    'PerpsMarketDetails',
+    Math.max(1, deadline - Date.now()),
+    params,
+  );
+  return {
+    navigated: 'PerpsMarketDetails',
+    params,
+    previousRoute,
+    currentRoute,
+    verifiedRoute: 'PerpsMarketDetails',
+    visibleMarketSelection: { usedSearch },
+  };
+}
+
+async function waitForRouteChange(input, previousRoute, deadline) {
+  let currentRoute = previousRoute;
+  while (Date.now() < deadline) {
+    currentRoute = await readCurrentRoute(
+      withRemainingDeadline(input, deadline, READ_ATTEMPT_TIMEOUT_MS),
+    );
+    if (
+      currentRoute &&
+      (currentRoute.name !== previousRoute?.name ||
+        currentRoute.key !== previousRoute?.key)
+    ) {
+      return currentRoute;
+    }
+    await sleepBeforeDeadline(deadline, 250);
+  }
+  throw new Error('Perps back control did not change the current route.');
+}
+
+async function navigateFromMarketDetailsToHome(input, previousRoute) {
+  const timeoutMs = Number(input.node?.navigation_timeout_ms ?? 15_000);
+  const deadline = deadlineFromTimeout(input, timeoutMs);
+  let visibleTestIds = await readVisiblePerpsTestIds(input, deadline);
+  let backTestId = PERPS_MARKET_DETAILS_BACK_TEST_IDS.find((testId) =>
+    visibleTestIds.has(testId),
+  );
+  if (!backTestId) {
+    for (const [index, scrollTestId] of
+      PERPS_MARKET_DETAILS_SCROLL_TEST_IDS.entries()) {
+      try {
+        await bridgeCommand(withRemainingDeadline(input, deadline), [
+          'scroll-view',
+          '--test-id',
+          scrollTestId,
+          '--offset',
+          '0',
+          '--no-animated',
+        ]);
+        const expectedBackTestId = PERPS_MARKET_DETAILS_BACK_TEST_IDS[index];
+        visibleTestIds = await waitForPerpsUiTarget(
+          input,
+          expectedBackTestId,
+          deadline,
+        );
+        backTestId = expectedBackTestId;
+        break;
+      } catch (error) {
+        if (!/No scrollable near testID=/u.test(String(error))) throw error;
+      }
+    }
+  }
+  if (!backTestId) {
+    throw new Error(
+      'Perps market details has no visible back control for returning home.',
+    );
+  }
+  const pressed = await bridgeCommand(withRemainingDeadline(input, deadline), [
+    'press-test-id',
+    backTestId,
+  ]);
+  if (pressed?.ok === false) {
+    throw new Error(String(pressed.error || 'Perps back control press failed.'));
+  }
+  const intermediateRoute = await waitForRouteChange(
+    input,
+    previousRoute,
+    deadline,
+  );
+  if (
+    routeSatisfiesNavigationTarget(intermediateRoute, 'PerpsMarketListView')
+  ) {
+    return {
+      navigated: 'PerpsMarketListView',
+      params: {},
+      previousRoute,
+      currentRoute: intermediateRoute,
+      verifiedRoute: 'PerpsMarketListView',
+      visibleBackNavigation: { testId: backTestId },
+    };
+  }
+  const navigation = await navigate(
+    withRemainingDeadline(input, deadline),
+    'PerpsMarketListView',
+    {},
+  );
+  return {
+    ...navigation,
+    previousRoute,
+    intermediateRoute,
+    visibleBackNavigation: { testId: backTestId },
+  };
+}
+
 async function navigatePerps(input) {
   const selected = String(
     input.node?.target ?? input.node?.destination ?? defaultNavigationTarget(input.node),
   ).toLowerCase();
   if (selected === 'home' || selected === 'perps' || selected === 'perps_home') {
-    const navigation = await navigate(input, 'PerpsMarketListView', {});
-    return { action: input.action, target: selected, navigation, proofPath: 'agentic-navigation' };
+    const currentRoute = await readCurrentRoute(input);
+    if (routeSatisfiesNavigationTarget(currentRoute, 'PerpsMarketListView')) {
+      return {
+        action: input.action,
+        target: selected,
+        navigation: {
+          navigated: 'PerpsMarketListView',
+          params: {},
+          previousRoute: currentRoute,
+          currentRoute,
+          verifiedRoute: 'PerpsMarketListView',
+          alreadyAtRoute: true,
+        },
+        proofPath: 'agentic-navigation',
+      };
+    }
+    const navigation = currentRoute?.name === 'PerpsMarketDetails'
+      ? await navigateFromMarketDetailsToHome(input, currentRoute)
+      : await navigate(input, 'PerpsMarketListView', {});
+    return {
+      action: input.action,
+      target: selected,
+      navigation,
+      proofPath: navigation.visibleBackNavigation
+        ? 'visible-native-back-navigation'
+        : 'agentic-navigation',
+    };
   }
   if (selected === 'market' || selected === 'market_details') {
+    const currentRoute = await readCurrentRoute(input);
+    const requestedMarket = input.node?.market ?? input.node?.symbol;
+    if (
+      !String(requestedMarket ?? '').trim() &&
+      routeSatisfiesNavigationTarget(currentRoute, 'PerpsMarketDetails')
+    ) {
+      return {
+        action: input.action,
+        target: selected,
+        market: marketSymbolFromRoute(currentRoute),
+        navigation: {
+          navigated: 'PerpsMarketDetails',
+          params: currentRoute?.params ?? {},
+          previousRoute: currentRoute,
+          currentRoute,
+          verifiedRoute: 'PerpsMarketDetails',
+          alreadyAtRoute: true,
+        },
+        proofPath: 'agentic-navigation',
+      };
+    }
     const symbol = marketSymbol(input);
-    const navigation = await navigate(input, 'PerpsMarketDetails', { market: { symbol } });
-    return { action: input.action, target: selected, market: symbol, navigation, proofPath: 'agentic-navigation' };
+    const params = { market: { symbol } };
+    if (
+      routeSatisfiesNavigationTarget(
+        currentRoute,
+        'PerpsMarketDetails',
+        params,
+      )
+    ) {
+      return {
+        action: input.action,
+        target: selected,
+        market: symbol,
+        navigation: {
+          navigated: 'PerpsMarketDetails',
+          params,
+          previousRoute: currentRoute,
+          currentRoute,
+          verifiedRoute: 'PerpsMarketDetails',
+          alreadyAtRoute: true,
+        },
+        proofPath: 'agentic-navigation',
+      };
+    }
+    const navigation = isPerpsMarketSelectorRoute(currentRoute)
+      ? await selectPerpsMarketFromHome(input, symbol, currentRoute)
+      : await navigate(input, 'PerpsMarketDetails', params);
+    return {
+      action: input.action,
+      target: selected,
+      market: symbol,
+      navigation,
+      proofPath: navigation.visibleMarketSelection
+        ? 'visible-native-market-selection'
+        : 'agentic-navigation',
+    };
   }
   throw new Error(`Unsupported mobile Perps navigation target: ${selected}`);
 }
@@ -681,10 +1234,15 @@ function closePositionParams(input, position) {
 async function closePositionItem(input, position) {
   const maxAttempts = Number(input.node?.close_attempts ?? 3);
   const retryDelayMs = Number(input.node?.close_retry_delay_ms ?? 1000);
+  const deadline = deadlineFromTimeout(
+    input,
+    Number(input.node?.timeout_ms ?? 30_000),
+  );
   const baseParams = closePositionParams(input, position);
   const attempts = [];
   let lastResult = null;
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    if (Date.now() >= deadline) break;
     const currentPositions = await readPositions(input);
     const currentPosition = currentPositions.find((candidate) => symbolForItem(candidate) === baseParams.symbol);
     if (!currentPosition) return { symbol: baseParams.symbol, result: { success: true, alreadyClosed: true }, attempts };
@@ -699,7 +1257,7 @@ async function closePositionItem(input, position) {
     lastResult = result;
     if (result?.success === false) {
       if (isTransientClosePriceError(result)) {
-        await sleep(retryDelayMs);
+        await sleepBeforeDeadline(deadline, retryDelayMs);
       } else {
         break;
       }
@@ -872,7 +1430,8 @@ function paramsForState(input) {
 }
 
 function profileDefaults(profile) {
-  const selected = String(profile ?? 'clean_market_testnet');
+  const selected = String(profile ?? '').trim();
+  if (!selected) return {};
   if (selected === 'clean_market_testnet') {
     return {
       provider: 'hyperliquid',
@@ -880,6 +1439,7 @@ function profileDefaults(profile) {
       page: 'market',
       positions: { state: 'none', mode: 'matching' },
       orders: { state: 'none', mode: 'matching' },
+      strategies: { state: 'none', mode: 'matching' },
     };
   }
   if (selected === 'open_position_testnet') {
@@ -927,9 +1487,40 @@ function mergeStateConfig(defaults, params) {
     ...params,
     positions: mergeNested(defaults.positions, params.positions),
     orders: mergeNested(defaults.orders, params.orders),
+    strategies: mergeNested(defaults.strategies, params.strategies),
   };
 }
 
+export function applyTradingStatePolicy(config) {
+  const policy = config.trading_state;
+  if (policy === undefined) return config;
+  if (policy === 'preserve') {
+    return { ...config, positions: false, orders: false, strategies: false };
+  }
+  if (policy === 'clean_selected_testnet_market') {
+    if (!config.market && !config.symbol) {
+      throw new Error(
+        'metamask.perps.start_state trading_state=clean_selected_testnet_market requires market or symbol.',
+      );
+    }
+    const selectedMarketState = {
+      state: 'none',
+      mode: 'matching',
+    };
+    return String(config.network).toLowerCase() === 'testnet'
+      ? {
+          ...config,
+          positions: selectedMarketState,
+          orders: selectedMarketState,
+          strategies: selectedMarketState,
+        }
+      : { ...config, positions: false, orders: false, strategies: false };
+  }
+  throw new Error(
+    `metamask.perps.start_state received unsupported trading_state: ${String(policy)}`,
+  );
+}
+
 function mergeNested(defaultValue, overrideValue) {
   if (overrideValue === false) return false;
   if (overrideValue === undefined) return defaultValue;
@@ -939,34 +1530,66 @@ function mergeNested(defaultValue, overrideValue) {
   return overrideValue;
 }
 
+function resolveChildTimeoutMs(input, node, params) {
+  const deadline = Number(input.node?._action_deadline_epoch_ms);
+  const limits = [
+    Number(node.timeout_ms ?? params.timeout_ms),
+    Number(input.node?.timeout_ms),
+  ];
+  if (Number.isFinite(deadline)) {
+    limits.push(deadline - Date.now());
+  }
+  const finiteLimits = limits.filter(Number.isFinite);
+  return finiteLimits.length > 0
+    ? Math.max(1, Math.min(...finiteLimits))
+    : undefined;
+}
+
 function childInput(input, node) {
   const params = paramsForState(input);
+  const deadline = inheritedDeadline(input);
   return {
     ...input,
     node: {
       ...params,
       ...node,
+      ...(deadline === null ? {} : { _action_deadline_epoch_ms: deadline }),
       market: node.market ?? node.symbol ?? params.market ?? params.symbol,
       markets: node.markets ?? params.markets,
       symbols: node.symbols ?? params.symbols,
       side: node.side ?? params.side,
-      timeout_ms: node.timeout_ms ?? params.timeout_ms,
+      timeout_ms: resolveChildTimeoutMs(input, node, params),
     },
   };
 }
 
 async function applyOrdersState(input, config) {
-  if (config === false) return { skipped: true };
+  if (config === false || config === undefined) return { skipped: true };
   const node = config && typeof config === 'object' ? config : { state: String(config ?? 'none') };
   return ensureOrders(childInput(input, node));
 }
 
 async function applyPositionsState(input, config) {
-  if (config === false) return { skipped: true };
+  if (config === false || config === undefined) return { skipped: true };
   const node = config && typeof config === 'object' ? config : { state: String(config ?? 'none') };
   return ensurePositions(childInput(input, node));
 }
 
+async function applyStrategiesState(input, config) {
+  if (config === false || config === undefined) return { skipped: true };
+  const node =
+    config && typeof config === 'object'
+      ? config
+      : { state: String(config ?? 'none') };
+  const state = String(node.state ?? 'none').toLowerCase();
+  if (!['none', 'closed', 'absent'].includes(state)) {
+    throw new Error(
+      `metamask.perps.start_state received unsupported strategy state: ${state}`,
+    );
+  }
+  return closeStrategyOrders(childInput(input, node));
+}
+
 async function applyStateNavigation(input, config) {
   if (!config.page && !config.market && !config.symbol) return { skipped: true };
   const target = config.page ?? defaultNavigationTarget(config);
@@ -984,6 +1607,28 @@ async function readPerpsRuntimeState(input) {
   `);
 }
 
+async function assertRequestedRuntimeState(input, config) {
+  const state = await readPerpsRuntimeState(input);
+  if (
+    config.provider &&
+    String(state.activeProvider ?? '').toLowerCase() !==
+      String(config.provider).toLowerCase()
+  ) {
+    throw new Error(
+      `Refusing Perps teardown on provider ${state.activeProvider ?? 'unknown'}; expected ${config.provider}.`,
+    );
+  }
+  if (config.network) {
+    const expectedTestnet = String(config.network).toLowerCase() === 'testnet';
+    if (Boolean(state.isTestnet) !== expectedTestnet) {
+      throw new Error(
+        `Refusing Perps teardown on ${state.isTestnet ? 'testnet' : 'mainnet'}; expected ${config.network}.`,
+      );
+    }
+  }
+  return state;
+}
+
 async function ensureProvider(input, config) {
   if (!config.provider) return { skipped: true };
   const expected = String(config.provider).toLowerCase();
@@ -1018,12 +1663,12 @@ async function ensureNetwork(input, config) {
 }
 
 async function waitForNetworkState(input, expectedTestnet, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
+  const deadline = deadlineFromTimeout(input, timeoutMs);
   let last = await readPerpsRuntimeState(input);
   while (Date.now() < deadline) {
     last = await readPerpsRuntimeState(input);
     if (Boolean(last.isTestnet) === expectedTestnet) return last;
-    await sleep(500);
+    await sleepBeforeDeadline(deadline, 500);
   }
   return last;
 }
@@ -1078,11 +1723,18 @@ async function applyTutorialState(input, config) {
 
 export async function startState(input) {
   const params = paramsForState(input);
-  const config = mergeStateConfig(profileDefaults(params.profile), params);
+  const config = applyTradingStatePolicy(
+    mergeStateConfig(profileDefaults(params.profile), params),
+  );
   const timeoutMs = Math.max(1, Number(input.node?.timeout_ms ?? 30_000));
-  const deadline = Date.now() + timeoutMs;
+  const deadline = deadlineFromTimeout(input, timeoutMs);
   const stateInput = () => {
-    const remainingMs = Math.max(1, deadline - Date.now());
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new Error(
+        'metamask.perps.start_state timed out before completing all phases.',
+      );
+    }
     const configuredTargetMs = Number(input.node?.target_timeout_ms);
     const targetTimeoutMs = Math.min(
       remainingMs,
@@ -1101,6 +1753,7 @@ export async function startState(input) {
       ...input,
       node: {
         ...input.node,
+        _action_deadline_epoch_ms: deadline,
         timeout_ms: remainingMs,
         bridge_timeout_ms: remainingMs,
         cdp_timeout_ms: remainingMs,
@@ -1136,45 +1789,107 @@ export async function startState(input) {
   const navigation = await applyStateNavigation(stateInput(), config);
   const provider = await ensureProvider(stateInput(), config);
   const network = await ensureNetwork(stateInput(), config);
+  const resolvedNavigation = provider.changed || network.changed
+    ? await applyStateNavigation(stateInput(), config)
+    : navigation;
+  const modeInput = stateInput();
+  const marketMode = config.market_mode
+    ? await ensureMode({
+        ...modeInput,
+        action: 'metamask.perps.ensure_mode',
+        node: {
+          ...modeInput.node,
+          action: 'metamask.perps.ensure_mode',
+          mode: config.market_mode,
+        },
+      })
+    : { skipped: true };
   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);
   return {
     action: input.action,
-    profile: config.profile ?? params.profile ?? 'clean_market_testnet',
+    profile: config.profile ?? params.profile ?? null,
     phase: 'start_state',
     wallet,
     account,
     provider,
     network,
+    marketMode,
     tutorial,
     readyToTrade,
     balance,
-    market: config.market ?? config.symbol ?? null,
+    market:
+      config.market ??
+      config.symbol ??
+      resolvedNavigation.market ??
+      navigation.market ??
+      null,
+    tradingState: config.trading_state ?? null,
+    strategies,
     orders,
     positions,
-    navigation,
+    navigation: resolvedNavigation,
     proofPath: 'metamask-perps-start-state',
   };
 }
 
 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 params = paramsForState(input);
   const defaults = {
+    provider: 'hyperliquid',
+    network: 'testnet',
     page: 'home',
     positions: params.market || params.symbol || params.markets || params.symbols ? { state: 'none', mode: 'matching' } : false,
     orders: params.market || params.symbol || params.markets || params.symbols ? { state: 'none', mode: 'matching' } : false,
+    strategies: params.market || params.symbol || params.markets || params.symbols ? { state: 'none', mode: 'matching' } : false,
   };
   const config = mergeStateConfig(defaults, params);
-  const orders = await applyOrdersState(input, config.orders);
-  const positions = await applyPositionsState(input, config.positions);
-  const navigation = config.page === false ? { skipped: true } : await applyStateNavigation(input, config);
+  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 navigation =
+    config.page === false
+      ? { skipped: true }
+      : await applyStateNavigation(
+          stateInput('restoring the requested page'),
+          config,
+        );
   return {
     action: input.action,
     phase: 'teardown',
     market: config.market ?? config.symbol ?? null,
+    environment,
+    strategies,
     orders,
     positions,
     navigation,