@deeeed/metamask-harness 0.21.0 → 0.23.0

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

@@ -27,6 +27,17 @@ import {
 // on-exchange notional (size * limitPrice) clears HyperLiquid's ~$10 minimum even
 // though the limit sits far from mid. After placing we verify the resting open
 // order exists (not a filled position).
+//
+// TRIGGER placements (order_type=stop_market | stop_limit | take_profit_market |
+// take_profit_limit) rest off-book until `trigger_price` is reached, then execute
+// as a market or limit order per the suffix. `trigger_price` is absolute, or
+// derived from mid via `trigger_offset_pct`; `*_limit` types also take the
+// execution limit price (`limit_price` / `offset_pct`). Like limit orders they are
+// verified as RESTING open orders. `reduce_only` is passed through as a
+// first-class placement flag, and `take_profit_price`/`take_profit_size` +
+// `stop_loss_price`/`stop_loss_size` (with `tpsl_linkage`) exercise attached and
+// partial TP/SL. Controller param names are used verbatim (triggerPrice,
+// reduceOnly, takeProfitSize, stopLossSize, tpslLinkage).
 
 function resolveSymbol(input) {
   const symbols = configuredSymbols(input, []);
@@ -38,16 +49,105 @@ function resolveSymbol(input) {
   return symbols[0];
 }
 
+const ORDER_TYPES = [
+  'market',
+  'limit',
+  'stop_market',
+  'stop_limit',
+  'take_profit_market',
+  'take_profit_limit',
+];
+
+const TRIGGER_ORDER_TYPES = ORDER_TYPES.filter((type) => type.includes('_'));
+
+// Order types whose price field is a real limit price the exchange must honour.
+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',
   ).toLowerCase();
-  if (raw !== 'market' && raw !== 'limit') {
-    throw new Error(`metamask.perps.place_order received unsupported order_type: ${raw}.`);
+  if (!ORDER_TYPES.includes(raw)) {
+    throw new Error(
+      `metamask.perps.place_order received unsupported order_type: ${raw}. Supported: ${ORDER_TYPES.join(' | ')}.`,
+    );
   }
   return raw;
 }
 
+const isTriggerOrderType = (orderType) => TRIGGER_ORDER_TYPES.includes(orderType);
+const isLimitExecution = (orderType) => LIMIT_EXECUTION_ORDER_TYPES.includes(orderType);
+
+/**
+ * Resolve the trigger price for a stop / take-profit placement.
+ * Precedence: absolute `trigger_price` → `trigger_offset_pct` from mid.
+ * Defaults keep the trigger far from mid so it will not fire during the proof:
+ * a stop sits below mid for a long (sell-side protection) and above for a short;
+ * a take profit sits on the opposite side.
+ *
+ * @param input - Adapter input (node.trigger_price / node.trigger_offset_pct).
+ * @param orderType - Resolved placement type.
+ * @param isBuy - Order direction.
+ * @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 numeric = Number(absolute);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+      throw new Error(
+        `metamask.perps.place_order received invalid trigger_price: ${absolute}.`,
+      );
+    }
+    return numeric;
+  }
+  const rawOffset = input.node?.trigger_offset_pct ?? input.node?.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;
+  const offsetPct =
+    rawOffset === undefined || rawOffset === null ? defaultOffset : Number(rawOffset);
+  if (!Number.isFinite(offsetPct)) {
+    throw new Error(
+      `metamask.perps.place_order received invalid trigger_offset_pct: ${rawOffset}.`,
+    );
+  }
+  const price = mid * (1 + offsetPct / 100);
+  if (!Number.isFinite(price) || price <= 0) {
+    throw new Error(
+      `metamask.perps.place_order computed a non-positive trigger price (${price}).`,
+    );
+  }
+  return price;
+}
+
+/**
+ * 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) {
+  const node = input.node ?? {};
+  const pick = (snake, camel) => {
+    const value = node[snake] ?? node[camel];
+    return value === undefined || value === null ? undefined : String(value);
+  };
+  const attached = {
+    takeProfitPrice: pick('take_profit_price', 'takeProfitPrice'),
+    takeProfitSize: pick('take_profit_size', 'takeProfitSize'),
+    stopLossPrice: pick('stop_loss_price', 'stopLossPrice'),
+    stopLossSize: pick('stop_loss_size', 'stopLossSize'),
+  };
+  const linkage = node.tpsl_linkage ?? node.tpslLinkage;
+  if (linkage !== undefined && linkage !== null) {
+    attached.tpslLinkage = String(linkage);
+  }
+  return Object.fromEntries(
+    Object.entries(attached).filter(([, value]) => value !== undefined),
+  );
+}
+
 /**
  * Resolve the resting limit price for a limit order.
  * Precedence: explicit absolute `limit_price` → `offset_pct` from mid.
@@ -80,6 +180,89 @@ function resolveLimitPrice(input, isBuy, mid) {
   return price;
 }
 
+export function resolveTriggerLimitPrice(input, isBuy, triggerPrice) {
+  const node = input.node ?? {};
+  const hasExplicitPrice =
+    node.limit_price !== undefined ||
+    node.limitPrice !== undefined ||
+    node.price !== undefined;
+  const hasExplicitOffset =
+    node.offset_pct !== undefined || node.offsetPct !== undefined;
+  if (hasExplicitPrice || hasExplicitOffset) {
+    return resolveLimitPrice(input, isBuy, triggerPrice);
+  }
+
+  return triggerPrice * (isBuy ? 1.01 : 0.99);
+}
+
+function numericValuesMatch(actual, expected) {
+  const actualNumber = Number(actual);
+  const expectedNumber = Number(expected);
+  if (!Number.isFinite(actualNumber) || !Number.isFinite(expectedNumber)) {
+    return String(actual) === String(expected);
+  }
+  const tolerance = Math.max(1e-12, Math.abs(expectedNumber) * 1e-4);
+  return Math.abs(actualNumber - expectedNumber) <= tolerance;
+}
+
+export function orderMatchesPlacement(order, expected) {
+  const orderId = order.orderId ?? order.oid ?? order.id;
+  if (
+    expected.orderId !== undefined &&
+    expected.orderId !== null &&
+    String(orderId) !== String(expected.orderId)
+  ) {
+    return false;
+  }
+  if (expected.triggerOrderType) {
+    if (order.isTrigger !== true) return false;
+    if (order.triggerOrderType !== expected.triggerOrderType) return false;
+    if (!numericValuesMatch(order.triggerPrice ?? order.triggerPx, expected.triggerPrice)) {
+      return false;
+    }
+  } else if (order.isTrigger === true) {
+    return false;
+  }
+  if (
+    expected.limitPrice !== null &&
+    expected.limitPrice !== undefined &&
+    !numericValuesMatch(order.price ?? order.limitPx ?? order.px, expected.limitPrice)
+  ) {
+    return false;
+  }
+  if (
+    expected.size !== undefined &&
+    !numericValuesMatch(order.size ?? order.sz ?? order.szi, expected.size)
+  ) {
+    return false;
+  }
+  return Boolean(order.reduceOnly) === Boolean(expected.reduceOnly);
+}
+
+async function waitForPlacedOrder(
+  controller,
+  accountAddress,
+  input,
+  expected,
+  timeoutMs,
+) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let matching = [];
+  for (;;) {
+    const openOrders = await controller.getOpenOrders({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    matching = selectedItems(input, openOrders).filter((order) =>
+      orderMatchesPlacement(order, expected),
+    );
+    if (matching.length > 0 || Date.now() >= deadline) return matching;
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.min(500, Math.max(1, deadline - Date.now()))),
+    );
+  }
+}
+
 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.');
@@ -95,6 +278,34 @@ export async function placeOrder(input) {
   const maxSlippageBps = Number(
     input.node?.max_slippage_bps ?? input.node?.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)
+  ) {
+    throw new Error(
+      'metamask.perps.place_order supports time_in_force/post_only only for order_type=limit.',
+    );
+  }
+  const timeInForce =
+    orderType === 'limit'
+      ? String(requestedTimeInForce ?? (postOnly ? 'ALO' : 'GTC')).toUpperCase()
+      : null;
+  if (timeInForce !== null && !['GTC', 'ALO'].includes(timeInForce)) {
+    throw new Error(
+      `metamask.perps.place_order received unsupported time_in_force: ${timeInForce}. Supported: GTC | ALO.`,
+    );
+  }
+  if (
+    postOnly !== undefined &&
+    Boolean(postOnly) !== (timeInForce === 'ALO')
+  ) {
+    throw new Error(
+      'metamask.perps.place_order received conflicting post_only and time_in_force values.',
+    );
+  }
 
   const usdNumeric = Number(usdAmount);
   if (!Number.isFinite(usdNumeric) || usdNumeric <= 0) {
@@ -106,9 +317,38 @@ 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);
+
   let orderParams;
   let limitPrice = null;
-  if (orderType === 'limit') {
+  let triggerPrice = null;
+  if (isTriggerOrderType(orderType)) {
+    triggerPrice = resolveTriggerPrice(input, orderType, isBuy, currentPrice);
+    if (isLimitExecution(orderType)) {
+      limitPrice = resolveTriggerLimitPrice(input, isBuy, triggerPrice);
+    }
+    // A trigger placement rests off-book and executes near the trigger, so size
+    // from the trigger price (or the execution limit price) to clear HL's ~$10
+    // minimum; omit usdAmount so the controller keeps the explicit size.
+    const sizeAnchor = limitPrice ?? triggerPrice;
+    const size = ((usdNumeric * leverage) / sizeAnchor).toString();
+    orderParams = {
+      symbol,
+      isBuy,
+      size,
+      orderType,
+      triggerPrice: String(triggerPrice),
+      ...(limitPrice === null ? {} : { price: String(limitPrice) }),
+      leverage,
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+      ...(reduceOnly === undefined ? {} : { reduceOnly: Boolean(reduceOnly) }),
+      ...attachedTpsl,
+    };
+  } else if (orderType === 'limit') {
     limitPrice = resolveLimitPrice(input, isBuy, currentPrice);
     // Size from the LIMIT price so size * limitPrice clears HL's ~$10 minimum;
     // omit usdAmount so the controller does NOT recompute size from mid.
@@ -119,11 +359,13 @@ export async function placeOrder(input) {
       size,
       orderType: 'limit',
       price: String(limitPrice),
-      timeInForce: 'GTC',
+      timeInForce,
       leverage,
       currentPrice,
       priceAtCalculation: currentPrice,
       maxSlippageBps,
+      ...(reduceOnly === undefined ? {} : { reduceOnly: Boolean(reduceOnly) }),
+      ...attachedTpsl,
     };
   } else {
     const size = ((usdNumeric * leverage) / currentPrice).toString();
@@ -137,6 +379,8 @@ export async function placeOrder(input) {
       currentPrice,
       priceAtCalculation: currentPrice,
       maxSlippageBps,
+      ...(reduceOnly === undefined ? {} : { reduceOnly: Boolean(reduceOnly) }),
+      ...attachedTpsl,
     };
   }
 
@@ -150,28 +394,38 @@ export async function placeOrder(input) {
   // For limit orders, confirm a RESTING open order exists (not a filled position);
   // for market orders, confirm the position opened. Both read the real
   // provider/exchange state (not the submit ack) before reporting success.
-  let openOrders = [];
+  const restsOnBook = orderType === 'limit' || isTriggerOrderType(orderType);
+  let matchingOrders = [];
   let positions = [];
-  if (orderType === 'limit') {
-    openOrders = await controller.getOpenOrders({
-      standalone: true,
-      userAddress: accountAddress,
-    });
+  if (restsOnBook) {
+    matchingOrders = await waitForPlacedOrder(
+      controller,
+      accountAddress,
+      input,
+      {
+        orderId: result.orderId,
+        triggerOrderType: isTriggerOrderType(orderType) ? orderType : null,
+        triggerPrice,
+        limitPrice,
+        size: result.submittedSize ?? orderParams.size,
+        reduceOnly: orderParams.reduceOnly ?? false,
+      },
+      Number(input.node?.timeout_ms ?? 30000),
+    );
   } else {
     positions = await controller.getPositions({
       standalone: true,
       userAddress: accountAddress,
     });
   }
-  const matchingOrders = selectedItems(input, openOrders);
   const matchingPositions = selectedItems(input, positions);
 
-  if (orderType === 'limit' && matchingOrders.length === 0) {
+  if (restsOnBook && matchingOrders.length === 0) {
     throw new Error(
-      `core placeOrder (limit) for ${symbol} reported success but no resting open order is visible (orderId=${result.orderId ?? 'null'}, limitPrice=${limitPrice}).`,
+      `core placeOrder (${orderType}) for ${symbol} reported success but no resting open order is visible (orderId=${result.orderId ?? 'null'}, limitPrice=${limitPrice}, triggerPrice=${triggerPrice}).`,
     );
   }
-  if (orderType === 'market' && matchingPositions.length === 0) {
+  if (!restsOnBook && matchingPositions.length === 0) {
     throw new Error(
       `core placeOrder (market) for ${symbol} reported success but no matching position is visible (orderId=${result.orderId ?? 'null'}).`,
     );
@@ -187,14 +441,18 @@ export async function placeOrder(input) {
     orderType,
     notional: usdAmount,
     leverage,
+    timeInForce,
     size: orderParams.size,
     currentPrice,
     limitPrice,
+    triggerPrice,
+    reduceOnly: orderParams.reduceOnly ?? false,
+    attachedTpsl: Object.keys(attachedTpsl).length === 0 ? null : attachedTpsl,
     submitted: true,
     orderId: result.orderId ?? null,
     filledSize: result.filledSize ?? null,
     averagePrice: result.averagePrice ?? null,
-    matchingCount: orderType === 'limit' ? matchingOrders.length : matchingPositions.length,
+    matchingCount: restsOnBook ? matchingOrders.length : matchingPositions.length,
     orders: matchingOrders.map(redactOrder),
     positions: matchingPositions.map(redactPosition),
     order: result,

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

@@ -0,0 +1,185 @@
+import {
+  configuredSymbols,
+  getCoreControllerWithSigner,
+  isDirectRun,
+  redactOrder,
+  requireExplicitSelection,
+  runAdapter,
+  selectedItems,
+} from './_controller.mjs';
+
+// core Set or replace the TP/SL attached to an existing Perps POSITION by driving
+// the headless PerpsController.updatePositionTPSL() through the full
+// signing/provider path. This is the position-bound half of the advanced-order
+// contract (TAT-3511): it covers both whole-position TP/SL and PARTIAL
+// (quantity-scoped) TP/SL, which the provider must express as standalone
+// reduce-only trigger orders because a position-bound TP/SL always closes the
+// whole position.
+//
+// Params use the controller's own provider-agnostic names: take_profit_price /
+// take_profit_size / stop_loss_price / stop_loss_size (camelCase aliases
+// accepted). Omitting a price removes that side; omitting a size covers the
+// whole position. After submitting we re-read live open orders so the resulting
+// trigger orders — including their partial sizes — are visible as evidence.
+
+function optionalString(node, snake, camel) {
+  const value = node?.[snake] ?? node?.[camel];
+  return value === undefined || value === null ? undefined : String(value);
+}
+
+function numericValuesMatch(actual, expected) {
+  const actualNumber = Number(actual);
+  const expectedNumber = Number(expected);
+  if (!Number.isFinite(actualNumber) || !Number.isFinite(expectedNumber)) {
+    return String(actual) === String(expected);
+  }
+  const tolerance = Math.max(1e-12, Math.abs(expectedNumber) * 1e-4);
+  return Math.abs(actualNumber - expectedNumber) <= tolerance;
+}
+
+export function orderMatchesTpslRequest(order, request) {
+  if (order.isTrigger !== true || order.reduceOnly !== true) return false;
+  if (order.triggerOrderType !== request.triggerOrderType) return false;
+  if (
+    !numericValuesMatch(
+      order.triggerPrice ?? order.triggerPx,
+      request.triggerPrice,
+    )
+  ) {
+    return false;
+  }
+  return (
+    request.size === undefined ||
+    numericValuesMatch(order.size ?? order.sz ?? order.szi, request.size)
+  );
+}
+
+async function waitForRequestedTpsl(
+  controller,
+  accountAddress,
+  input,
+  requests,
+  timeoutMs,
+) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let matching = [];
+  for (;;) {
+    const openOrders = await controller.getOpenOrders({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    const selected = selectedItems(input, openOrders);
+    matching = requests
+      .map((request) =>
+        selected.find((order) => orderMatchesTpslRequest(order, request)),
+      )
+      .filter(Boolean);
+    if (matching.length === requests.length || Date.now() >= deadline) {
+      return matching;
+    }
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.min(500, Math.max(1, deadline - Date.now()))),
+    );
+  }
+}
+
+export async function updatePositionTpsl(input) {
+  requireExplicitSelection(input);
+  const symbols = configuredSymbols(input, []);
+  if (symbols.length !== 1) {
+    throw new Error(
+      `metamask.perps.update_position_tpsl requires exactly one market; got ${JSON.stringify(symbols)}.`,
+    );
+  }
+  const symbol = symbols[0];
+
+  const node = input.node ?? {};
+  const takeProfitPrice = optionalString(node, 'take_profit_price', 'takeProfitPrice');
+  const stopLossPrice = optionalString(node, 'stop_loss_price', 'stopLossPrice');
+  const takeProfitSize = optionalString(node, 'take_profit_size', 'takeProfitSize');
+  const stopLossSize = optionalString(node, 'stop_loss_size', 'stopLossSize');
+
+  if (takeProfitPrice === undefined && stopLossPrice === undefined) {
+    throw new Error(
+      'metamask.perps.update_position_tpsl requires take_profit_price and/or stop_loss_price (omit both only to clear, which is not supported here).',
+    );
+  }
+
+  const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
+
+  // The controller resolves the position itself when none is passed; read it
+  // first so the proof records what the TP/SL was attached to.
+  const positions = await controller.getPositions({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const position = positions.find((item) => (item.symbol ?? item.coin) === symbol);
+  if (!position) {
+    throw new Error(
+      `metamask.perps.update_position_tpsl found no open ${symbol} position to attach TP/SL to.`,
+    );
+  }
+
+  const params = {
+    symbol,
+    ...(takeProfitPrice === undefined ? {} : { takeProfitPrice }),
+    ...(stopLossPrice === undefined ? {} : { stopLossPrice }),
+    ...(takeProfitSize === undefined ? {} : { takeProfitSize }),
+    ...(stopLossSize === undefined ? {} : { stopLossSize }),
+  };
+
+  const result = await controller.updatePositionTPSL(params);
+  if (!result || result.success !== true) {
+    throw new Error(
+      `core updatePositionTPSL failed for ${symbol}: ${result?.error ?? 'unknown error'}.`,
+    );
+  }
+
+  const requests = [
+    ...(takeProfitPrice === undefined
+      ? []
+      : [{
+          triggerOrderType: 'take_profit_limit',
+          triggerPrice: takeProfitPrice,
+          size: takeProfitSize,
+        }]),
+    ...(stopLossPrice === undefined
+      ? []
+      : [{
+          triggerOrderType: 'stop_market',
+          triggerPrice: stopLossPrice,
+          size: stopLossSize,
+        }]),
+  ];
+  const triggerOrders = await waitForRequestedTpsl(
+    controller,
+    accountAddress,
+    input,
+    requests,
+    Number(input.node?.timeout_ms ?? 30000),
+  );
+
+  if (triggerOrders.length !== requests.length) {
+    throw new Error(
+      `core updatePositionTPSL for ${symbol} reported success but only ${triggerOrders.length}/${requests.length} requested trigger orders are visible.`,
+    );
+  }
+
+  return {
+    action: input.action,
+    source: 'perps-controller-updatePositionTPSL',
+    network,
+    account: accountAddress,
+    market: symbol,
+    positionSize: position.size ?? null,
+    requested: params,
+    isPartial: takeProfitSize !== undefined || stopLossSize !== undefined,
+    submitted: true,
+    triggerOrderCount: triggerOrders.length,
+    orders: triggerOrders.map(redactOrder),
+    result,
+    proofPath: 'perps-controller-updatePositionTPSL',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(updatePositionTpsl);

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

@@ -69,12 +69,17 @@ async function activateSemanticControl(page, selector) {
 export async function openHome(page, timeoutMs) {
   const home = dataTestId('bottom-nav-home');
   const selectedHome = `${home}[aria-current="page"]`;
+  const legacyHome = dataTestId('account-overview__asset-tab');
+  const selectedLegacyHome = `${legacyHome}[aria-selected="true"]`;
   const deadline = Date.now() + timeoutMs;
   const steps = [];
   let pendingActivation;
 
   while (Date.now() < deadline) {
-    if (await hasVisibleSelector(page, selectedHome)) {
+    if (
+      (await hasVisibleSelector(page, selectedHome)) ||
+      (await hasVisibleSelector(page, selectedLegacyHome))
+    ) {
       return { method: 'visible-ui', href: await currentHref(page), steps };
     }
     const href = await currentHref(page);
@@ -83,12 +88,17 @@ export async function openHome(page, timeoutMs) {
       await pauseForUi(page);
       continue;
     }
-    if (await hasVisibleSelector(page, home)) {
-      if (pendingActivation?.selector !== home) pendingActivation = undefined;
+    const homeControl = (await hasVisibleSelector(page, home))
+      ? home
+      : (await hasVisibleSelector(page, legacyHome))
+        ? legacyHome
+        : undefined;
+    if (homeControl) {
+      if (pendingActivation?.selector !== homeControl) pendingActivation = undefined;
       if (!pendingActivation) {
-        await activateSemanticControl(page, home);
-        steps.push(home);
-        pendingActivation = { selector: home, href };
+        await activateSemanticControl(page, homeControl);
+        steps.push(homeControl);
+        pendingActivation = { selector: homeControl, href };
       }
       await pauseForUi(page);
       continue;