@deeeed/metamask-harness 0.86.2 → 0.88.0

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

@@ -4,11 +4,13 @@ import { pathToFileURL } from 'node:url';
 import {
   MOBILE_BRIDGE_RESULT_ERROR_CODES,
   bridgeCommand,
+  createSetupBudget,
   deadlineFromTimeout,
   earliestDeadline,
   evalAsync,
   inheritedDeadline,
-  isTargetTransition,
+  isUnansweredRead,
+  mobileNavigationTimeoutMs,
   navigate,
   routeSatisfiesNavigationTarget,
   runAdapter,
@@ -25,6 +27,17 @@ import {
   requireHouseNotional,
   requirePerpsOrderAllowed,
 } from '../../shared/perps/order-policy.mjs';
+import {
+  dropMainnetOrder,
+  ledgerOrderTargets,
+  markMainnetOrderCancelled,
+  ownedMainnetOrder,
+  readMainnetOrderLedger,
+  recordPendingMainnetOrder,
+  recordPlacedMainnetOrder,
+  requireNoOpenMainnetOrders,
+} from '../../shared/perps/mainnet-order-ledger.mjs';
+import { isRateLimited, rateLimitedError, withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -169,7 +182,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;
   }
 }
@@ -237,6 +250,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,
   {
@@ -244,6 +259,8 @@ export async function retryPerpsClientRead(
     intervalMs = 500,
     sleep: wait = sleep,
     deadlineEpochMs,
+    call = 'PerpsController read',
+    random,
   } = {},
 ) {
   const localDeadline = Date.now() + Math.max(0, timeoutMs);
@@ -254,7 +271,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;
@@ -386,7 +403,7 @@ async function readPositions(input) {
       }
       return positions;
     },
-    { deadlineEpochMs: inheritedDeadline(input) },
+    { deadlineEpochMs: inheritedDeadline(input), call: 'PerpsController.getPositions' },
   );
 }
 
@@ -413,7 +430,7 @@ async function readOpenOrders(input) {
       }
       return orders;
     },
-    { deadlineEpochMs: inheritedDeadline(input) },
+    { deadlineEpochMs: inheritedDeadline(input), call: 'PerpsController.getOpenOrders' },
   );
 }
 
@@ -445,7 +462,7 @@ async function readStrategyOrders(input) {
       }
       return orders;
     },
-    { deadlineEpochMs: inheritedDeadline(input) },
+    { deadlineEpochMs: inheritedDeadline(input), call: 'PerpsController.getTwapOrders/getChaseOrders' },
   );
 }
 
@@ -903,7 +920,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;
   }
 }
