@deeeed/metamask-harness 0.86.1 → 0.86.2

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.86.2 - 2026-10-09
+
+### Fixed
+
+- Extension `metamask.perps.place_order` through the background Perps request accepts the venue's lot-rounded market fill. The controller sizes a USD order to the market's size step, so $12 of SOL at 109.94 fills 0.11 SOL with $12.09 margin. The observer required the margin within $0.01 of $12 and left every such placement `outcome-unknown`. It now reads the market's size decimals before dispatch and computes the lot the controller fills. The position size must equal the venue-reported filled size (or be within one step of the computed lot when the controller reports none, and never off the step grid), and the margin must be within one size step at the current price plus `identity_rounding_tolerance_base_units`. A reported fill more than one step from the computed lot fails. The lot is stored in the receipt (`facts.marketLot`), so a resume checks against it, not against a lot recomputed at a moved price. A lot whose notional exceeds the trusted operation cap is refused before the receipt. A filled position whose exposure (margin × leverage) exceeds the cap leaves the outcome unknown. Market, side and leverage still match exactly, and mainnet limits are unchanged. With no known size step the exact-cent check stays, and the size must equal a reported fill.
+- Background market placements now record the venue's filled order (`acceptance.source: "background-perpsPlaceOrder"`, with `venueOrderId`, `filledSize` and `averagePrice` from `perpsPlaceOrder`) and the pre-order balance (`facts.balanceBeforeBaseUnits`). Before, the receipt had neither, so `metamask.perps.close_visible_position` refused cleanup with "Position cleanup requires the exact accepted venue order ID", even after a successful placement. Cleanup still proves the position from that order's own fills.
+
+### Changed
+
+- Extension `metamask.perps.close_visible_position cleanup_only=true` now takes the released amount from the position's margin (`marginUsed`, already read from the position detail), not from the close modal text. It records the amount in the receipt as `closeReleaseBaseUnits` with `closeReleaseSource: "position-margin"`. Unrealized PnL is not added, because the available balance (Hyperliquid `withdrawable`) already includes it. The modal's "You'll receive" amount (`marginUsed` minus fees) is now a cross-check, recorded as `closeModalReceiveBaseUnits`. If it differs from the margin by more than the reconciliation tolerance, the action refuses before publishing a receipt or clicking. If the modal amount cannot be read, the action no longer refuses; it reconciles on the margin. The $1 tolerance is unchanged.
+
+### Fixed
+
+- Mobile route waits (`navigate` and `waitForRoute` in the action library) now end at the calling action's deadline. Before, once a Perps `start_state` or `teardown_state` ran out of budget, the bridge refused each new `get-route` with `CDP_TIMEOUT`. The waits took that refusal for a target transition and kept polling for up to 30 s more on their own 15 s windows. They could not see a route that did arrive, and failed with "did not start before its action deadline: get-route". On a physical Pixel 6a this showed up as `CDP_TIMEOUT` in clean-market setup and teardown, while one `get-route` took 0.1 to 0.5 s. Both now stop at the deadline. A route that never matched fails with the expected route, the last route read and the limit applied; a recovery cut short by the deadline fails with its last bridge error.
+
 ## 0.86.1 - 2026-10-09
 
 ### Fixed

package/library/actions/extension/perps/close_visible_position.mjs

