@deeeed/metamask-harness 0.23.0 → 0.24.0

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

@@ -1,4 +1,5 @@
 import {
+  controllerRejection,
   getCoreControllerWithSigner,
   isDirectRun,
   redactOrder,
@@ -6,6 +7,7 @@ import {
   runAdapter,
   selectedItems,
   symbolForItem,
+  optionalParam,
 } from './_controller.mjs';
 
 // core Cancel selected live Perps open orders on HyperLiquid testnet by driving
@@ -37,10 +39,24 @@ async function waitForOrdersAbsent(controller, accountAddress, symbols, timeoutM
   }
 }
 
+export function cancelOrdersFailure(result) {
+  if (!result) return 'unknown error';
+  const failed = Array.isArray(result.results)
+    ? result.results.find((entry) => entry?.success !== true)
+    : undefined;
+  const hasFailure =
+    result.success !== true ||
+    Number(result.failureCount ?? 0) > 0 ||
+    failed !== undefined;
+  return hasFailure ? failed?.error ?? 'unknown error' : undefined;
+}
+
 export async function closeOrders(input) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
-  const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+  const timeoutMs = Number(
+    optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000,
+  );
 
   const orders = await controller.getOpenOrders({
     standalone: true,
@@ -66,10 +82,13 @@ export async function closeOrders(input) {
   // Cancel by the selected symbols. cancelOrders() filters the active provider's
   // open orders to these symbols and batch-cancels them on the exchange.
   const result = await controller.cancelOrders({ symbols });
-  if (!result || result.success !== true) {
-    throw new Error(
-      `core cancelOrders failed for ${JSON.stringify(symbols)}: ${JSON.stringify(result)}`,
-    );
+  const failure = cancelOrdersFailure(result);
+  if (failure !== undefined) {
+    throw controllerRejection({
+      action: 'core cancelOrders',
+      detail: `${JSON.stringify(symbols)}: ${JSON.stringify(result)}`,
+      code: failure,
+    });
   }
 
   const after = await waitForOrdersAbsent(controller, accountAddress, symbols, timeoutMs);

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

@@ -1,4 +1,5 @@
 import {
+  controllerRejection,
   currentMarketPrice,
   getCoreControllerWithSigner,
   isDirectRun,
@@ -7,6 +8,7 @@ import {
   runAdapter,
   selectedItems,
   symbolForItem,
+  optionalParam,
 } from './_controller.mjs';
 
 // core Close selected live Perps positions on HyperLiquid testnet by driving the
@@ -36,12 +38,23 @@ async function waitForPositionsAbsent(controller, accountAddress, symbols, timeo
   }
 }
 
+export function closePositionsFailure(results) {
+  const failed = results.find((entry) => entry?.success !== true);
+  return failed ? failed.result?.error ?? 'unknown error' : undefined;
+}
+
 export async function closePositions(input) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
-  const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+  const timeoutMs = Number(
+    optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000,
+  );
   const maxSlippageBps = Number(
-    input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300,
+    optionalParam(
+      input.node ?? {},
+      'max_slippage_bps',
+      'maxSlippageBps',
+    ) ?? 300,
   );
 
   const positions = await controller.getPositions({
@@ -86,12 +99,13 @@ export async function closePositions(input) {
     if (success) successCount += 1;
   }
 
-  // A wholesale close failure must surface even if a read race shows the
-  // positions absent — mirrors close_orders, which throws on success !== true.
-  if (matching.length > 0 && successCount === 0) {
-    throw new Error(
-      `All ${matching.length} closePosition call(s) reported failure (successCount=0): ${JSON.stringify(results)}`,
-    );
+  const failure = closePositionsFailure(results);
+  if (failure !== undefined) {
+    throw controllerRejection({
+      action: 'core closePosition',
+      detail: `${matching.length} call(s): ${JSON.stringify(results)}`,
+      code: failure,
+    });
   }
 
   const after = await waitForPositionsAbsent(controller, accountAddress, symbols, timeoutMs);

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);