@@ -961,8 +978,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}`;
@@ -1045,8 +1061,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),
@@ -1349,6 +1364,7 @@ export async function closeOrders(input) {
   if (invalid) {
     throw new Error(`Cannot cancel selected Perps order without orderId and symbol: ${JSON.stringify(invalid)}`);
   }
+  const owned = await mainnetOrdersOwned(input, orders);
   const result = await evalAsync(
     input,
     `(function(){
@@ -1380,10 +1396,105 @@ export async function closeOrders(input) {
   const after = await waitForOrdersAbsent(input, symbols, Number(input.node?.timeout_ms ?? 30000));
   const stillOpen = after.filter((order) => symbols.includes(symbolForItem(order)));
   if (stillOpen.length > 0) throw new Error(`Expected selected Perps orders to cancel, but ${stillOpen.length} are still open.`);
+  // The run's teardown settles them once the market's position is checked too.
+  // Only a cancel the controller accepted: anything else stays for the teardown to cancel.
+  for (const entry of owned ?? []) {
+    const canceled = (result?.results ?? []).filter((item) => item.orderId === entry.orderId && item.success);
+    if (canceled.length > 0) await markMainnetOrderCancelled(input.context.projectRoot, entry.id, { via: input.action, canceled });
+  }
   return { action: input.action, canceled: true, matchingCount: matching.length, symbols, result, proofPath: 'mobile-perps-controller-cancel-order' };
 }
 
-export async function placeOrder(input) {
+// The order book fields the mainnet order ledger matches on.
+const LEDGER_ORDER_FIELDS = {
+  idOf: orderIdForItem,
+  symbolOf: symbolForItem,
+  sideOf: sideForItem,
+  priceOf: (order) => order?.price ?? order?.limitPrice ?? order?.limitPx ?? order?.px,
+};
+
+// The signed size held in a market (0 when flat): a fill changes it.
+function positionSizeIn(positions, symbol) {
+  return positions
+    .filter((position) => symbolForItem(position) === symbol)
+    .reduce((total, position) => total + Number(position.size ?? position.szi ?? 0), 0);
+}
+
+// The run's forced cancel of one mainnet limit order it opened (see
+// mainnet-order-ledger.mjs), from the run's process: on the account that placed
+// it, still on mainnet, cancel it and read the book until it is gone. The read
+// also carries the market's position, which the caller compares with the one
+// before the order (a fill is reported, never closed here).
+export async function cancelMainnetLedgerOrder(entry, { projectRoot, env = {} }) {
+  const input = {
+    action: 'metamask.perps.close_orders',
+    node: { controller_ready_timeout_ms: 15_000 },
+    context: { nodeId: 'mainnet-order-cleanup', projectRoot, artifactsDir: entry.artifactsDir, env: { ...env, ...entry.connection } },
+  };
+  const bound = { address: entry.address, network: 'mainnet' };
+  // The placing provider too: another provider's book would read as empty.
+  const providerGuard = `if (String(Engine.context.PerpsController.state.activeProvider || '').toLowerCase() !== ${sourceLiteral(entry.provider)}) {
+      return Promise.resolve(JSON.stringify({ contextChanged: true }));
+    }`;
+  const readBook = async () => {
+    const book = await evalAsync(input, `(function(){ ${boundContextGuard(bound)} ${providerGuard}
+      var c = Engine.context.PerpsController;
+      return Promise.all([c.getOpenOrders(), c.getPositions()]).then(function(r){ return JSON.stringify({ orders: r[0], positions: r[1] }); }); })()`);
+    if (book?.contextChanged) {
+      throw new Error(`the app is not on mainnet ${entry.provider} with the placing account ${entry.address} selected`);
+    }
+    if (!Array.isArray(book?.orders) || !Array.isArray(book?.positions)) throw new Error('PerpsController returned a non-array book.');
+    return book;
+  };
+  const bookRead = (book, outcome) => ({
+    source: 'PerpsController.getOpenOrders+getPositions',
+    openOrderIds: book.orders.map(orderIdForItem).map(String),
+    positionSize: positionSizeIn(book.positions, entry.symbol),
+    ...outcome,
+  });
+  const before = await readBook();
+  const targets = ledgerOrderTargets(entry, before.orders, LEDGER_ORDER_FIELDS);
+  if (targets.length === 0) return { canceled: [], read: bookRead(before, { notOpen: true }) };
+  const orders = targets.map((order) => ({ orderId: String(orderIdForItem(order)), symbol: entry.symbol }));
+  const canceled = await evalAsync(input, `(function(){ ${boundContextGuard(bound)} ${providerGuard}
+    var c = Engine.context.PerpsController;
+    return Promise.all(${sourceLiteral(orders)}.map(function(o){
+      return c.cancelOrder(o).then(function(r){ return { orderId: o.orderId, success: !r || r.success !== false, result: r }; });
+    })).then(function(r){ return JSON.stringify(r); }); })()`);
+  if (canceled?.contextChanged) throw new Error(`the app left mainnet, ${entry.provider} or account ${entry.address} before the cancel`);
+  if (!Array.isArray(canceled) || canceled.some((item) => !item.success)) throw new Error(`cancelOrder failed: ${JSON.stringify(canceled)}`);
+  const deadline = Date.now() + 30_000;
+  for (;;) {
+    const after = await readBook();
+    const open = after.orders.filter((order) => orders.some((target) => String(orderIdForItem(order)) === target.orderId));
+    if (open.length === 0) return { canceled, read: bookRead(after, { absent: true }) };
+    if (Date.now() >= deadline) throw new Error(`order(s) ${open.map(orderIdForItem).join(', ')} still open 30 s after the cancel: ${JSON.stringify(canceled)}`);
+    await sleep(1000);
+  }
+}
+
+// On mainnet a cancel may only take orders this checkout's runs placed (the
+// mainnet order ledger); anything else is refused before dispatch. Returns the
+// ledger entries on mainnet, null on testnet.
+async function mainnetOrdersOwned(input, orders) {
+  const runtime = await readPerpsRuntimeState(input);
+  if (runtime?.isTestnet !== false) return null;
+  const owned = await Promise.all(orders.map((order) => ownedMainnetOrder(input.context?.projectRoot, order.orderId)));
+  const foreign = orders.filter((_order, index) => !owned[index]);
+  if (foreign.length > 0) {
+    throw Object.assign(
+      new Error(
+        `PERPS_MAINNET_ORDER_REFUSED: ${input.action} on mainnet cancels only orders this run placed; ` +
+          `${foreign.map((order) => `${order.symbol} ${order.orderId}`).join(', ')} ${foreign.length === 1 ? 'is' : 'are'} not. Refused before dispatch.`,
+      ),
+      { code: 'PERPS_MAINNET_ORDER_REFUSED' },
+    );
+  }
+  return owned;
+}
+
+// ensure: an ensure_* action opening state; it never leaves a mainnet limit order.
+export async function placeOrder(input, { ensure = false } = {}) {
   requirePlaceOrderInputs(input);
   const symbol = marketSymbol(input);
   const side = String(input.node.side).toLowerCase();
@@ -1403,17 +1514,27 @@ export async function placeOrder(input) {
     leverage,
     orderType,
     closeImmediately,
+    runCancelsLimit: !ensure,
     projectRoot: input.context?.projectRoot,
     selectedAddress: bound.address,
   });
+  const mainnetLimit = network === 'mainnet' && orderType === 'limit';
+  // A mainnet limit is also bound to the provider it is recorded under.
+  if (mainnetLimit) bound.provider = String(runtime?.activeProvider ?? '').toLowerCase();
   if ((closeImmediately || network === 'mainnet') && input.node?.size != null) {
     throw new Error('close_immediately and mainnet orders are sized from amount; drop size.');
   }
+  if (network === 'mainnet' && hasNodeValue(input, 'current_price', 'currentPrice')) {
+    throw new Error('Mainnet orders are bounded at the live market price; drop current_price.');
+  }
   if (closeImmediately) {
     const book = await readBoundBook(input, bound);
     assertFlatBeforeRoundTrip(book.positions, symbol, symbolForItem, book.orders);
   }
   const currentPrice = await currentPriceForOrder(input, symbol);
+  const limitPrice = orderType === 'limit'
+    ? resolveLimitPrice(input, isBuy, currentPrice)
+    : null;
   const houseNotional = requireHouseNotional({
     network,
     symbol,
@@ -1422,10 +1543,8 @@ export async function placeOrder(input) {
     price: currentPrice,
     szDecimals: network === 'mainnet' ? await readSizeDecimals(input, symbol) : null,
     maxSlippageBps,
+    limit: orderType === 'limit' ? { price: limitPrice, isBuy } : null,
   });
-  const limitPrice = orderType === 'limit'
-    ? resolveLimitPrice(input, isBuy, currentPrice)
-    : null;
   const size = String(
     input.node?.size
       ?? ((Number(amount) * leverage) / (limitPrice ?? currentPrice)),
@@ -1437,7 +1556,8 @@ export async function placeOrder(input) {
       orderType,
       size,
       price: String(limitPrice),
-      timeInForce: 'GTC',
+      // Post-only on mainnet: the venue rejects a limit that would fill now.
+      timeInForce: mainnetLimit ? 'ALO' : 'GTC',
       leverage,
       currentPrice,
       priceAtCalculation: currentPrice,
@@ -1457,6 +1577,21 @@ export async function placeOrder(input) {
   if (await tradingContextChanged(input, bound)) {
     throw new Error('Perps order not dispatched: the selected account or network changed after the order rule allowed it.');
   }
+  // Tracked before dispatch, so the run cancels it even if this action dies.
+  const baseline = mainnetLimit ? await readBoundBook(input, bound) : null;
+  const ledgerId = mainnetLimit
+    ? await recordPendingMainnetOrder(input.context.projectRoot, {
+      platform: 'mobile',
+      provider: bound.provider,
+      symbol,
+      side: isBuy ? 'long' : 'short',
+      limitPrice,
+      address: bound.address,
+      baselineOrderIds: baseline.orders.map(orderIdForItem).filter(Boolean),
+      artifactsDir: input.context.artifactsDir,
+      connection: input.context.env ?? {},
+    })
+    : null;
   let result;
   try {
     result = await evalAsync(input, `(function(){ ${boundContextGuard(bound)}
@@ -1468,18 +1603,31 @@ export async function placeOrder(input) {
       );
     }
     if (result?.success === false || result == null) {
-      throw new Error(`Failed to place ${symbol} ${side}: ${result?.error || JSON.stringify(result)}`);
+      const restNote = ledgerId ? "; the run's teardown cancels it if it rests" : '';
+      // 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${restNote}`,
+          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)}${restNote}`);
     }
     if (orderType === 'limit') {
       await waitForSelectedState(input, readOpenOrders, true, Number(input.node?.timeout_ms ?? 30000));
+      if (ledgerId) await recordPlacedMainnetOrder(input.context.projectRoot, ledgerId, await placedMainnetOrderId(input, bound, ledgerId, result));
     } else {
       await waitForPositionPresent(input, symbol, Number(input.node?.timeout_ms ?? 30000));
     }
   } catch (error) {
+    if (ledgerId && error?.knownNotDispatched) await dropMainnetOrder(input.context.projectRoot, ledgerId);
     if (!closeImmediately || error?.knownNotDispatched) throw error;
     throw await closeAfterFailedPlacement(input, symbol, error, bound);
   }
-  const placed = { action: input.action, market: symbol, side, orderType, amount, size, leverage, limitPrice, submitted: true, result, network, policy: policy.lane, ...(houseNotional ? { houseNotional } : {}), proofPath: 'mobile-perps-controller-place-order' };
+  const placed = { action: input.action, market: symbol, side, orderType, amount, size, leverage, limitPrice, submitted: true, result, network, policy: policy.lane, ...(policy.autoCancel ? { autoCancel: policy.autoCancel } : {}), ...(houseNotional ? { houseNotional } : {}), proofPath: 'mobile-perps-controller-place-order' };
   if (!closeImmediately) return placed;
   return { ...placed, roundTrip: await closeOpenedPosition(input, symbol, bound) };
 }
@@ -1509,6 +1657,18 @@ async function closeAfterFailedPlacement(input, symbol, error, bound) {
   return new Error(`${message} close_immediately: ${outcome}.`);
 }
 
+// The venue ID of the mainnet limit order just placed: the controller's answer,
+// else the one new order in its market and side since the pending entry.
+async function placedMainnetOrderId(input, bound, ledgerId, result) {
+  if (result?.orderId != null && String(result.orderId) !== '') return String(result.orderId);
+  const entry = (await readMainnetOrderLedger(input.context.projectRoot)).entries.find((candidate) => candidate.id === ledgerId);
+  const targets = ledgerOrderTargets(entry, (await readBoundBook(input, bound)).orders, LEDGER_ORDER_FIELDS);
+  if (targets.length !== 1) {
+    throw new Error(`Mainnet ${entry.symbol} limit order placed but its ID is unknown (${targets.length} new orders match); the run's teardown cancels it.`);
+  }
+  return String(orderIdForItem(targets[0]));
+}
+
 async function readSizeDecimals(input, symbol) {
   const markets = await evalAsync(
     input,
@@ -1540,7 +1700,9 @@ function boundContextGuard(bound) {
   return `var __account = Engine.context.AccountsController.getSelectedAccount();
     var __address = String((__account && __account.address) || '').toLowerCase();
     var __network = Engine.context.PerpsController.state.isTestnet ? 'testnet' : 'mainnet';
-    if (__address !== ${sourceLiteral(bound.address)} || __network !== ${sourceLiteral(bound.network)}) {
+    var __provider = String(Engine.context.PerpsController.state.activeProvider || '').toLowerCase();
+    if (__address !== ${sourceLiteral(bound.address)} || __network !== ${sourceLiteral(bound.network)}
+      || (${sourceLiteral(bound.provider ?? null)} !== null && __provider !== ${sourceLiteral(bound.provider ?? null)})) {
       return Promise.resolve(JSON.stringify({ success: false, contextChanged: true }));
     }`;
 }
@@ -1639,7 +1801,7 @@ export async function ensurePositions(input) {
   }
   if (state === 'open' || state === 'present') {
     const existing = await readPositions(input);
-    if (selectedItems(input, existing).length === 0) await placeOrder(input);
+    if (selectedItems(input, existing).length === 0) await placeOrder(input, { ensure: true });
     return assertPositions(input, true);
   }
   throw new Error(`metamask.perps.ensure_positions received unsupported state: ${state}`);
@@ -1657,7 +1819,7 @@ export async function ensureOrders(input) {
     const current = await readOpenOrders(input);
     let order = null;
     if (selectedItems(input, current).length === 0) {
-      order = await placeOrder({ ...input, node: { ...input.node, order_type: 'limit' } });
+      order = await placeOrder({ ...input, node: { ...input.node, order_type: 'limit' } }, { ensure: true });
     }
     return { ...(await assertOrders(input, true)), order };
   }
@@ -1732,9 +1894,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 };
   }
@@ -1895,6 +2068,7 @@ async function ensureNetwork(input, config) {
   if (Boolean(before.isTestnet) === expectedTestnet) {
     return { requested: config.network, isTestnet: before.isTestnet, changed: false };
   }
+  if (expectedTestnet) await requireNoOpenMainnetOrders(input.context?.projectRoot, input.action);
   const result = await evalAsync(input, 'Engine.context.PerpsController.toggleTestnet().then(function(r){return JSON.stringify(r)})');
   const after = await waitForNetworkState(input, expectedTestnet, Number(input.node?.timeout_ms ?? 30000));
   if (Boolean(after.isTestnet) !== expectedTestnet) {
@@ -1969,16 +2143,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,
@@ -1993,75 +2166,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,
@@ -2090,16 +2266,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',
@@ -2110,28 +2277,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,

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

@@ -1,10 +1,13 @@
-// Submit a Perps order through the Mobile controller and assert a matching open position.
-// With close_immediately the order's position is already closed again, so the market must be flat.
+// Submit a Perps order through the Mobile controller and assert the resulting
+// order (limit) or position (market). With close_immediately the order's
+// position is already closed again, so the market must be flat.
 import { runAdapter } from '../platform/bridge.mjs';
 import { closeImmediatelyRequested } from '../../shared/perps/order-policy.mjs';
-import { assertPositions, placeOrder } from './perps.mjs';
+import { assertOrders, assertPositions, placeOrder } from './perps.mjs';
 runAdapter(async (input) => {
   const order = await placeOrder(input);
-  const assertion = await assertPositions(input, !closeImmediatelyRequested(input.node));
+  const assertion = order.orderType === 'limit'
+    ? await assertOrders(input, true)
+    : await assertPositions(input, !closeImmediatelyRequested(input.node));
   return { ...assertion, submitted: order.submitted === true, order };
 });