@@ -421,10 +421,13 @@ export async function closeVisiblePosition(input) {
   if (partialAmount == null && (!confirmation.fullSizeSelected || !confirmation.marketOrder)) {
     throw new Error('Receipt-bound full close requires the visible 100% market-close form.');
   }
-  // Without a placement receipt the baseline is the in-position balance, which excludes the released margin.
-  const closeReleaseBaseUnits = placement ? null : parseUsdBaseUnits(confirmation.receive);
-  if (!placement && closeReleaseBaseUnits == null) {
-    throw new Error('Close without a placement receipt requires the visible close receive amount.');
+  // Without a placement receipt the baseline is the in-position balance, which excludes the position's
+  // margin. The close returns marginUsed (PnL is already in the balance); the modal receive cross-checks it.
+  const closeReleaseBaseUnits = placement ? null : exactBefore.marginBaseUnits;
+  const closeModalReceiveBaseUnits = placement ? null : parseUsdBaseUnits(confirmation.receive);
+  if (closeModalReceiveBaseUnits != null
+    && BigInt(absoluteDelta(closeModalReceiveBaseUnits, closeReleaseBaseUnits)) > BigInt(balanceToleranceBaseUnits)) {
+    throw new Error('Visible close receive amount disagrees with the position margin beyond the reconciliation tolerance.');
   }
   const closeSizing = partialAmount == null ? { size: sizeMatch[1], side: fundingSide === 'long' ? 'short' : 'long' } : null;
   let submissionObserver = null;
@@ -440,7 +443,8 @@ export async function closeVisiblePosition(input) {
       cleanupOnly,
       fundingBalance,
       tradingContext,
-      ...(closeReleaseBaseUnits != null ? { closeReleaseBaseUnits } : {}),
+      ...(closeReleaseBaseUnits != null ? { closeReleaseBaseUnits, closeReleaseSource: 'position-margin' } : {}),
+      ...(closeModalReceiveBaseUnits != null ? { closeModalReceiveBaseUnits } : {}),
       ...(acceptedFill ? { acceptedFill } : {}),
       ...(closeSizing ? { closeSizing } : {}),
     },

package/library/actions/extension/perps/mutation-receipt.mjs

@@ -831,8 +831,27 @@ export async function recordExternalMutationCleanupCandidate(input, receipt, can
   });
 }
 
