@deeeed/metamask-harness 0.23.1 → 0.24.0

package/library/actions/core/perps/edit_order.mjs

@@ -0,0 +1,331 @@
+import {
+  configuredSymbols,
+  controllerRejection,
+  currentMarketPrice,
+  getCoreControllerWithSigner,
+  isDirectRun,
+  optionalBooleanParam,
+  optionalParam,
+  redactOrder,
+  requireExplicitSelection,
+  runAdapter,
+  selectedItems,
+  symbolForItem,
+} from './_controller.mjs';
+
+// core Modify a RESTING Perps open order by driving the headless
+// PerpsController.editOrder() through the full signing/provider path.
+//
+// HyperLiquid's `modify` rebuilds the order as a plain limit/market order, so a
+// trigger on either side of the edit would be silently dropped: editing a
+// resting stop into a plain order removes the protection while reporting
+// success. The controller therefore refuses both directions, and refuses
+// outright when it cannot establish what the resting order is. Those refusals
+// are the interesting half of this action's contract — pair it with
+// `expect_error` to prove them.
+//
+// The order to edit is selected by `order_id` (preferred) or, when the market
+// holds exactly one open order, by `market` alone. `new_order` fields use the
+// controller's own provider-agnostic names, so a recipe reads the same way as
+// place_order: side, size, price, order_type, time_in_force, reduce_only.
+
+/**
+ * Resolve the new limit price, absolute or offset from live mid.
+ *
+ * Mirrors place_order's precedence so a recipe reads the same either way: an
+ * explicit `price` wins, otherwise `offset_pct` is applied to mid. Returns
+ * undefined when neither is given, which is correct for a market order.
+ *
+ * @param input - Adapter input (node.price / node.offset_pct).
+ * @param controller - Headless perps controller, used to read live mid.
+ * @param symbol - Market the order belongs to.
+ * @returns The price as a string, or undefined when the node sets none.
+ */
+async function resolvePrice(input, controller, symbol) {
+  const node = input.node ?? {};
+  const absolute = optionalParam(node, 'price', 'price');
+  if (absolute !== undefined && absolute.length > 0) {
+    return absolute;
+  }
+
+  const rawOffset = optionalParam(node, 'offset_pct', 'offsetPct');
+  if (rawOffset === undefined) {
+    return undefined;
+  }
+
+  const offsetPct = Number(rawOffset);
+  if (!Number.isFinite(offsetPct)) {
+    throw new Error(
+      `metamask.perps.edit_order received invalid offset_pct: ${rawOffset}.`,
+    );
+  }
+
+  const mid = await currentMarketPrice(controller, symbol);
+  const price = mid * (1 + offsetPct / 100);
+  if (!Number.isFinite(price) || price <= 0) {
+    throw new Error(
+      `metamask.perps.edit_order computed a non-positive price (${price}) from offset_pct=${offsetPct}.`,
+    );
+  }
+  return String(price);
+}
+
+/**
+ * Resolve the resting order this node edits.
+ *
+ * @param input - Adapter input carrying order_id and/or market selection.
+ * @param openOrders - Live open orders for the account.
+ * @returns The single matching order.
+ */
+export function resolveTargetOrder(input, openOrders, symbol) {
+  const node = input.node ?? {};
+  const orderId = optionalParam(node, 'order_id', 'orderId');
+  const selected = openOrders.filter((order) => symbolForItem(order) === symbol);
+
+  // An explicit id is what the caller asked to edit, so it is authoritative
+  // whatever the account currently holds — the controller is the thing entitled
+  // to decide that an order cannot be verified. The lookup is therefore
+  // non-throwing and only enriches the evidence; it must never gate the request,
+  // or what gets submitted would depend on local state.
+  if (orderId !== undefined) {
+    return {
+      orderId,
+      order:
+        selected.find(
+          (order) => String(order.orderId ?? order.oid) === orderId,
+        ) ?? null,
+    };
+  }
+
+  if (selected.length !== 1) {
+    throw new Error(
+      `metamask.perps.edit_order requires order_id when the selection does not resolve to exactly one open order; got ${selected.length}.`,
+    );
+  }
+  return {
+    orderId: String(selected[0].orderId ?? selected[0].oid),
+    order: selected[0],
+  };
+}
+
+// The controller normalizes side to 'buy' | 'sell' (Order.side); there is no
+// isBuy field and never a raw 'B'. Exported so the vocabulary is pinned by a
+// test: comparing against the venue's form instead matched nothing at all, and
+// a matcher that matches nothing makes a "stricter" check prove less than the
+// loose one it replaced.
+export function isLongOrder(order) {
+  if (order.isBuy !== undefined) return Boolean(order.isBuy);
+  const raw = order.side ?? order.dir;
+  if (raw === undefined) return undefined;
+  const value = String(raw).toLowerCase();
+  if (value === 'buy' || value === 'b' || value.includes('long')) return true;
+  if (value === 'sell' || value === 'a' || value.includes('short')) return false;
+  return undefined;
+}
+
+export async function editOrder(input) {
+  requireExplicitSelection(input);
+  const symbols = configuredSymbols(input, []);
+  if (symbols.length !== 1) {
+    throw new Error(
+      `metamask.perps.edit_order requires exactly one market; got ${JSON.stringify(symbols)}.`,
+    );
+  }
+  const symbol = symbols[0];
+
+  const node = input.node ?? {};
+  const requestedSize = optionalParam(node, 'size', 'size');
+  const side = optionalParam(node, 'side', 'side')?.toLowerCase();
+  if (side !== 'long' && side !== 'short') {
+    throw new Error(
+      'metamask.perps.edit_order requires side=long or side=short.',
+    );
+  }
+
+  const orderType = optionalParam(node, 'order_type', 'orderType') ?? 'limit';
+  const triggerPrice = optionalParam(node, 'trigger_price', 'triggerPrice');
+  const requestedTimeInForce = optionalParam(
+    node,
+    'time_in_force',
+    'timeInForce',
+  );
+  const timeInForce = requestedTimeInForce?.toUpperCase();
+  if (timeInForce !== undefined && !['GTC', 'ALO'].includes(timeInForce)) {
+    throw new Error(
+      `metamask.perps.edit_order received unsupported time_in_force: ${timeInForce}. Supported: GTC | ALO.`,
+    );
+  }
+  const reduceOnly = optionalBooleanParam(
+    node,
+    'reduce_only',
+    'reduceOnly',
+  );
+
+  const { controller, accountAddress, network } =
+    await getCoreControllerWithSigner(input);
+
+  // Same precedence as place_order: an absolute price wins, otherwise the price
+  // is derived from live mid by offset_pct, so a recipe can reprice far from mid
+  // without hard-coding a number that only suits one market.
+  const price = await resolvePrice(input, controller, symbol);
+
+  const openOrdersBefore = await controller.getOpenOrders({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const resolved = resolveTargetOrder(input, openOrdersBefore, symbol);
+  const targetOrderId = resolved.orderId;
+  const target = resolved.order;
+
+  // Repricing should not have to restate the size. Falling back to the resting
+  // order's own size keeps a recipe free of an absolute that only suits one
+  // market — the caller still overrides it to prove a resize.
+  // Prefer the caller's size, then the resting order's own, then a size derived
+  // from a USD notional. The last case matters for a refusal proof against an
+  // order the account does not hold: there is nothing to read a size from, and
+  // editOrder validates size before it ever reports that the order could not be
+  // verified, so without one the proof never reaches the refusal it is testing.
+  let size = requestedSize ?? (target ? String(target.size ?? target.sz) : undefined);
+  if (size === undefined) {
+    const notional = optionalParam(node, 'notional', 'notional');
+    if (notional === undefined) {
+      throw new Error(
+        'metamask.perps.edit_order requires size=<contracts> or notional=<usd> when the resting order cannot be read.',
+      );
+    }
+    const mid = await currentMarketPrice(controller, symbol);
+    size = String(Number(notional) / mid);
+  }
+
+  const newOrder = {
+    symbol,
+    isBuy: side === 'long',
+    size,
+    orderType,
+    ...(price === undefined ? {} : { price }),
+    ...(triggerPrice === undefined ? {} : { triggerPrice }),
+    ...(timeInForce === undefined ? {} : { timeInForce }),
+    ...(reduceOnly === undefined ? {} : { reduceOnly: Boolean(reduceOnly) }),
+  };
+
+  const result = await controller.editOrder({
+    orderId: targetOrderId,
+    newOrder,
+  });
+  if (!result || result.success !== true) {
+    throw controllerRejection({
+      action: 'core editOrder',
+      detail: `${symbol} order ${targetOrderId}`,
+      code: result?.error ?? 'unknown error',
+    });
+  }
+  if (target === null) {
+    throw new Error(
+      `core editOrder for ${symbol} reported success for order ${targetOrderId}, but that order was not present before the edit, so no replacement can be proven.`,
+    );
+  }
+
+  // An acknowledgement is not proof, and neither is "some order is still open".
+  // Two weaker anchors were tried and both fail:
+  //   - attributes alone: an unrelated order sharing size and price satisfies it;
+  //   - the order id: a venue modify REPLACES the order, resting it under a new
+  //     id while the controller still reports the old one (observed on testnet,
+  //     target 57185095325 became 57185125383), so no id we hold is ever present.
+  // Excluding only the target id is still not enough — a lookalike that was
+  // already resting before the edit passes. So anchor on NOVELTY against a
+  // complete pre-edit snapshot: exactly one id that did not exist before, and it
+  // must carry every attribute requested, not just size and price.
+  const preEditIds = new Set(
+    openOrdersBefore.map((order) => String(order.orderId ?? order.oid)),
+  );
+  const sameNumber = (left, right) => {
+    const a = Number(left);
+    const b = Number(right);
+    return Number.isFinite(a) && Number.isFinite(b)
+      ? Math.abs(a - b) <= Math.max(1e-9, Math.abs(b) * 1e-4)
+      : String(left) === String(right);
+  };
+  const sameFlag = (actual, expected) =>
+    expected === undefined ||
+    (actual !== undefined && Boolean(actual) === Boolean(expected));
+  // The controller normalizes side to 'buy' | 'sell' (Order.side) — there is no
+  // isBuy field and never a raw 'B'. Comparing against the venue's vocabulary
+  // instead of the controller's matched nothing at all, which is how a stricter
+  // check can end up proving less than the loose one it replaced. The raw forms
+  // stay as a fallback for an unadapted payload.
+  const orderTypeOf = (order) => order.orderType ?? order.orderTypeLabel;
+  const matchesRequest = (order) =>
+    (order.symbol ?? order.coin) === symbol &&
+    sameNumber(order.size ?? order.sz, size) &&
+    (price === undefined || sameNumber(order.price ?? order.limitPx, price)) &&
+    sameFlag(isLongOrder(order), side === 'long') &&
+    sameFlag(order.reduceOnly ?? order.reduce_only, reduceOnly) &&
+    (orderType === undefined ||
+      (orderTypeOf(order) !== undefined &&
+        String(orderTypeOf(order)).toLowerCase() === String(orderType).toLowerCase()));
+
+  const deadline =
+    Date.now() +
+    Math.min(
+      Number(optionalParam(node, 'timeout_ms', 'timeoutMs') ?? 30000) * 0.6,
+      60000,
+    );
+  let openOrdersAfter = [];
+  let replacements = [];
+  let targetStillResting = true;
+  for (;;) {
+    openOrdersAfter = await controller.getOpenOrders({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    targetStillResting = openOrdersAfter.some(
+      (order) => String(order.orderId ?? order.oid) === targetOrderId,
+    );
+    replacements = openOrdersAfter.filter(
+      (order) =>
+        !preEditIds.has(String(order.orderId ?? order.oid)) && matchesRequest(order),
+    );
+    if ((!targetStillResting && replacements.length === 1) || Date.now() >= deadline) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+
+  const resting = openOrdersAfter
+    .filter((order) => (order.symbol ?? order.coin) === symbol)
+    .map(
+      (order) =>
+        `${order.orderId ?? order.oid}@${order.price ?? order.limitPx}x${order.size ?? order.sz}${preEditIds.has(String(order.orderId ?? order.oid)) ? ' (pre-existing)' : ' (new)'}`,
+    );
+  if (targetStillResting) {
+    throw new Error(
+      `core editOrder for ${symbol} reported success but the edited order ${targetOrderId} is still resting, so nothing was replaced. Resting now: ${resting.join(', ') || 'none'}.`,
+    );
+  }
+  if (replacements.length !== 1) {
+    throw new Error(
+      `core editOrder for ${symbol} reported success but ${replacements.length} newly-created orders match the request (size=${size}${price === undefined ? '' : `, price=${price}`}, side=${side}${reduceOnly === undefined ? '' : `, reduceOnly=${Boolean(reduceOnly)}`}) — expected exactly one. Resting now: ${resting.join(', ') || 'none'}.`,
+    );
+  }
+  const edited = replacements[0];
+
+  return {
+    action: input.action,
+    source: 'perps-controller-editOrder',
+    network,
+    account: accountAddress,
+    market: symbol,
+    orderId: targetOrderId,
+    editedOrderId: String(edited.orderId ?? edited.oid),
+    replacedOrderId: targetOrderId,
+    before: target ? redactOrder(target) : null,
+    requested: newOrder,
+    submitted: true,
+    verified: true,
+    orders: selectedItems(input, openOrdersAfter).map(redactOrder),
+    result,
+    proofPath: 'perps-controller-editOrder',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(editOrder);

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

@@ -1,8 +1,11 @@
 import {
   configuredSymbols,
+  controllerRejection,
   currentMarketPrice,
   getCoreControllerWithSigner,
   isDirectRun,
+  optionalBooleanParam,
+  optionalParam,
   redactOrder,
   redactPosition,
   runAdapter,
@@ -64,8 +67,8 @@ const TRIGGER_ORDER_TYPES = ORDER_TYPES.filter((type) => type.includes('_'));
 const LIMIT_EXECUTION_ORDER_TYPES = ['limit', 'stop_limit', 'take_profit_limit'];
 
 function resolveOrderType(input) {
-  const raw = String(
-    input.node?.order_type ?? input.node?.orderType ?? 'market',
+  const raw = (
+    optionalParam(input.node ?? {}, 'order_type', 'orderType') ?? 'market'
   ).toLowerCase();
   if (!ORDER_TYPES.includes(raw)) {
     throw new Error(
@@ -91,8 +94,12 @@ const isLimitExecution = (orderType) => LIMIT_EXECUTION_ORDER_TYPES.includes(ord
  * @param mid - Current mid price.
  */
 function resolveTriggerPrice(input, orderType, isBuy, mid) {
-  const absolute = input.node?.trigger_price ?? input.node?.triggerPrice;
-  if (absolute !== undefined && absolute !== null && String(absolute).length > 0) {
+  const absolute = optionalParam(
+    input.node ?? {},
+    'trigger_price',
+    'triggerPrice',
+  );
+  if (absolute !== undefined) {
     const numeric = Number(absolute);
     if (!Number.isFinite(numeric) || numeric <= 0) {
       throw new Error(
@@ -101,7 +108,11 @@ function resolveTriggerPrice(input, orderType, isBuy, mid) {
     }
     return numeric;
   }
-  const rawOffset = input.node?.trigger_offset_pct ?? input.node?.triggerOffsetPct;
+  const rawOffset = optionalParam(
+    input.node ?? {},
+    'trigger_offset_pct',
+    'triggerOffsetPct',
+  );
   const isStop = orderType.startsWith('stop');
   // A stop fires against the position: below mid when selling to close a long.
   const defaultOffset = isStop === isBuy ? 30 : -30;
@@ -121,27 +132,96 @@ function resolveTriggerPrice(input, orderType, isBuy, mid) {
   return price;
 }
 
+/**
+ * Resolve a trigger price set on a placement that is not a trigger type.
+ *
+ * Such a value is a caller mistake, which the controller reports as
+ * ORDER_TRIGGER_PRICE_NOT_SUPPORTED. It has to reach the controller in either
+ * spelling to be reported: accepting only the absolute form meant an offset was
+ * silently dropped and the order placed for real instead of being refused.
+ *
+ * @param input - Adapter input (node.trigger_price / node.trigger_offset_pct).
+ * @param mid - Current mid price, for the offset spelling.
+ * @returns The stray trigger price, or undefined when the node set none.
+ */
+function resolveStrayTriggerPrice(input, mid) {
+  const node = input.node ?? {};
+  const absolute = optionalParam(node, 'trigger_price', 'triggerPrice');
+  if (absolute !== undefined) {
+    return absolute;
+  }
+
+  const rawOffset = optionalParam(
+    node,
+    'trigger_offset_pct',
+    'triggerOffsetPct',
+  );
+  if (rawOffset === undefined) {
+    return undefined;
+  }
+
+  const offsetPct = Number(rawOffset);
+  if (!Number.isFinite(offsetPct)) {
+    throw new Error(
+      `metamask.perps.place_order received invalid trigger_offset_pct: ${rawOffset}.`,
+    );
+  }
+  return String(mid * (1 + offsetPct / 100));
+}
+
 /**
  * Collect the attached TP/SL fields, using the controller's own param names.
  *
  * @param input - Adapter input.
  * @returns Attached TP/SL params, omitting anything the node did not set.
  */
-function resolveAttachedTpsl(input) {
+function resolveAttachedTpsl(input, mid) {
   const node = input.node ?? {};
-  const pick = (snake, camel) => {
-    const value = node[snake] ?? node[camel];
-    return value === undefined || value === null ? undefined : String(value);
+  const pick = (snake, camel) => optionalParam(node, snake, camel);
+
+  // An absolute price only holds for one market at one moment, so offsets from
+  // live mid are the preferred spelling; an explicit price still wins.
+  const fromOffset = (snake, camel, name) => {
+    const raw = pick(snake, camel);
+    if (raw === undefined) {
+      return undefined;
+    }
+    const pct = Number(raw);
+    if (!Number.isFinite(pct)) {
+      throw new Error(
+        `metamask.perps.place_order received invalid ${name}: ${raw}.`,
+      );
+    }
+    const price = mid * (1 + pct / 100);
+    if (!Number.isFinite(price) || price <= 0) {
+      throw new Error(
+        `metamask.perps.place_order computed a non-positive price from ${name}=${raw}.`,
+      );
+    }
+    return String(price);
   };
+
   const attached = {
-    takeProfitPrice: pick('take_profit_price', 'takeProfitPrice'),
+    takeProfitPrice:
+      pick('take_profit_price', 'takeProfitPrice') ??
+      fromOffset(
+        'take_profit_offset_pct',
+        'takeProfitOffsetPct',
+        'take_profit_offset_pct',
+      ),
     takeProfitSize: pick('take_profit_size', 'takeProfitSize'),
-    stopLossPrice: pick('stop_loss_price', 'stopLossPrice'),
+    stopLossPrice:
+      pick('stop_loss_price', 'stopLossPrice') ??
+      fromOffset(
+        'stop_loss_offset_pct',
+        'stopLossOffsetPct',
+        'stop_loss_offset_pct',
+      ),
     stopLossSize: pick('stop_loss_size', 'stopLossSize'),
   };
-  const linkage = node.tpsl_linkage ?? node.tpslLinkage;
-  if (linkage !== undefined && linkage !== null) {
-    attached.tpslLinkage = String(linkage);
+  const linkage = optionalParam(node, 'tpsl_linkage', 'tpslLinkage');
+  if (linkage !== undefined) {
+    attached.tpslLinkage = linkage;
   }
   return Object.fromEntries(
     Object.entries(attached).filter(([, value]) => value !== undefined),
@@ -159,15 +239,18 @@ function resolveAttachedTpsl(input) {
  * @param mid - Current mid price.
  */
 function resolveLimitPrice(input, isBuy, mid) {
-  const absolute = input.node?.limit_price ?? input.node?.limitPrice ?? input.node?.price;
-  if (absolute !== undefined && absolute !== null && String(absolute).length > 0) {
+  const node = input.node ?? {};
+  const absolute =
+    optionalParam(node, 'limit_price', 'limitPrice') ??
+    optionalParam(node, 'price');
+  if (absolute !== undefined) {
     const numeric = Number(absolute);
     if (!Number.isFinite(numeric) || numeric <= 0) {
       throw new Error(`metamask.perps.place_order received invalid limit_price: ${absolute}.`);
     }
     return numeric;
   }
-  const rawOffset = input.node?.offset_pct ?? input.node?.offsetPct;
+  const rawOffset = optionalParam(input.node ?? {}, 'offset_pct', 'offsetPct');
   // Default far-from-mid offset so the resting order does not fill.
   const offsetPct = rawOffset === undefined || rawOffset === null ? (isBuy ? -30 : 30) : Number(rawOffset);
   if (!Number.isFinite(offsetPct)) {
@@ -182,12 +265,16 @@ function resolveLimitPrice(input, isBuy, mid) {
 
 export function resolveTriggerLimitPrice(input, isBuy, triggerPrice) {
   const node = input.node ?? {};
+  // Presence must be tested on the NORMALIZED value. A recipe cannot omit a
+  // key, so an unused param arrives as '' — and `'' !== undefined` is true, so
+  // a raw presence test reads a blank as explicit and then falls through to the
+  // far-from-mid default. For a buy trigger at 100 that silently turns 101 into
+  // 70: an unrelated price, on the wrong side, from a param nobody set.
   const hasExplicitPrice =
-    node.limit_price !== undefined ||
-    node.limitPrice !== undefined ||
-    node.price !== undefined;
+    optionalParam(node, 'limit_price', 'limitPrice') !== undefined ||
+    optionalParam(node, 'price') !== undefined;
   const hasExplicitOffset =
-    node.offset_pct !== undefined || node.offsetPct !== undefined;
+    optionalParam(node, 'offset_pct', 'offsetPct') !== undefined;
   if (hasExplicitPrice || hasExplicitOffset) {
     return resolveLimitPrice(input, isBuy, triggerPrice);
   }
@@ -265,28 +352,54 @@ async function waitForPlacedOrder(
 
 export async function placeOrder(input) {
   const symbol = resolveSymbol(input);
-  if (input.node?.side == null) throw new Error('metamask.perps.place_order requires side=long or side=short.');
-  if (input.node?.amount == null && input.node?.notional == null) {
+  // Blank counts as absent, not as a default direction: treating '' as long
+  // would let an unset template place a real order on the wrong side.
+  const side = optionalParam(input.node ?? {}, 'side', 'side')?.toLowerCase();
+  if (side === undefined) {
+    throw new Error(
+      'metamask.perps.place_order requires side=long or side=short.',
+    );
+  }
+  const usdAmount =
+    optionalParam(input.node ?? {}, 'amount') ??
+    optionalParam(input.node ?? {}, 'notional');
+  if (usdAmount === undefined) {
     throw new Error('metamask.perps.place_order requires amount=<usd> or notional=<usd>.');
   }
   const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
-  const side = String(input.node.side).toLowerCase();
-  const isBuy = side !== 'short';
+  if (side !== 'long' && side !== 'short') {
+    throw new Error(
+      `metamask.perps.place_order received invalid side: ${side} (expected long or short).`,
+    );
+  }
+  const isBuy = side === 'long';
   const orderType = resolveOrderType(input);
-  const usdAmount = String(input.node.amount ?? input.node.notional);
-  const leverage = Number(input.node?.leverage ?? 3);
+  const leverage = Number(optionalParam(input.node ?? {}, 'leverage') ?? 3);
   const maxSlippageBps = Number(
-    input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300,
+    optionalParam(
+      input.node ?? {},
+      'max_slippage_bps',
+      'maxSlippageBps',
+    ) ?? 300,
   );
-  const postOnly = input.node?.post_only ?? input.node?.postOnly;
-  const requestedTimeInForce =
-    input.node?.time_in_force ?? input.node?.timeInForce;
-  if (
-    orderType !== 'limit' &&
-    (postOnly !== undefined || requestedTimeInForce !== undefined)
-  ) {
+  const postOnly = optionalBooleanParam(
+    input.node ?? {},
+    'post_only',
+    'postOnly',
+  );
+  const requestedTimeInForce = optionalParam(
+    input.node ?? {},
+    'time_in_force',
+    'timeInForce',
+  );
+  // The controller rejects this combination itself, with
+  // ORDER_TIME_IN_FORCE_NOT_SUPPORTED. Duplicating the check here only made the
+  // controller's own refusal unreachable, so the fields are forwarded and the
+  // controller decides. post_only has no controller equivalent, so it keeps a
+  // local guard.
+  if (orderType !== 'limit' && postOnly !== undefined) {
     throw new Error(
-      'metamask.perps.place_order supports time_in_force/post_only only for order_type=limit.',
+      'metamask.perps.place_order supports post_only only for order_type=limit.',
     );
   }
   const timeInForce =
@@ -317,9 +430,40 @@ export async function placeOrder(input) {
 
   const currentPrice = await currentMarketPrice(controller, symbol);
 
-  const reduceOnly =
-    input.node?.reduce_only ?? input.node?.reduceOnly ?? undefined;
-  const attachedTpsl = resolveAttachedTpsl(input);
+  const reduceOnly = optionalBooleanParam(
+    input.node ?? {},
+    'reduce_only',
+    'reduceOnly',
+  );
+  const attachedTpsl = resolveAttachedTpsl(input, currentPrice);
+
+  // A non-trigger placement used to drop a stray trigger price or time in
+  // force. Silently discarding a field the caller set is wrong on its own
+  // terms, and it also hid the controller's refusal of it. Both are forwarded
+  // verbatim now, for every request, so what is submitted never depends on what
+  // the caller expects to happen. Trigger placements resolve their own trigger
+  // price below, so this only carries the stray case.
+  // Each branch below builds its own params, so a field only that branch
+  // considers stray has to be added to all of them — forwarding on the market
+  // branch alone left a limit order silently dropping a trigger price and a
+  // trigger order silently dropping a time in force, either of which then
+  // succeeded instead of reaching the controller's refusal.
+  const isTrigger = isTriggerOrderType(orderType);
+  const strayTriggerPrice = isTrigger
+    ? undefined
+    : resolveStrayTriggerPrice(input, currentPrice);
+  // A limit order legitimately carries a time in force; every other shape does
+  // not, and the controller refuses it.
+  const strayTimeInForce =
+    orderType === 'limit' ? undefined : requestedTimeInForce;
+  const forwardedFields = {
+    ...(strayTriggerPrice === undefined
+      ? {}
+      : { triggerPrice: strayTriggerPrice }),
+    ...(strayTimeInForce === undefined
+      ? {}
+      : { timeInForce: strayTimeInForce }),
+  };
 
   let orderParams;
   let limitPrice = null;
@@ -339,6 +483,7 @@ export async function placeOrder(input) {
       isBuy,
       size,
       orderType,
+      ...forwardedFields,
       triggerPrice: String(triggerPrice),
       ...(limitPrice === null ? {} : { price: String(limitPrice) }),
       leverage,
@@ -358,6 +503,7 @@ export async function placeOrder(input) {
       isBuy,
       size,
       orderType: 'limit',
+      ...forwardedFields,
       price: String(limitPrice),
       timeInForce,
       leverage,
@@ -374,6 +520,7 @@ export async function placeOrder(input) {
       isBuy,
       size,
       orderType: 'market',
+      ...forwardedFields,
       leverage,
       usdAmount,
       currentPrice,
@@ -386,9 +533,11 @@ export async function placeOrder(input) {
 
   const result = await controller.placeOrder(orderParams);
   if (!result || result.success !== true) {
-    throw new Error(
-      `core placeOrder failed for ${symbol} (${orderType}): ${result?.error ?? 'unknown error'} (currentPrice=${currentPrice}${limitPrice ? `, limitPrice=${limitPrice}` : ''}).`,
-    );
+    throw controllerRejection({
+      action: 'core placeOrder',
+      detail: `${symbol} (${orderType}), currentPrice=${currentPrice}${limitPrice ? `, limitPrice=${limitPrice}` : ''}`,
+      code: result?.error ?? 'unknown error',
+    });
   }
 
   // For limit orders, confirm a RESTING open order exists (not a filled position);
@@ -410,7 +559,7 @@ export async function placeOrder(input) {
         size: result.submittedSize ?? orderParams.size,
         reduceOnly: orderParams.reduceOnly ?? false,
       },
-      Number(input.node?.timeout_ms ?? 30000),
+      Number(optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000),
     );
   } else {
     positions = await controller.getPositions({