@deeeed/metamask-harness 0.23.1 → 0.25.0

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

@@ -1,6 +1,7 @@
 import {
   getCoreController,
   isDirectRun,
+  optionalParam,
   redactOrder,
   requireExplicitSelection,
   runAdapter,
@@ -19,6 +20,123 @@ import {
 // expect_size (proves a partial TP/SL quantity). They use the controller's own
 // field names (triggerOrderType, triggerPrice, orderType, reduceOnly, size).
 
+// A count proves only how many orders exist, never that one is the linked TP/SL
+// the caller asked for: two unrelated orders satisfy `expect_count: 2` just as
+// well as a parent and its child. So assert the LINK the controller exposes —
+// the parent's own takeProfitOrderId / stopLossOrderId — and that the id it
+// names is really resting as a reduce-only trigger.
+export function expectedChildLinks(input) {
+  const node = input.node ?? {};
+  const wanted = [];
+  const truthy = (value) =>
+    value !== undefined && value !== null && String(value).trim() !== '' &&
+    String(value).toLowerCase() !== 'false';
+  if (truthy(optionalParam(node, 'expect_take_profit_child', 'expectTakeProfitChild'))) {
+    wanted.push({ label: 'take profit', idField: 'takeProfitOrderId' });
+  }
+  if (truthy(optionalParam(node, 'expect_stop_loss_child', 'expectStopLossChild'))) {
+    wanted.push({ label: 'stop loss', idField: 'stopLossOrderId' });
+  }
+  return wanted;
+}
+
+export function assertChildLinks(matching, allOrders, wanted) {
+  const resolved = [];
+  if (wanted.length === 0) return resolved;
+
+  const hasLink = (order, idField) =>
+    order[idField] !== undefined && String(order[idField]).trim() !== '';
+  const parent = matching.find((order) =>
+    wanted.every(({ idField }) => hasLink(order, idField)),
+  );
+  if (!parent) {
+    throw new Error(
+      `Expected one matching order to expose ${wanted.map(({ idField }) => idField).join(' and ')}, but none did. Matching orders: ${JSON.stringify(matching.map((order) => ({ id: order.orderId, takeProfitOrderId: order.takeProfitOrderId, stopLossOrderId: order.stopLossOrderId })))}.`,
+    );
+  }
+
+  const normalizedSide = (order) => {
+    const value = String(order.side ?? order.dir ?? '').toLowerCase();
+    if (value === 'buy' || value === 'b' || value.includes('long')) return 'buy';
+    if (value === 'sell' || value === 'a' || value.includes('short')) return 'sell';
+    return undefined;
+  };
+  const parentSymbol = parent.symbol ?? parent.coin;
+  const parentSide = normalizedSide(parent);
+
+  for (const { label, idField } of wanted) {
+    const isTakeProfit = idField === 'takeProfitOrderId';
+    const priceField = isTakeProfit ? 'takeProfitPrice' : 'stopLossPrice';
+    const triggerFamily = isTakeProfit ? 'take_profit_' : 'stop_';
+    const childId = String(parent[idField]);
+    const child = allOrders.find(
+      (order) => String(order.orderId ?? order.oid) === childId,
+    );
+    if (!child) {
+      throw new Error(
+        `Order ${parent.orderId} names ${idField}=${childId} as its ${label} child, but no such order is live — the child was dropped after being linked.`,
+      );
+    }
+    if (child.reduceOnly !== true) {
+      throw new Error(
+        `The ${label} child ${childId} is live but not reduce-only, so it would open exposure rather than close it.`,
+      );
+    }
+    if (child.isTrigger !== true) {
+      throw new Error(
+        `The ${label} child ${childId} is live but is not a trigger order, so it cannot fire as a ${label}.`,
+      );
+    }
+    const childType = String(child.triggerOrderType ?? '').toLowerCase();
+    if (!childType.startsWith(triggerFamily)) {
+      throw new Error(
+        `The ${label} child ${childId} has triggerOrderType=${JSON.stringify(child.triggerOrderType)}, expected the ${triggerFamily} family.`,
+      );
+    }
+    const childSymbol = child.symbol ?? child.coin;
+    if (parentSymbol === undefined || childSymbol !== parentSymbol) {
+      throw new Error(
+        `The ${label} child ${childId} is on ${childSymbol ?? 'an unknown market'}, expected ${parentSymbol ?? 'the parent market'}.`,
+      );
+    }
+    const childSide = normalizedSide(child);
+    if (
+      parentSide === undefined ||
+      childSide === undefined ||
+      childSide === parentSide
+    ) {
+      throw new Error(
+        `The ${label} child ${childId} has side=${child.side ?? child.dir ?? 'unknown'}, expected the opposite of parent side=${parent.side ?? parent.dir ?? 'unknown'}.`,
+      );
+    }
+    const parentPrice = parent[priceField];
+    const childPrice = child.triggerPrice ?? child.triggerPx;
+    if (
+      parentPrice === undefined ||
+      childPrice === undefined ||
+      Number(parentPrice) !== Number(childPrice)
+    ) {
+      throw new Error(
+        `The ${label} child ${childId} has triggerPrice=${JSON.stringify(childPrice)}, expected the parent's ${priceField}=${JSON.stringify(parentPrice)}.`,
+      );
+    }
+    resolved.push({
+      link: idField,
+      parentOrderId: String(parent.orderId ?? parent.oid),
+      childOrderId: childId,
+      child: {
+        symbol: childSymbol,
+        side: childSide,
+        triggerOrderType: child.triggerOrderType,
+        triggerPrice: childPrice,
+        size: child.size ?? child.sz,
+        reduceOnly: child.reduceOnly,
+      },
+    });
+  }
+  return resolved;
+}
+
 export function expectedOpen(input) {
   if (input.node?.state == null) throw new Error('metamask.perps.assert_orders requires state=open or state=none.');
   const state = String(input.node.state).toLowerCase();
@@ -40,23 +158,42 @@ export function expectedOpen(input) {
  * @returns True when only trigger orders should be considered.
  */
 export function onlyTriggerOrders(input) {
-  const value = input.node?.only_trigger_orders ?? input.node?.onlyTriggerOrders;
+  const value = optionalParam(
+    input.node ?? {},
+    'only_trigger_orders',
+    'onlyTriggerOrders',
+  );
   return value === true || String(value).toLowerCase() === 'true';
 }
 
 export function expectedTriggerData(input) {
   const node = input.node ?? {};
+  const pick = (snake, camel) => {
+    const normalize = (value) =>
+      typeof value === 'string' && value.trim().length === 0
+        ? undefined
+        : value ?? undefined;
+    return normalize(node[snake]) ?? normalize(node[camel]);
+  };
   const expectations = {
-    triggerOrderType:
-      node.expect_trigger_order_type ?? node.expectTriggerOrderType,
-    triggerPrice: node.expect_trigger_price ?? node.expectTriggerPrice,
-    orderType: node.expect_execution ?? node.expectExecution,
-    reduceOnly: node.expect_reduce_only ?? node.expectReduceOnly,
-    size: node.expect_size ?? node.expectSize,
+    triggerOrderType: pick(
+      'expect_trigger_order_type',
+      'expectTriggerOrderType',
+    ),
+    triggerPrice: pick('expect_trigger_price', 'expectTriggerPrice'),
+    orderType: pick('expect_execution', 'expectExecution'),
+    reduceOnly: pick('expect_reduce_only', 'expectReduceOnly'),
+    size: pick('expect_size', 'expectSize'),
   };
+  // A blank expectation is an unset recipe template, not a demand that the
+  // value equal ''. Keeping it turned an unused param into an assertion against
+  // an empty string — which for a price compares as 0.
   return Object.fromEntries(
     Object.entries(expectations).filter(
-      ([, value]) => value !== undefined && value !== null,
+      ([, value]) =>
+        value !== undefined &&
+        value !== null &&
+        !(typeof value === 'string' && value.trim().length === 0),
     ),
   );
 }
@@ -103,8 +240,15 @@ export function assertTriggerData(orders, expectations) {
 export async function assertOrders(input, expectOpen = expectedOpen(input)) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
-  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const timeoutMs = Number(
+    optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 0,
+  );
   const deadline = Date.now() + Math.max(0, timeoutMs);
+  const expectedCount = optionalParam(
+    input.node ?? {},
+    'expect_count',
+    'expectCount',
+  );
   let orders;
   let matching;
   while (true) {
@@ -118,7 +262,13 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
       // applied to an unrelated parent order resting alongside them.
       matching = matching.filter((order) => order.isTrigger === true);
     }
-    if (expectOpen ? matching.length > 0 : matching.length === 0) break;
+    // When an exact count is demanded, stopping at the first positive result
+    // reads a mid-replace moment as final: the previous order may not have been
+    // swept yet, or the new one not yet placed. Wait for the count itself.
+    const reached = expectedCount === undefined
+      ? matching.length > 0
+      : matching.length === Number(expectedCount);
+    if (expectOpen ? reached : matching.length === 0) break;
     if (Date.now() >= deadline) break;
     await new Promise((resolve) =>
       setTimeout(resolve, Math.min(500, Math.max(1, deadline - Date.now()))),
@@ -130,9 +280,20 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
     throw new Error('Expected at least one matching open Perps order, but found none.');
   }
 
+  // "at least one" cannot distinguish a clean replace from one that added a
+  // second order beside the first, so a caller can pin the exact count.
+  if (expectedCount !== undefined && matching.length !== Number(expectedCount)) {
+    throw new Error(
+      `Expected exactly ${expectedCount} matching open Perps order(s), but found ${matching.length}.`,
+    );
+  }
+
   const triggerExpectations = expectedTriggerData(input);
+  const childLinks = expectedChildLinks(input);
+  let resolvedChildLinks = [];
   if (expectOpen) {
     assertTriggerData(matching, triggerExpectations);
+    resolvedChildLinks = assertChildLinks(matching, orders, childLinks);
   }
   if (!expectOpen && hasOrder) {
     throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
@@ -146,7 +307,10 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
     expectedOpen: expectOpen,
     expectedTrigger:
       Object.keys(triggerExpectations).length === 0 ? null : triggerExpectations,
+    expectedChildLinks: childLinks.map((link) => link.idField),
+    resolvedChildLinks,
     matchingCount: matching.length,
+    expectedCount: expectedCount === undefined ? null : Number(expectedCount),
     orders: matching.map(redactOrder),
     proofPath: 'perps-controller-getOpenOrders',
   };

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

@@ -2,6 +2,7 @@ import {
   getCoreController,
   isDirectRun,
   redactPosition,
+  optionalParam,
   requireExplicitSelection,
   runAdapter,
   selectedItems,
@@ -22,8 +23,15 @@ export function expectedOpen(input) {
 export async function assertPositions(input, expectOpen = expectedOpen(input)) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
-  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const timeoutMs = Number(
+    optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 0,
+  );
   const deadline = Date.now() + Math.max(0, timeoutMs);
+  const expectedCount = optionalParam(
+    input.node ?? {},
+    'expect_count',
+    'expectCount',
+  );
   let positions;
   let matching;
   while (true) {
@@ -32,7 +40,10 @@ export async function assertPositions(input, expectOpen = expectedOpen(input)) {
       userAddress: accountAddress,
     });
     matching = selectedItems(input, positions);
-    if (expectOpen ? matching.length > 0 : matching.length === 0) break;
+    const reached = expectedCount === undefined
+      ? matching.length > 0
+      : matching.length === Number(expectedCount);
+    if (expectOpen ? reached : matching.length === 0) break;
     if (Date.now() >= deadline) break;
     await new Promise((resolve) =>
       setTimeout(resolve, Math.min(500, Math.max(1, deadline - Date.now()))),
@@ -43,6 +54,12 @@ export async function assertPositions(input, expectOpen = expectedOpen(input)) {
   if (expectOpen && !hasPosition) {
     throw new Error('Expected at least one matching open Perps position, but found none.');
   }
+
+  if (expectedCount !== undefined && matching.length !== Number(expectedCount)) {
+    throw new Error(
+      `Expected exactly ${expectedCount} matching open Perps position(s), but found ${matching.length}.`,
+    );
+  }
   if (!expectOpen && hasPosition) {
     throw new Error(`Expected no matching open Perps positions, but found ${matching.length}.`);
   }
@@ -54,6 +71,7 @@ export async function assertPositions(input, expectOpen = expectedOpen(input)) {
     account: accountAddress,
     expectedOpen: expectOpen,
     matchingCount: matching.length,
+    expectedCount: expectedCount === undefined ? null : Number(expectedCount),
     positions: matching.map(redactPosition),
     proofPath: 'perps-controller-getPositions',
   };

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