+// A market order placed through the background Perps request reports the venue's
+// filled order itself; there is no observed network request to bind.
+export const BACKGROUND_ACCEPTANCE_SOURCE = 'background-perpsPlaceOrder';
+
+function validFilledOrder(filledSize, averagePrice) {
+  return /^(?:0|[1-9][0-9]{0,19})(?:\.[0-9]{1,8})?$/u.test(String(filledSize)) && Number(filledSize) > 0
+    && /^(?:0|[1-9][0-9]{0,19})(?:\.[0-9]{1,18})?$/u.test(String(averagePrice)) && Number(averagePrice) > 0;
+}
+
 async function recordSubmissionAcceptance(input, receipt, acceptance) {
   const { venueOrderId, status, requestId, serviceWorkerTargetId, asset, size, limitPriceBaseUnits, filledSize, averagePrice } = acceptance;
+  if (acceptance.source === BACKGROUND_ACCEPTANCE_SOURCE) {
+    if (receipt.record.identity.operation !== 'perps-market-order' || receipt.record.identity.provider !== 'hyperliquid'
+      || !/^[1-9][0-9]{0,19}$/u.test(String(venueOrderId)) || status !== 'filled' || size !== filledSize
+      || !validFilledOrder(filledSize, averagePrice)) {
+      throw recoveryError(receipt, 'background market acceptance has invalid filled order identity');
+    }
+    return writeSubmissionAcceptance(input, receipt, {
+      source: BACKGROUND_ACCEPTANCE_SOURCE, venueOrderId, status, size, filledSize, averagePrice,
+    });
+  }
   const closing = receipt.record.identity.operation === 'perps-close-position';
   const market = closing || receipt.record.identity.operation === 'perps-market-order';
   const sizing = closing ? receipt.record.facts?.closeSizing
@@ -849,20 +868,22 @@ async function recordSubmissionAcceptance(input, receipt, acceptance) {
     || !BASE_UNITS.test(String(limitPriceBaseUnits))) {
     throw recoveryError(receipt, 'submission acceptance has invalid order identity');
   }
-  if (market && status === 'filled' && (!/^(?:0|[1-9][0-9]{0,19})(?:\.[0-9]{1,8})?$/u.test(String(filledSize))
-    || !(Number(filledSize) > 0) || Number(filledSize) > Number(size)
-    || !/^(?:0|[1-9][0-9]{0,19})(?:\.[0-9]{1,18})?$/u.test(String(averagePrice)) || !(Number(averagePrice) > 0))) {
+  if (market && status === 'filled' && (!validFilledOrder(filledSize, averagePrice) || Number(filledSize) > Number(size))) {
     throw recoveryError(receipt, 'market acceptance has invalid filled size or price');
   }
+  return writeSubmissionAcceptance(input, receipt, {
+    venueOrderId, status, requestId, serviceWorkerTargetId, asset, size, limitPriceBaseUnits,
+    ...(market && status === 'filled' ? { filledSize, averagePrice } : {}),
+  });
+}
+
+async function writeSubmissionAcceptance(input, receipt, acceptance) {
   const destination = await receiptDestination(input);
   const current = await readPublished(destination);
   if (!current || current.sha256 !== receipt.sha256 || current.record?.state !== 'outcome-unknown') {
     throw recoveryError(receipt, 'the receipt changed before submission acceptance was recorded');
   }
-  const record = { ...current.record, acceptance: {
-    venueOrderId, status, requestId, serviceWorkerTargetId, asset, size, limitPriceBaseUnits,
-    ...(market && status === 'filled' ? { filledSize, averagePrice } : {}),
-  } };
+  const record = { ...current.record, acceptance };
   const staged = await stagedRecord(destination.directory, record);
   try {
     await rename(staged.stagedPath, destination.absolute);

package/library/actions/extension/perps/perps.mjs

@@ -8,6 +8,7 @@ import path from 'node:path';
 import { dataTestId, marketSymbol, normalizeMarketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
   assertTrustedExternalMutationTarget,
+  BACKGROUND_ACCEPTANCE_SOURCE,
   externalMutationNotDispatched,
   readExternalMutationReceipt,
   readPriorMutationReceipt,
@@ -27,6 +28,7 @@ import {
   assertFlatBeforeRoundTrip,
   assertHouseLimitPosition,
   closeImmediatelyRequested,
+  marketOrderLot,
   requireHouseNotional,
 } from '../../shared/perps/order-policy.mjs';
 import {
@@ -780,8 +782,33 @@ function backgroundPositionObservation(position) {
   return { market, side, leverage, size: String(position?.size ?? position?.szi), marginBaseUnits };
 }
 
-async function observeBackgroundPlace(page, expected, baselineIds, timeoutMs) {
+// Whole size steps in a size, or null when it is off the step grid.
+function sizeLots(size, sizeDecimals) {
+  const scaled = Math.abs(Number(size)) * 10 ** sizeDecimals;
+  const lots = Math.round(scaled);
+  return Number.isSafeInteger(lots) && lots > 0 && Math.abs(scaled - lots) < 1e-6 ? lots : null;
+}
+
+async function observeBackgroundPlace(page, expected, baselineIds, timeoutMs, acceptance) {
   const deadline = Date.now() + timeoutMs;
+  const lot = expected.orderType === 'market' ? expected.marketLot : null;
+  // A venue-reported fill fixes the exact size; without one the size may be a step
+  // off the lot computed here, since the controller sizes at its own fresh price.
+  const acceptedLots = lot && acceptance?.source === BACKGROUND_ACCEPTANCE_SOURCE
+    ? sizeLots(acceptance.filledSize, lot.sizeDecimals) : null;
+  if (lot && acceptance?.source === BACKGROUND_ACCEPTANCE_SOURCE
+    && (acceptedLots == null || Math.abs(acceptedLots - lot.lots) > 1)) {
+    throw new Error('Background Perps market fill size is not within one size step of the requested amount.');
+  }
+  const marginToleranceBaseUnits = lot
+    ? `${BigInt(expected.roundingToleranceBaseUnits) + BigInt(lot.stepMarginBaseUnits)}`
+    : expected.roundingToleranceBaseUnits;
+  const reported = acceptance?.source === BACKGROUND_ACCEPTANCE_SOURCE;
+  const sizeMatches = (size) => {
+    if (!lot) return !reported || Math.abs(Number(size)) === Number(acceptance.filledSize);
+    const observed = sizeLots(size, lot.sizeDecimals);
+    return observed != null && (acceptedLots != null ? observed === acceptedLots : Math.abs(observed - lot.lots) <= 1);
+  };
   while (Date.now() <= deadline) {
     if (expected.orderType === 'limit') {
       const matches = (await readOpenOrders(page))
@@ -798,12 +825,20 @@ async function observeBackgroundPlace(page, expected, baselineIds, timeoutMs) {
           && position.market === expected.market
           && position.side === expected.side
           && position.leverage === expected.leverage
+          && sizeMatches(position.size)
           && withinBaseUnitTolerance(
             position.marginBaseUnits,
             expected.amountBaseUnits,
-            expected.roundingToleranceBaseUnits,
+            marginToleranceBaseUnits,
           ));
-      if (matches.length === 1) return { success: true, position: matches[0] };
+      if (matches.length === 1) {
+        // The step tolerance widens the identity match, never the exposure the run allowed.
+        if (expected.maximumNotionalBaseUnits != null
+          && BigInt(matches[0].marginBaseUnits) * BigInt(matches[0].leverage) > BigInt(expected.maximumNotionalBaseUnits)) {
+          throw new Error('Background Perps position exposure exceeds the runner-trusted operation cap.');
+        }
+        return { success: true, position: matches[0] };
+      }
       if (matches.length > 1) throw new Error('Background position postcondition matched more than one position.');
     }
     await sleep(250);
@@ -870,7 +905,12 @@ async function dispatchBackgroundPlace(page, {
     };
     const result = await request('perpsPlaceOrder', [orderParams]);
     if (!result || result.success !== true) throw new Error(result?.error || 'perpsPlaceOrder failed.');
-    return { success: true };
+    return {
+      success: true,
+      orderId: result.orderId == null ? null : String(result.orderId),
+      filledSize: result.filledSize == null ? null : String(result.filledSize),
+      averagePrice: result.averagePrice == null ? null : String(result.averagePrice),
+    };
   })()`, { awaitPromise: true });
 }
 
@@ -1246,10 +1286,23 @@ async function placeOrderThroughBackground(input, page, {
       }
     }
   }
+  if (!existing && expected.marketLot
+    && BigInt(expected.marketLot.notionalBaseUnits) > BigInt(expected.maximumNotionalBaseUnits)) {
+    throw new Error('Rounded Perps market lot exceeds the runner-trusted operation cap.');
+  }
+  // A resume checks the fill against the lot sized at publication, not one
+  // recomputed at a price that has since moved.
+  const marketLot = existing?.record?.facts?.marketLot ?? expected.marketLot ?? null;
   const mutation = await runGuardedExternalMutation({
     input,
     identity,
-    publicationFacts: { baselineOrderIds: [...baselineIds], fundingBalance },
+    // The pre-order balance lets a receipt-bound close reconcile its final balance.
+    publicationFacts: {
+      balanceBeforeBaseUnits: fundingBalance.observedBaseUnits,
+      baselineOrderIds: [...baselineIds],
+      fundingBalance,
+      ...(expected.marketLot ? { marketLot: expected.marketLot } : {}),
+    },
     dispatch: async () => {
       try {
         await requireCurrentVisibleFundingBalance(
@@ -1278,13 +1331,26 @@ async function placeOrderThroughBackground(input, page, {
       if (accepted?.changed) {
         throw externalMutationNotDispatched('the selected account or Perps network changed after the order rule allowed it');
       }
+      // The venue's filled order ID goes into the receipt, so cleanup can prove the
+      // position is this order's own.
+      if (orderType === 'market' && accepted?.orderId != null && accepted.filledSize != null && accepted.averagePrice != null) {
+        return {
+          source: BACKGROUND_ACCEPTANCE_SOURCE,
+          venueOrderId: accepted.orderId,
+          status: 'filled',
+          size: accepted.filledSize,
+          filledSize: accepted.filledSize,
+          averagePrice: accepted.averagePrice,
+        };
+      }
       return accepted;
     },
-    observe: async () => observeBackgroundPlace(
+    observe: async ({ receipt }) => observeBackgroundPlace(
       page,
-      expected,
+      { ...expected, marketLot },
       baselineIds,
       Number(input.node?.timeout_ms ?? 30_000),
+      receipt?.acceptance,
     ),
   });
   return {
@@ -1676,8 +1742,9 @@ export async function placeOrder(input) {
         const slippage = Number(input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300) / 10_000;
         const margin = Number(amount);
         if (szDecimals == null) throw new Error(`close_immediately cannot read the ${symbol} size decimals; not dispatched.`);
-        const tolerance = Math.ceil(((10 ** -Number(szDecimals)) * Number(price) / leverage + margin * slippage) * 1_000_000) + 10_000;
-        if (!Number.isInteger(Number(szDecimals)) || !Number.isFinite(tolerance) || tolerance > 1_000_000) {
+        const lot = marketOrderLot({ amount, leverage, price, szDecimals });
+        const tolerance = lot ? Number(lot.stepMarginBaseUnits) + Math.ceil(margin * slippage * 1_000_000) + 10_000 : Number.NaN;
+        if (!Number.isFinite(tolerance) || tolerance > 1_000_000) {
           throw new Error(`close_immediately cannot prove a ${symbol} fill within $1 (size step or slippage too coarse); pass identity_rounding_tolerance_base_units or choose another market.`);
         }
         // The receipt identity must not move with the price, so a resume finds it:
@@ -1743,15 +1810,18 @@ export async function placeOrder(input) {
         symbol,
         input.node?.current_price ?? input.node?.currentPrice,
       );
+      const szDecimals = lane.network === 'mainnet' || orderType === 'market'
+        ? await readSizeDecimals(page, symbol) : null;
       houseNotional = requireHouseNotional({
         network: lane.network,
         symbol,
         amount,
         leverage,
         price: resolvedPrice,
-        szDecimals: lane.network === 'mainnet' ? await readSizeDecimals(page, symbol) : null,
+        szDecimals,
         maxSlippageBps: Number(input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300),
       });
+      const marketLot = orderType === 'market' ? marketOrderLot({ amount, leverage, price: resolvedPrice, szDecimals }) : null;
       const backgroundLimitPrice = orderType === 'limit'
         ? resolveLimitPrice(input, isBuy, resolvedPrice)
         : null;
@@ -1764,6 +1834,7 @@ export async function placeOrder(input) {
         expected: {
           ...expectedVisibleIdentity,
           limitPriceBaseUnits: backgroundLimitPrice == null ? null : parseUsdBaseUnits(backgroundLimitPrice),
+          ...(marketLot ? { marketLot } : {}),
         },
         identity,
         isBuy,

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

@@ -4,7 +4,10 @@ import { pathToFileURL } from 'node:url';
 import {
   MOBILE_BRIDGE_RESULT_ERROR_CODES,
   bridgeCommand,
+  deadlineFromTimeout,
+  earliestDeadline,
   evalAsync,
+  inheritedDeadline,
   isTargetTransition,
   navigate,
   routeSatisfiesNavigationTarget,
@@ -94,23 +97,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;

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

@@ -663,6 +663,24 @@ function routeTransitionProven(previousRoute, currentRoute, expectedRoute, expec
   );
 }
 
+export function inheritedDeadline(input) {
+  const deadline = Number(input.node?.[ACTION_DEADLINE_FIELD]);
+  return Number.isFinite(deadline) ? deadline : null;
+}
+
+export function earliestDeadline(input, deadline) {
+  const inherited = inheritedDeadline(input);
+  return inherited === null ? deadline : Math.min(deadline, inherited);
+}
+
+// The earlier of now + timeoutMs and the calling action's deadline. Route waits
+// use it because past the action deadline bridgeCommand refuses to start
+// get-route (CDP_TIMEOUT): polling on would only retry that refusal and could
+// never see a route that did arrive.
+export function deadlineFromTimeout(input, timeoutMs) {
+  return earliestDeadline(input, Date.now() + Math.max(0, Number(timeoutMs)));
+}
+
 async function waitForNextRouteProbe(deadline) {
   const remaining = deadline - Date.now();
   if (remaining > 0) await sleep(Math.min(250, remaining));
@@ -712,7 +730,7 @@ export async function navigate(input, route, params = {}, expectedRoute) {
 
   while (navigateAttempts < 2 || recoveryPending) {
     if (recoveryPending) {
-      const deadline = recoveryDeadline ?? Date.now() + timeoutMs;
+      const deadline = recoveryDeadline ?? deadlineFromTimeout(input, timeoutMs);
       let currentRoute = null;
       while (Date.now() < deadline) {
         try {
@@ -798,7 +816,7 @@ export async function navigate(input, route, params = {}, expectedRoute) {
       if (!isTargetTransition(error)) throw error;
       lastTransitionError = error;
       transitionCodes.push(error.code);
-      recoveryDeadline = Date.now() + timeoutMs;
+      recoveryDeadline = deadlineFromTimeout(input, timeoutMs);
       recoveryPending = true;
       await waitForNextRouteProbe(recoveryDeadline);
     }
@@ -820,7 +838,8 @@ export async function waitForRoute(
   expectedParams,
 ) {
   const expected = String(expectedRoute);
-  const deadline = Date.now() + timeoutMs;
+  const startedAt = Date.now();
+  const deadline = deadlineFromTimeout(input, timeoutMs);
   // lastRoute is null when bridgeCommand returns null (transient: route not yet
   // settled mid-navigation). Null means "not ready yet" — keep polling.
   let lastRoute = null;
@@ -857,7 +876,7 @@ export async function waitForRoute(
     ? 'empty/undefined (route transiently unavailable — bridge not yet settled)'
     : JSON.stringify(lastRoute);
   const timeoutError = new Error(
-    `Timed out waiting for Mobile route '${expected}' after ${timeoutMs}ms (${pollCount} polls).\n` +
+    `Timed out waiting for Mobile route '${expected}' after ${Date.now() - startedAt}ms (${pollCount} polls; limit ${deadline - startedAt}ms of ${timeoutMs}ms requested).\n` +
     `  Expected route: ${expected}\n` +
     `  Expected params: ${expectedParams === undefined ? 'any' : JSON.stringify(expectedParams)}\n` +
     `  Last parsed route: ${JSON.stringify(lastRoute)}\n` +

package/library/actions/shared/perps/order-policy.mjs

@@ -123,6 +123,25 @@ export function worstCaseNotionalUsd({ amount, leverage, price, szDecimals, maxS
   return (usd + step * Number(price)) * (1 + Number(maxSlippageBps) / 10_000);
 }
 
+// The lot the controller submits for a market order of `amount` USDC margin (the
+// same rounding as above), in whole size steps, its notional, and the margin one
+// step adds at `price`. Null when the size decimals or price are unknown.
+export function marketOrderLot({ amount, leverage, price, szDecimals }) {
+  const decimals = szDecimals == null || szDecimals === '' ? Number.NaN : Number(szDecimals);
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 8 || !(Number(price) > 0)) return null;
+  const multiplier = 10 ** decimals;
+  const usd = Number(amount) * Number(leverage);
+  let lots = Math.round((usd / Number(price)) * multiplier);
+  if ((lots / multiplier) * Number(price) < usd) lots += 1;
+  if (!Number.isSafeInteger(lots) || lots <= 0) return null;
+  return {
+    sizeDecimals: decimals,
+    lots,
+    notionalBaseUnits: `${Math.ceil((lots / multiplier) * Number(price) * 1_000_000)}`,
+    stepMarginBaseUnits: `${Math.ceil((Number(price) / multiplier / Number(leverage)) * 1_000_000)}`,
+  };
+}
+
 // Mainnet only: refuse before dispatch when the size the controller would submit
 // could fill above the house notional limit. Testnet needs no bound.
 export function requireHouseNotional({ network, symbol, amount, leverage, price, szDecimals, maxSlippageBps }) {

package/library/manifests/extension.action-manifest.json

@@ -4465,7 +4465,7 @@
           "identity_rounding_tolerance_base_units": {
             "type": "string",
             "default": "10000",
-            "description": "Maximum visible amount/price rounding delta in six-decimal USDC base units; default 10000 and capped at 1000000."
+            "description": "Maximum visible amount/price rounding delta in six-decimal USDC base units; default 10000 and capped at 1000000. A background market order's margin check adds one venue size step at the current price."
           }
         },
         "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.86.1",
+  "version": "0.86.2",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"