@deeeed/metamask-harness 0.23.1 → 0.24.0

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

@@ -1,7 +1,9 @@
 import {
   configuredSymbols,
+  controllerRejection,
   getCoreControllerWithSigner,
   isDirectRun,
+  optionalParam,
   redactOrder,
   requireExplicitSelection,
   runAdapter,
@@ -22,11 +24,6 @@ import {
 // 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);
@@ -94,12 +91,21 @@ export async function updatePositionTpsl(input) {
   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');
+  let takeProfitPrice = optionalParam(node, 'take_profit_price', 'takeProfitPrice');
+  let stopLossPrice = optionalParam(node, 'stop_loss_price', 'stopLossPrice');
+  let takeProfitSize = optionalParam(node, 'take_profit_size', 'takeProfitSize');
+  let stopLossSize = optionalParam(node, 'stop_loss_size', 'stopLossSize');
+  const takeProfitOffsetPct = optionalParam(node, 'take_profit_offset_pct', 'takeProfitOffsetPct');
+  const stopLossOffsetPct = optionalParam(node, 'stop_loss_offset_pct', 'stopLossOffsetPct');
+  const takeProfitFraction = optionalParam(node, 'take_profit_fraction', 'takeProfitFraction');
+  const stopLossFraction = optionalParam(node, 'stop_loss_fraction', 'stopLossFraction');
 
-  if (takeProfitPrice === undefined && stopLossPrice === undefined) {
+  if (
+    takeProfitPrice === undefined &&
+    stopLossPrice === undefined &&
+    takeProfitOffsetPct === undefined &&
+    stopLossOffsetPct === 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).',
     );
@@ -120,6 +126,93 @@ export async function updatePositionTpsl(input) {
     );
   }
 
+  // Prices and sizes are resolved from live mid and the actual position, so a
+  // recipe never has to name a number that only holds for one market at one
+  // moment. An absolute value still wins when the caller gives one.
+  // Both derivations below need the market, and each used to fetch it
+  // separately. getMarketDataWithPrices reads every market, so doing it twice in
+  // one adapter is what pushed this past the node timeout.
+  let market;
+  const readMarket = async () => {
+    if (market === undefined) {
+      const markets = await controller.getMarketDataWithPrices({
+        standalone: true,
+      });
+      market =
+        (Array.isArray(markets) ? markets : []).find(
+          (item) => (item?.symbol ?? '').toUpperCase() === symbol.toUpperCase(),
+        ) ?? null;
+    }
+    return market;
+  };
+
+  if (takeProfitOffsetPct !== undefined || stopLossOffsetPct !== undefined) {
+    // PerpsMarketData.price is a formatted string like '$103,245.00'.
+    const mid = Number(
+      String((await readMarket())?.price ?? '').replace(/[$,\s]/gu, ''),
+    );
+    if (!Number.isFinite(mid) || mid <= 0) {
+      throw new Error(
+        `metamask.perps.update_position_tpsl found no usable mid for ${symbol}.`,
+      );
+    }
+    const fromOffset = (raw, name) => {
+      const pct = Number(raw);
+      if (!Number.isFinite(pct)) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl received invalid ${name}: ${raw}.`,
+        );
+      }
+      const price = mid * (1 + pct / 100);
+      if (!Number.isFinite(price) || price <= 0) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl computed a non-positive price from ${name}=${raw}.`,
+        );
+      }
+      return String(price);
+    };
+    if (takeProfitPrice === undefined && takeProfitOffsetPct !== undefined) {
+      takeProfitPrice = fromOffset(takeProfitOffsetPct, 'take_profit_offset_pct');
+    }
+    if (stopLossPrice === undefined && stopLossOffsetPct !== undefined) {
+      stopLossPrice = fromOffset(stopLossOffsetPct, 'stop_loss_offset_pct');
+    }
+  }
+
+  if (takeProfitFraction !== undefined || stopLossFraction !== undefined) {
+    const absolutePositionSize = Math.abs(Number(position.size ?? position.szi ?? 0));
+    // Round to the market's own size precision before submitting. The venue
+    // rounds anyway, and the read-back below matches on size — so an unrounded
+    // fraction asks for a size that can never come back, and the poll spins
+    // until it times out.
+    const szDecimals = Number((await readMarket())?.szDecimals);
+    const fromFraction = (raw, name) => {
+      const fraction = Number(raw);
+      if (!Number.isFinite(fraction) || fraction <= 0 || fraction > 1) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl received invalid ${name}: ${raw} (expected a fraction in (0, 1]).`,
+        );
+      }
+      const exact = absolutePositionSize * fraction;
+      if (!Number.isFinite(szDecimals)) {
+        return String(exact);
+      }
+      const rounded = Number(exact.toFixed(szDecimals));
+      if (rounded <= 0) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl: ${name}=${raw} of a ${absolutePositionSize} position rounds to zero at ${szDecimals} size decimals; use a larger position or a larger fraction.`,
+        );
+      }
+      return String(rounded);
+    };
+    if (takeProfitSize === undefined && takeProfitFraction !== undefined) {
+      takeProfitSize = fromFraction(takeProfitFraction, 'take_profit_fraction');
+    }
+    if (stopLossSize === undefined && stopLossFraction !== undefined) {
+      stopLossSize = fromFraction(stopLossFraction, 'stop_loss_fraction');
+    }
+  }
+
   const params = {
     symbol,
     ...(takeProfitPrice === undefined ? {} : { takeProfitPrice }),
@@ -130,9 +223,11 @@ export async function updatePositionTpsl(input) {
 
   const result = await controller.updatePositionTPSL(params);
   if (!result || result.success !== true) {
-    throw new Error(
-      `core updatePositionTPSL failed for ${symbol}: ${result?.error ?? 'unknown error'}.`,
-    );
+    throw controllerRejection({
+      action: 'core updatePositionTPSL',
+      detail: symbol,
+      code: result?.error ?? 'unknown error',
+    });
   }
 
   const requests = [
@@ -156,12 +251,23 @@ export async function updatePositionTpsl(input) {
     accountAddress,
     input,
     requests,
-    Number(input.node?.timeout_ms ?? 30000),
+    // Poll for only part of the node's budget. Spending all of it means the
+    // runner kills this adapter before the mismatch below can be reported, so a
+    // read-back that never matches surfaces as an opaque timeout instead of
+    // saying which trigger order was missing.
+    Math.min(
+      Number(
+        optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000,
+      ) * 0.6,
+      60000,
+    ),
   );
 
   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.`,
+      `core updatePositionTPSL for ${symbol} reported success but only ${triggerOrders.length}/${requests.length} requested trigger orders are visible. Requested: ${JSON.stringify(
+        requests,
+      )}.`,
     );
   }